# Documentation PDFMonkey

> Générez des documents PDF à partir de modèles HTML via API



---

# De zéro à la génération de votre premier document

Source: https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md
## Créer un compte sur PDFMonkey

Pour créer un compte, rendez-vous sur [la page d’inscription](https://dashboard.pdfmonkey.io/register) et renseignez votre adresse email et votre mot de passe.

> [!NOTE]
> Nous ne demandons pas de confirmation du mot de passe, mais vous pouvez afficher ou masquer celui-ci en cliquant sur _Show my password_.


Une fois vos identifiants renseignés, nous vous enverrons un email d’activation. Cliquez sur le lien contenu dans cet email pour activer votre compte. **Vous ne pourrez pas vous connecter tant que votre compte n’aura pas été confirmé.**

## Se connecter

Une fois votre compte confirmé, renseignez vos identifiants sur [la page de connexion](https://dashboard.pdfmonkey.io/login) pour accéder à votre tableau de bord.

## Créer votre premier modèle

Pour créer un modèle, rendez-vous sur [la page des modèles](https://dashboard.pdfmonkey.io/templates) et cliquez sur **Create my first Template**.

Donnez un nom à votre modèle, sélectionnez le mode d’édition **Code** et choisissez le _Base Template_ nommé **Blank**.

L’éditeur de modèles s’ouvrira alors : c’est là que la magie de PDFMonkey opère.

> [!NOTE]
> Vous pouvez modifier le nom de votre modèle aussi souvent que vous le souhaitez, cela n’aura aucun impact sur vos applications clientes.


## Écrire votre premier modèle

Dans l’onglet **HTML**, insérez le code suivant :

```liquid
<p>Bonjour {{name}} !</p>
```

Dans l’onglet **CSS**, insérez le code suivant :

```css
p {
  color: #6D28D9;
  font-size: 24px;
}
```

Et enfin dans l’onglet **Test data**, insérez ceci :

```json
{
  "name": "Jean Dupont"
}
```

Vous pouvez maintenant cliquer sur le bouton **Save**, et vous devriez voir le panneau d’aperçu à droite se mettre à jour pour refléter vos modifications.

> [!NOTE]
> **Aperçu PDF réel**
>
> L’aperçu PDF que vous voyez est en réalité une version 100 % fidèle du résultat final, car il s’agit d’un véritable PDF généré avec le même processus que celui utilisé pour générer vos documents.


La dernière étape consiste à rendre votre modèle disponible pour la génération. Pour cela, cliquez sur le bouton **Publish**.

Pour en savoir plus sur la syntaxe des modèles, consultez la section [Modèles Code](https://pdfmonkey.io/fr/docs/modeles-code). Découvrez comment [utiliser les données de test](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) pour prévisualiser vos modèles.

## Générer votre premier document

Maintenant que votre modèle est prêt, rendez-vous sur [la page des documents](https://dashboard.pdfmonkey.io/documents).

Une fois sur cette page, cliquez sur le bouton **Create my first Document**. Sur la page suivante, sélectionnez votre modèle dans la liste déroulante et cliquez sur **Create a draft**.

L’éditeur de documents s’ouvrira alors, vous permettant de spécifier les données et métadonnées de votre document.

Par défaut, une copie modifiable des données de test ajoutées à votre modèle vous sera présentée. Modifions-les comme suit :

```json
{
  "name": "Spider-man"
}
```

Rendez-vous ensuite dans l’onglet **Meta data** et insérez les informations suivantes pour [personnaliser le nom du fichier PDF](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) :

```json
{
  "_filename": "bonjour-spider-man.pdf"
}
```

Cliquez sur le bouton **Save**. L’aperçu se rafraîchira et vous montrera une version à jour du PDF.

Enfin, cliquez sur **Generate**.

Et voilà ! Vous venez de générer votre tout premier document avec PDFMonkey !

Si quelque chose ne fonctionne pas, consultez la section [Dépannage](https://pdfmonkey.io/fr/docs/depannage).


---

# Visite guidée du tableau de bord

Source: https://pdfmonkey.io/fr/docs/premiers-pas/visite-guidee-du-tableau-de-bord.md

Cette page vous propose une visite rapide des principales sections du tableau de bord PDFMonkey. Chaque section renvoie vers une documentation plus détaillée pour approfondir le sujet quand vous le souhaitez.

## Modèles

![Page de la liste des modèles affichant les cartes de modèles et le sélecteur d’espace de travail](https://pdfmonkey.io/fr/docs/img/dashboard-templates-list.webp)

La page des modèles est la première chose que vous voyez après vous être connecté. Elle liste tous les modèles de votre espace de travail actuel, affichés sous forme de cartes indiquant le nom du modèle, son statut (brouillon ou publié) et sa date de dernière modification.

Depuis cette page, vous pouvez :

- **Créer un nouveau modèle** en utilisant le bouton _Create Template_ en haut de la page.
- **Dupliquer ou supprimer** un modèle depuis son menu contextuel.

Pour apprendre à créer un modèle de A à Z, consultez [Votre premier modèle (Builder)](https://pdfmonkey.io/fr/docs/modeles-builder/votre-premier-modele.md) ou la section [Modèles Code](https://pdfmonkey.io/fr/docs/modeles-code).

## Éditeur de modèles

![Éditeur de modèles avec les onglets HTML, CSS et Test Data aux côtés du panneau d’aperçu en direct](https://pdfmonkey.io/fr/docs/img/dashboard-template-editor.webp)

L’éditeur de modèles est l’endroit où vous concevez la mise en page de votre PDF et prévisualisez le résultat en temps réel. PDFMonkey propose deux modes d’édition :

- **Éditeur de code :** écrivez directement du HTML, de la CSS et du Liquid. L’éditeur comporte trois onglets : _HTML_, _CSS_ et _Test Data_. Les modifications sont reflétées dans le panneau d’aperçu à droite après enregistrement.
- **Builder :** une interface glisser-déposer qui vous permet d’assembler des pages à partir de blocs préconstruits sans écrire de code.

Le panneau d’aperçu génère un véritable PDF avec le même moteur que celui qui produit vos documents finaux : ce que vous voyez est exactement ce que vos utilisateurs recevront.

Lorsque votre modèle est prêt, cliquez sur **Publish** pour le rendre disponible à la génération de documents. Seuls les modèles publiés peuvent être utilisés pour créer des documents via l’API ou les intégrations.

Pour un guide pratique pas à pas, consultez [De zéro à la génération de votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

## Documents

![Page des documents listant les documents générés avec indicateurs de statut et filtres](https://pdfmonkey.io/fr/docs/img/dashboard-documents.webp)

La page des documents affiche tous les documents générés dans votre espace de travail. Chaque entrée indique le nom du document, le modèle à partir duquel il a été créé, son statut actuel et sa date de génération.

Les documents passent par plusieurs statuts au cours de leur cycle de vie :

- **Draft :** créé mais pas encore envoyé pour génération.
- **Pending :** en file d’attente pour la génération.
- **Generating :** en cours de rendu.
- **Success :** génération terminée, le PDF est prêt à être téléchargé.
- **Failure :** un problème est survenu lors de la génération.

Vous pouvez filtrer la liste par modèle ou par statut pour trouver rapidement des documents spécifiques. Le bouton **Create Document** vous permet de générer un document manuellement en sélectionnant un modèle et en fournissant des données JSON.

Pour une description détaillée de chaque statut, consultez [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md).

## Paramètres

![Page des paramètres affichant le nom et l’identifiant de l’espace de travail](https://pdfmonkey.io/fr/docs/img/dashboard-settings.webp)

La page des paramètres vous permet de gérer l’identité de votre espace de travail.

Depuis cette page, vous pouvez :

- **Renommer votre espace de travail :** modifiez le nom de l’espace de travail et cliquez sur _Save_ pour appliquer le changement.
- **Copier votre Workspace ID :** l’identifiant unique de votre espace de travail, utile pour contacter le support ou travailler avec l’API.


## FAQ

**Quelles sont les sections principales du tableau de bord PDFMonkey ?**

Le tableau de bord comporte quatre zones principales : Templates (listant tous les modèles de votre espace de travail), l’éditeur de modèles (pour concevoir les mises en page PDF avec du code ou le builder visuel), Documents (affichant les documents générés et leurs statuts) et Settings (pour gérer l’identité de l’espace de travail).

**Quels statuts de documents existent dans PDFMonkey ?**

Les documents passent par cinq statuts : Draft (créé mais pas mis en file d’attente), Pending (en file d’attente pour la génération), Generating (en cours de rendu), Success (PDF prêt à télécharger) et Failure (une erreur s’est produite pendant la génération).

**L'éditeur de modèles PDFMonkey affiche-t-il un vrai aperçu ?**

Oui. Le panneau d’aperçu affiche un vrai PDF en utilisant le même moteur que celui qui produit vos documents finaux : ce que vous voyez dans l’éditeur est exactement ce que vos utilisateurs recevront.


---

# Essai Pro de 30 jours PDFMonkey : fonctionnalités, limites et suite

Source: https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md
Chaque nouveau compte PDFMonkey démarre avec un **essai Pro de 30 jours** pour vous permettre d’explorer les fonctionnalités premium avant de choisir un plan. Pendant l’essai, vous avez accès aux mêmes capacités que le [plan Pro](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md#pro), sans carte bancaire requise.

## Ce que l’essai inclut {#what-the-trial-includes}

| Fonctionnalité | Essai (Pro) | Plan Free (après l’essai) |
|:---------------|:-----------:|:-------------------------:|
| Générations de documents | 300/mois | 20/mois |
| [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) (images, polices, CSS, JS via URL) | Oui | Non |
| Temps de génération max par document | 2 minutes | 30 secondes |
| [Conservation des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) | 24 heures | 24 heures |

> [!NOTE]
> **Aucun paiement requis**
>
> L’essai s’active automatiquement lorsque vous [créez votre compte](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md). Vous n’êtes jamais facturé pendant l’essai et vous n’avez rien à annuler.


## Qu’est-ce qui change à la fin de l’essai ? {#what-changes-when-the-trial-ends}

Lorsque l’essai de 30 jours expire, votre compte est **rétrogradé vers le plan Free** automatiquement. Vous n’êtes pas facturé. Les principales différences que vous remarquerez :

- **Les ressources externes cessent de fonctionner.** Les images, CSS, JavaScript et polices chargées via URL sont restreintes sur le plan Free. Les documents qui les référencent échoueront à la génération. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour la définition complète de ce qui est concerné.
- **Votre quota de génération passe à 20 documents par mois** au lieu de 300.
- **Le temps de génération max passe à 30 secondes** au lieu de 2 minutes.

> [!TIP]
> **Passez à un plan payant avant la fin de l’essai**
>
> Si les fonctionnalités de l’essai correspondent à vos besoins, [passez à un plan payant](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) à tout moment pendant ou après l’essai. Le changement prend effet immédiatement et la facturation est calculée au prorata. Consultez [Nos plans](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) pour une comparaison complète.


## Ce que vous pouvez utiliser avec le plan Free {#what-can-i-use-on-the-free-plan}

Après l’essai, les ressources suivantes continuent de fonctionner sur le plan Free car elles ne sont pas considérées comme des ressources externes :

- **Les images** chargées via [data-uri ou SVG inline](https://pdfmonkey.io/fr/docs/modeles-code/images.md)
- **La CSS** écrite directement dans l’onglet HTML ou CSS du modèle
- **La CSS** envoyée dans les données dynamiques du document et intégrée dans le HTML via une variable
- **Le JavaScript** écrit directement dans l’onglet HTML du modèle
- **Le JavaScript** stocké dans les données dynamiques du document et intégré dans le HTML via une variable
- **Les versions hébergées de Tailwind CSS** fournies par PDFMonkey (voir [Versions hébergées de Tailwind CSS](https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md#hosted-tailwind-css-versions))

Pour plus de détails sur ce qui constitue une ressource externe et ce qui n’en est pas, consultez la page dédiée [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md).

## Questions fréquentes {#faq}

**Peut-on prolonger l’essai ?**

L’essai est une fenêtre unique de 30 jours par compte. Cela dit, nous comprenons que parfois vous avez pu manquer l’essai entièrement ou que vous avez besoin de plus de temps pour évaluer le produit. Si c’est votre cas, [contactez notre équipe support](https://pdfmonkey.io/fr/docs/premiers-pas/support.md) et nous verrons ce que nous pouvons faire.

**Que deviennent mes documents à la fin de l’essai ?**

Vos documents existants ne sont pas supprimés. Ils restent accessibles selon les [paramètres de conservation](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) de vos modèles. Seules les nouvelles demandes de génération sont affectées par les limites du plan Free.

**Peut-on passer à un plan payant avant la fin de l’essai ?**

Oui. Vous pouvez [passer à n’importe quel plan payant](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) à tout moment pendant l’essai. Le changement prend effet immédiatement.

**Les documents non utilisés sont-ils reportés ?**

Non. Votre quota mensuel est réinitialisé au début de chaque cycle de facturation. Les documents non utilisés ne sont pas cumulés. Consultez [Atteindre votre quota](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md#reaching-your-quota) pour plus de détails.

## Pages associées {#related-pages}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : commencez avec votre premier modèle et document
- [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) : ce qui constitue une ressource externe et les alternatives pour le plan Free
- [Nos plans](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) : comparez tous les niveaux de plans côte à côte
- [Changer de plan](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) : fonctionnement des upgrades, downgrades et de la proratisation
- [Conservation et suppression des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : paramètres TTL et limites de conservation par plan


## FAQ

**Que comprend l’essai de 30 jours PDFMonkey ?**

L’essai vous donne un accès Pro pendant 30 jours : 300 générations de documents par mois, les ressources externes (images, polices, CSS et JS via URL) et un temps de génération maximum de 2 minutes par document.

**Que se passe-t-il à la fin de l’essai PDFMonkey ?**

Votre compte est automatiquement rétrogradé vers le plan Free sans frais. Les ressources externes cessent de fonctionner, votre quota passe à 20 documents par mois et le temps de génération maximum passe à 30 secondes.

**Faut-il une carte bancaire pour l’essai PDFMonkey ?**

Non. L’essai s’active automatiquement lorsque vous créez votre compte. Vous n’êtes jamais facturé pendant l’essai et vous n’avez rien à annuler.

**Peut-on passer à un plan payant pendant l’essai PDFMonkey ?**

Oui. Vous pouvez passer à n’importe quel plan payant à tout moment pendant l’essai. Le changement prend effet immédiatement et la facturation est calculée au prorata.


---

# Ressources externes dans PDFMonkey

Source: https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md
# Ressources externes

Les templates PDFMonkey peuvent charger des ressources depuis des URL externes — images, feuilles de styles, scripts et polices. On les appelle **ressources externes**, et leur disponibilité dépend de votre offre. Cette page explique ce qui en fait partie, comment savoir si votre template en utilise, et quoi faire si vous êtes sur le plan Free.

## Qu’est-ce qu’une ressource externe ? {#what-counts-as-an-external-resource}

Une ressource externe est tout fichier que votre template charge via une URL (`http://...` ou `https://...`). Cela inclut :

* **Les images distantes** — chargées depuis un serveur ou un CDN (les [data-uri et SVG inline](https://pdfmonkey.io/fr/docs/modeles-code/images.md) fonctionnent sur toutes les offres)
* **Les fichiers CSS** — feuilles de styles hébergées sur vos serveurs ou un CDN
* **Les fichiers JavaScript** — scripts hébergés sur vos serveurs ou un CDN
* **Les polices web** — comme Google Fonts ou Bunny Fonts
* **Les polices de l’éditeur visuel** — toute police sélectionnée dans le sélecteur de polices du builder

### Comment savoir si votre template utilise des ressources externes {#how-to-tell}

Cherchez les URL dans le code de votre template. Tout ce qui commence par `http://` ou `https://` est une ressource externe :

```html
<!-- Ressources externes -- nécessitent une offre payante -->
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<link rel="stylesheet" href="https://example.com/styles.css" />
<img src="https://example.com/logo.png" />
```

```css
/* Également externe */
@import url("https://fonts.googleapis.com/css2?family=Inter&display=swap");
```

Les ressources écrites directement dans votre template ne sont **pas** des ressources externes et fonctionnent sur toutes les offres :

```html
<!-- Ressources inline -- fonctionnent sur toutes les offres -->
<script>console.log('JS inline');</script>
<style>h1 { color: red; }</style>
<img src="data:image/png;base64,iVBOR..." />
<svg xmlns="http://www.w3.org/2000/svg">...</svg>
```

## Disponibilité par offre {#plan-availability}

Les ressources externes sont disponibles sur **toutes les offres payantes** et pendant l’**essai Pro de 30 jours**. Sur le plan Free, les documents qui référencent des ressources externes **échoueront lors de la génération**.

Pour un comparatif complet de chaque offre, consultez [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md). Pour savoir ce que l’essai débloque, consultez [Essai Pro de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md).

> [!TIP]
> **Alternatives sur le plan Free**
>
> Vous pouvez toujours créer des templates complets sur le plan Free en utilisant la CSS inline, le JavaScript inline, les images en data-uri et le SVG inline. Consultez [Ce que vous pouvez utiliser avec le plan Free](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md#what-can-i-use-on-the-free-plan) pour la liste complète.


## Ressources hébergées par PDFMonkey {#pdfmonkey-hosted-resources}

Les ressources hébergées sur les propres serveurs de PDFMonkey (`pdfmonkey-resources.s3-eu-west-3.amazonaws.com`) font exception : elles fonctionnent sur **toutes les offres**, y compris le plan Free.

L’exemple le plus courant est les builds hébergés de Tailwind CSS. Consultez [Versions hébergées de Tailwind CSS](https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md#hosted-tailwind-css-versions) pour la liste complète des versions disponibles.


## FAQ

**Peut-on utiliser des polices web dans les templates PDFMonkey ?**

Oui, mais uniquement sur les offres payantes (Starter et supérieures). Les polices web chargées via URL (ex. Google Fonts) sont considérées comme des ressources externes. Sur l’offre Free, utilisez des polices système ou intégrez les polices en Base64 data URI.

**Qu’est-ce qu’une ressource externe dans PDFMonkey ?**

Tout fichier que votre template charge via une URL (http:// ou https://) est une ressource externe. Cela inclut les images distantes, les fichiers CSS, les fichiers JavaScript, les polices web et les polices sélectionnées dans le sélecteur de polices du Builder. Le code en ligne et les data URI ne sont pas des ressources externes et fonctionnent sur toutes les offres.

**Pourquoi mes images ou polices ne se chargent-elles pas dans PDFMonkey ?**

Si vous êtes sur l’offre Free, les ressources externes (images distantes, polices web, CSS/JS externes) ne sont pas disponibles. Passez à l’offre Starter ou supérieure, ou utilisez des alternatives en ligne : data URI Base64 pour les images, SVG en ligne ou polices système.


---

# Builder vs. modèles Code

Source: https://pdfmonkey.io/fr/docs/premiers-pas/modeles-builder-vs-code.md
PDFMonkey propose deux façons de créer des modèles : le **[Builder](https://pdfmonkey.io/fr/docs/modeles-builder)** visuel et les **[modèles Code](https://pdfmonkey.io/fr/docs/modeles-code)** rédigés en HTML, CSS et Liquid. Les deux produisent des PDF de même qualité. La différence réside dans la manière de les concevoir, et il vaut mieux choisir la bonne approche avant de commencer.

## Comparaison en un coup d’œil {#builder-vs-code-templates}

| | Builder | Modèles Code |
|---|---|---|
| **Méthode de conception** | Glisser-déposer visuel | Écrire du HTML, CSS et Liquid |
| **Données dynamiques** | Panneau Logic (conditions, répétition) | Balises Liquid (`{% if %}`, `{% for %}`) |
| **Style** | Panneau Styles + éditeur Custom CSS | Contrôle CSS complet dans le modèle |
| **JavaScript** | Éditeur Custom JS + External Assets | Balises `<script>` dans le HTML du modèle |
| **Courbe d’apprentissage** | Plus faible, aucun code requis | Plus élevée, nécessite des connaissances HTML/CSS/Liquid |
| **Moteur de rendu PDF** | Chromium | Chromium |
| **Qualité du rendu** | Identique | Identique |

## Quand utiliser le Builder {#when-to-use-the-builder}

Le [Builder](https://pdfmonkey.io/fr/docs/modeles-builder) est adapté quand :

- Vous souhaitez créer des documents professionnels standards (factures, reçus, certificats, rapports) sans écrire de code.
- Des membres non techniques de l’équipe doivent créer ou modifier des modèles.
- Vous préférez une approche pointer-cliquer plutôt qu’écrire du balisage.
- Vos besoins de mise en page sont simples : en-têtes, contenu textuel, images, tableaux et sections répétées.

## Quand utiliser les modèles Code {#when-to-use-code-templates}

Les [modèles Code](https://pdfmonkey.io/fr/docs/modeles-code) sont un meilleur choix quand :

- Vous êtes à l’aise avec HTML et CSS. Vous irez plus vite en écrivant du balisage directement qu’en glissant-déposant des blocs.
- Vous avez besoin d’un contrôle au pixel près sur des mises en page multi-pages complexes avec des sauts de page personnalisés.
- Vos documents nécessitent une logique Liquid avancée : boucles imbriquées, filtres personnalisés ou conditions complexes.
- Vous avez du HTML et CSS existants que vous souhaitez réutiliser.
- Vous avez besoin de fonctionnalités pas encore disponibles dans le Builder.

## Le Builder n’utilise pas Liquid {#the-builder-does-not-use-liquid}

Les modèles du Builder utilisent **Vue** en interne, pas Liquid. Cela signifie que la syntaxe Liquid comme `{% if %}`, `{% for %}` et les filtres Liquid (`| upcase`, `| date`) ne fonctionneront pas dans le Builder. Les données dynamiques sont gérées par le moteur de templates Vue et le panneau Logic.

Une conséquence pratique : les **noms de variables qui commencent par un chiffre** ne sont pas des identifiants JavaScript valides, vous ne pouvez donc pas écrire `{{123varname}}` dans un binding texte. Utilisez la notation entre crochets sur l’objet payload à la place :

```
{{$docPayload['123varname']}}
```

Si vous venez des modèles Code, gardez à l’esprit que tout pattern spécifique à Liquid devra être repensé pour l’approche basée sur Vue du Builder.

## Peut-on basculer entre les deux ? {#can-i-switch-between-them}

En bref : non. Les modèles du Builder et les modèles Code sont des types de modèles distincts. Vous ne pouvez pas convertir un modèle Builder en modèle Code ni l’inverse. Choisissez l’approche adaptée à votre cas d’utilisation avant de commencer la conception.

> [!TIP]
> Vous hésitez ? Commencez avec le Builder. Si vous vous heurtez à une limitation, vous pouvez toujours créer un nouveau modèle Code pour ce document spécifique. De nombreuses équipes utilisent les deux approches pour différents types de documents.


## Comment le Builder fonctionne en interne {#how-the-builder-works}

Le Builder combine des composants Vue, des classes utilitaires Tailwind CSS et le moteur de rendu Chromium pour transformer votre design visuel en PDF. Vous n’avez jamais besoin d’interagir directement avec ces technologies. Le Builder et les modèles Code utilisent le même moteur Chromium, la qualité finale du PDF est donc identique. Pour les détails sur les versions de moteurs et leurs capacités, consultez [Nos moteurs](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md).

## Ce que PDFMonkey ne prend pas en charge {#what-pdfmonkey-does-not-support}

PDFMonkey ne prend pas en charge l’importation de fichiers PDF, Word ou d’autres formats existants. Les modèles doivent être construits de zéro, soit avec le Builder visuel, soit en écrivant du HTML, CSS et Liquid dans les modèles Code.


## FAQ

**Quelle est la difference entre le Builder et les modeles code dans PDFMonkey ?**

Le Builder est un editeur visuel par glisser-deposer qui utilise Vue. Les modeles code sont ecrits en HTML, CSS et Liquid. Les deux produisent des fichiers de qualite identique. Le Builder est plus facile pour les non-developpeurs ; les modeles code offrent plus de controle sur la mise en page et la logique avancee.

**Peut-on convertir un modele Builder en modele code PDFMonkey ?**

Non. Les modeles Builder et les modeles code sont des types distincts et ne peuvent pas etre convertis l’un vers l’autre. Choisissez votre approche avant de commencer.

**Le Builder PDFMonkey utilise-t-il Liquid ?**

Non. Les modeles Builder utilisent Vue, pas Liquid. La syntaxe Liquid comme {% if %}, {% for %} et les filtres Liquid ne fonctionne pas dans le Builder. Les donnees dynamiques sont gerees via le moteur de templates Vue et le panneau Logique.



---

# La syntaxe Liquid

Source: https://pdfmonkey.io/fr/docs/modeles-code/la-syntaxe-liquid.mdLiquid est un langage de templates open-source créé par Shopify. Il offre une syntaxe claire et simple que vous pouvez utiliser pour écrire vos templates PDFMonkey et les rendre hautement dynamiques.

## Comment PDFMonkey utilise Liquid

> [!NOTE]
> **Liquid v4**
>
> Nous utilisons Liquid v4 actuellement. Cela signifie que toute méthode marquée `5.0.0` ou supérieure dans la documentation officielle de Liquid ne sera pas disponible dans PDFMonkey.


Lorsque vous créez un Template en code, le HTML que vous écrivez utilise en réalité Liquid. Cela signifie que vous pouvez insérer des données dynamiques, transformer ces données, conditionner le contenu de votre template ou itérer sur des listes pour répéter du contenu.

## Un aperçu de Liquid

Voici un exemple rapide qui montre à quoi ressemble un template Liquid dans PDFMonkey. Il utilise la plupart des fonctionnalités clés que vous rencontrerez :

```liquid
<h1>Facture #{{invoiceNumber}}</h1>
<p>Date : {{"now" | date: "%d/%m/%Y"}}</p>
<p>Client : {{client.fullName}}</p>

<table>
  <tr>
    <th>Produit</th>
    <th>Qté</th>
    <th>Prix</th>
  </tr>

  {% for item in lineItems %}
    <tr>
      <td>{{item.product}}</td>
      <td>{{item.quantity}}</td>
      <td>{{item.price | times: item.quantity | with_delimiter, precision: 2}}</td>
    </tr>
  {% endfor %}
</table>

{% if client.isNewClient %}
  <p>Bienvenue ! Profitez de 10 % de réduction sur votre prochaine commande.</p>
{% endif %}
```

Dans ce court extrait, vous pouvez voir les trois éléments de base que vous utiliserez partout :

- **Les balises de sortie** `{{ }}` — insèrent des valeurs dynamiques dans le HTML. Elles peuvent accéder à des propriétés imbriquées comme `client.fullName`.
- **Les balises logiques** `{% %}` — contrôlent le flux avec des conditions (`if`/`else`), des boucles (`for`), et plus encore.
- **Les filtres** `|` — transforment les valeurs en ligne. Ici `date` formate la date courante, `times` multiplie deux nombres, et `with_delimiter` formate le résultat avec des séparateurs et des décimales.

Chacun de ces éléments est couvert en détail dans les pages ci-dessous.

## Conditions et boucles

Les conditions (`if`, `unless`, `case`) et les boucles (`for`) vous permettent de contrôler ce qui apparaît dans votre sortie. Vous pouvez afficher du contenu uniquement lorsque certains critères sont remplis, ou répéter un bloc pour chaque élément d’une liste.

- [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-code/conditions-et-boucles.md)

## Filtres

Les filtres Liquid vous permettent de transformer les données à l’intérieur de vos templates. Vous passez une valeur à travers un ou plusieurs filtres en utilisant le caractère `|` pour formater des chaînes de caractères, manipuler des nombres, travailler avec des tableaux, et bien plus.

Liquid fournit de nombreux filtres intégrés (des helpers de transformation de données) qui suffiront dans la plupart des cas. Cela dit, ayant nous-mêmes créé de nombreux templates, nous avons identifié le besoin de filtres supplémentaires que nous avons ajoutés au fil du temps.

PDFMonkey prend en charge tous les filtres Liquid standard ainsi qu’un ensemble de filtres personnalisés adaptés à la génération de documents :

- [Filtres](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md) : les filtres Liquid standard (par ex., `upcase`, `date`, `split`, `sort`) ainsi que les filtres personnalisés PDFMonkey comme `entities`, `in_time_zone`, et d’autres

## Tags et helpers

Dans le même esprit, nous étendons également l’ensemble de fonctionnalités par défaut de Liquid pour offrir des fonctionnalités qui n’ont de sens que dans le contexte de PDFMonkey.

- [Réutiliser du code](https://pdfmonkey.io/fr/docs/modeles-code/reutiliser-du-code.md) (Snippets et Partials)

> [!NOTE]
> **Documentation complète de Liquid**
>
> Cette documentation couvre les fonctionnalités Liquid les plus utiles à connaître lors de la création de Templates. Pour une documentation complète, vous pouvez vous référer à la documentation officielle hébergée sur [https://shopify.github.io/liquid/](https://shopify.github.io/liquid/)



## FAQ

**Quel langage de template PDFMonkey utilise-t-il ?**

Les modeles code PDFMonkey utilisent Liquid v4, un langage de template open source cree par Shopify. Il propose des balises de sortie {{ }} pour inserer des valeurs, des balises logiques {% %} pour les conditions et les boucles, et des filtres pour transformer les donnees.

**Peut-on utiliser les fonctionnalites Liquid v5 dans PDFMonkey ?**

Non. PDFMonkey utilise Liquid v4. Toute fonctionnalite marquee 5.0.0 ou superieure dans la documentation officielle Liquid n’est pas disponible dans les modeles PDFMonkey.

**Le Builder PDFMonkey utilise-t-il Liquid ?**

Non. Liquid n’est utilise que dans les modeles code. Les modeles Builder utilisent Vue. Si vous souhaitez utiliser la syntaxe Liquid comme {% if %} ou les filtres Liquid, utilisez un modele code.


---

# Utiliser les données dynamiques

Source: https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.mdLorsque vous générez un Document avec PDFMonkey, vous envoyez généralement des données à utiliser avec le Template que vous avez sélectionné. Les **données de test** d’un Template sont des données fictives qui ressemblent à celles que vous utiliseriez lors de la génération d’un Document. Leur but est de vous aider à construire le Template et à tester différents scénarios.

Il est généralement plus efficace de travailler avec des données de test que de construire votre Template et de le tester en générant des Documents de test. Vous obtenez une boucle de rétroaction plus courte et ne consommez pas votre quota mensuel.

Par commodité, vos données de test sont copiées comme payload du Document lors de la génération d’un Document via le dashboard. En dehors de cela, elles ne sont jamais utilisées lors de la génération de Documents via l’API.

> [!NOTE]
> **L’aperçu est un vrai PDF**
>
> Lorsque vous construisez votre Template, l’aperçu que vous voyez à droite de l’éditeur vous montre un vrai PDF. Cela signifie que si le rendu est satisfaisant dans l’aperçu, il sera identique lors de la génération d’un Document.


## Définir les données de test {#defining-test-data}

Définissez vos données de test dans l’onglet **Données de test** de l’éditeur de Template. Cela remplit deux fonctions :

* Vous aider à définir la structure que vous souhaitez utiliser pour vos données
* Fournir des données de test que vous pouvez manipuler lors de la construction de votre Template

Les données dans PDFMonkey, qu’il s’agisse de données de test pour un Template ou du payload d’un Document, sont exprimées en utilisant la syntaxe **JSON**.

Prenons l’exemple d’une commande e-commerce. Vous pourriez imaginer quelque chose comme ceci :

```json
{
  "orderId": 1234,
  "orderStatus": "pending",
  "invoiceId": null,
  "client": {
    "civility": "M.",
    "fullName": "Pierre Dupont",
    "isNewClient": true
  },
  "lineItems": [
    { "product": "Soie ultra résistante",    "quantity": 100, "price": 123.45 },
    { "product": "Composants électroniques", "quantity": 12,  "price": 12.34 }
  ]
}
```

Examinons ce que nous avons.

Nous avons des données liées à la commande avec `orderId` et `orderStatus`. Elles utilisent différents types de données, un `integer` et un `string`.

Ensuite, nous avons un `invoiceId` qui est `null` pour indiquer une valeur vide. Étant donné que notre commande est en attente, elle n’a pas encore de facture, ce qui est logique.

Les choses deviennent intéressantes avec `client` car c’est une structure imbriquée (généralement appelée « objet ») contenant ses propres données. Vous remarquerez un nouveau type de données pour `isNewClient` qui est un booléen, une valeur qui peut être `true` ou `false`.

Et enfin nous avons `lineItems` qui est une liste (généralement appelée « tableau ») de, sans surprise, lignes de commande représentées par des objets avec des propriétés pour `product`, `quantity` et `price`.

> [!NOTE]
> **Devez-vous imbriquer vos données ?**
>
> Vous n’êtes pas obligé d’utiliser une structure imbriquée si vous ne le souhaitez pas ou n’en avez pas besoin. Ici, les détails du client pourraient être définis comme `clientCivility`, `clientFullName` et `clientIsNewClient`.


## Utiliser vos données de test dans le Template

Une fois que vous avez défini vos données de test, vous les appelez dans votre Template en utilisant Liquid.

Étant donné les données que nous avons définies ci-dessus, notre HTML pourrait commencer par quelque chose comme ceci :

```liquid
<p>Commande n° {{orderId}} est actuellement {{orderStatus}}.</p>
<p>Client : {{client.civility}} {{client.fullName}}.</p>
```

Comme vous pouvez le voir, nous pouvons référencer nos éléments de données directement et utiliser un point (`.`) pour accéder aux éléments imbriqués. Ce code générerait le HTML suivant :

```html
<p>Commande n° 1234 est actuellement pending.</p>
<p>Client : M. Pierre Dupont</p>
```

Dans les guides suivants, nous apprendrons comment afficher du contenu selon une condition ou comment parcourir notre liste de lignes de commande et l’afficher correctement.

## Nommer vos variables {#naming-your-variables}

Les clés de votre payload ne doivent jamais contenir de point ni d’espace et ne doivent jamais être uniquement un nombre.

```json5 title="JSON"
{
  // Clés valides
  "someVariable": "Une valeur",              // {{someVariable}}
  "some_variable": "Une valeur",             // {{some_variable}}
  "some-variable": "Une valeur",             // {{some-variable}}
  "SomeVariable": "Une valeur",              // {{SomeVariable}}
  "somevariable": "Une valeur",              // {{somevariable}}
  "some": { "variable": "Une valeur" },      // {{some.variable}}
  "2words": "Bonjour le monde",              // {{2words}}

  // Clés invalides
  "some.variable": "Une valeur",
  "some variable": "Une valeur",
  "(someVariable)": "Une valeur",
  "'someVariable'": "Une valeur",
  "{{someVariable}}": "Une valeur",
  "2": "Une valeur",
  "$someVariable": "Une valeur"
}
```

Voici comment vous appelleriez les clés valides dans un template :

```html title="HTML"
{{someVariable}}
{{some_variable}}
{{some-variable}}
{{SomeVariable}}
{{somevariable}}
{{some}}
{{2words}}
```

## Créer des variables dans les templates

Les tags de variables créent de nouvelles variables Liquid. Voici les deux tags les plus courants, mais vous pouvez en découvrir davantage dans [la documentation officielle](https://shopify.github.io/liquid/tags/variable/).

### assign

[Lire la documentation complète de assign.](https://shopify.github.io/liquid/tags/variable/#assign)

Crée une nouvelle variable nommée.

```liquid title="Input"
{% assign foo = "bar" %}
{{foo}}
```

``` title="Output"
bar
```

### capture

[Lire la documentation complète de capture.](https://shopify.github.io/liquid/tags/variable/#capture)

Capture la chaîne de caractères entre les balises d’ouverture et de fermeture et l’assigne à une variable. Les variables créées avec `capture` sont stockées sous forme de chaînes de caractères.

```liquid title="Input"
{% assign favorite_food = "pizza" %}
{% assign age = 35 %}

{% capture about_me %}
J’ai {{age}} ans et mon plat préféré est la {{favorite_food}}.
{% endcapture %}

{{about_me}}
```

``` title="Output"
J’ai 35 ans et mon plat préféré est la pizza.
```


## FAQ

**Comment transmettre des données dynamiques à un template PDFMonkey ?**

Définissez vos données sous forme d’objet JSON et envoyez-les comme payload du document via l’API ou une intégration. Dans le template, accédez aux valeurs avec la syntaxe Liquid : {{ nomVariable }} pour les clés de premier niveau, {{ objet.propriete }} pour les valeurs imbriquées et {% for item in tableau %} pour les tableaux.

**À quoi servent les données de test dans PDFMonkey ?**

Les données de test sont un objet JSON défini dans l’onglet Données de test de l’éditeur de template. Elles simulent le payload que vous enverriez via l’API, vous permettant de prévisualiser le template en temps réel sans consommer votre quota mensuel de documents.

**Peut-on utiliser des objets JSON imbriqués et des tableaux dans les templates PDFMonkey ?**

Oui. PDFMonkey prend en charge le JSON profondément imbriqué. Accédez aux valeurs imbriquées avec la notation par points (ex. {{ client.fullName }}) et parcourez les tableaux avec {% for item in lineItems %}. Vous pouvez imbriquer des objets dans des tableaux et inversement.


---

# Formater et transformer les données

Source: https://pdfmonkey.io/fr/docs/modeles-code/filtres.md
Les filtres sont des transformateurs de données que vous appliquez à une valeur en utilisant la syntaxe pipe (`|`). Ils prennent la valeur à gauche, la traitent et produisent le résultat. Vous pouvez chaîner plusieurs filtres pour des transformations plus complexes.

Vous pouvez trouver la liste complète des filtres intégrés dans [la documentation officielle de Liquid](https://shopify.github.io/liquid/).

## Filtres intégrés

### append

[Lire la documentation complète de append.](https://shopify.github.io/liquid/filters/append)

Ajoute la chaîne de caractères spécifiée à la fin d’une autre chaîne.

```liquid
{{"/my/fancy/url" | append: ".html"}}
→ /my/fancy/url.html
```

### date

[Lire la documentation complète de date.](https://shopify.github.io/liquid/filters/date)

Convertit un timestamp dans un autre format de date. Le format de cette syntaxe est le même que [strftime](http://strftime.net/). L’entrée utilise le même format que [Time.parse](https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html#method-c-parse) de Ruby.

```liquid
{{article.published_at | date: "%a, %b %d, %y"}}
→ Fri, Jul 17, 22

{{article.published_at | date: "%Y"}}
→ 2022
```

`date` fonctionne sur les chaînes de caractères si elles contiennent des dates bien formatées :

```liquid
{{"March 14, 2022" | date: "%b %d, %y"}}
→ Mar 14, 22
```

Pour obtenir l’heure actuelle, passez le mot spécial `"now"` (ou `"today"`) à `date` :

```liquid
Dernière mise à jour : {{"now" | date: "%Y-%m-%d %H:%M"}}
→ Dernière mise à jour : 2022-03-14 12:34
```

> [!NOTE]
> **Besoin d’un fuseau horaire ?**
>
> Consultez le filtre [`in_time_zone`](#in_time_zone) fourni par PDFMonkey.


### default

[Lire la documentation complète de default.](https://shopify.github.io/liquid/filters/default)

Définit une valeur par défaut pour toute variable sans valeur assignée. `default` affichera sa valeur si l’entrée est `nil`, `false` ou vide.

Quand `product_price` **n’est pas défini**, la valeur par défaut est utilisée :

```liquid
{{product_price | default: 2.99}}
→ 2.99
```

Quand `product_price` **est défini**, la valeur par défaut n’est pas utilisée :

```liquid
{% assign product_price = 4.99 %}
{{product_price | default: 2.99}}
→ 4.99
```

Quand `product_price` **est vide**, la valeur par défaut est utilisée :

```liquid
{% assign product_price = "" %}
{{product_price | default: 2.99}}
→ 2.99
```

> [!TIP]
> **Filtres mathématiques**
>
> — `plus`, `minus`, `times`, `divided_by`, `round`, `ceil` et `floor` sont documentés sur la page dédiée [Faire des calculs](https://pdfmonkey.io/fr/docs/modeles-code/comment-faire-des-calculs.md).


### newline\_to\_br

[Lire la documentation complète de newline\_to\_br.](https://shopify.github.io/liquid/filters/newline_to_br/)

Insère un saut de ligne HTML (`<br />`) devant chaque retour à la ligne () dans une chaîne de caractères.

```liquid
{{"Hello\nWorld" | newline_to_br}}
→ Hello<br />
  World
```

### where

[Lire la documentation complète de where.](https://shopify.github.io/liquid/filters/where/)

Crée un tableau contenant uniquement les objets ayant une valeur de propriété donnée, ou toute valeur [truthy](https://shopify.github.io/liquid/basics/truthy-and-falsy/#truthy) par défaut.

Dans cet exemple, supposons que vous ayez une liste de produits et que vous souhaitiez afficher vos produits de cuisine séparément. En utilisant `where`, vous pouvez créer un tableau contenant uniquement les produits qui ont un `"type"` de `"kitchen"`.

```liquid
Tous les produits :
{% for product in products %}
- {{ product.title }}
{% endfor %}

{% assign kitchen_products = products | where: "type", "kitchen" %}

Produits de cuisine :
{% for product in kitchen_products %}
- {{ product.title }}
{% endfor %}
```

``` title="Résultat"
Tous les produits :
- Aspirateur
- Spatule
- Télévision
- Presse-ail

Produits de cuisine :
- Spatule
- Presse-ail
```

## Filtres PDFMonkey

> [!NOTE]
> Ces filtres sont exclusifs à PDFMonkey et ne sont pas disponibles dans les implémentations Liquid standard.


### Filtres de tableaux

#### push

Ajoute un élément à un tableau.

```liquid
{% assign arr = "terre vent" | split: " " %}
{% assign arr = arr | push: "feu" %}

{{arr | to_sentence}}
→ terre, vent and feu
```

#### slice\_by

Découpe un tableau en groupes de N éléments.

```liquid
{% assign reindeers = "Dasher Dancer Prancer Vixen Comet Cupid Donner Blitzen Rudolph" | split: " " %}
{% assign reindeerPairs = reindeers | slice_by: 2 %}

{% for reindeerPair in reindeerPairs %}
  Paire :
  {% for reindeer in reindeerPair %}
    - {{reindeer}}
  {% endfor %}
{% endfor %}
```

``` title="Résultat"
  Paire :
    - Dasher
    - Dancer
  Paire :
    - Prancer
    - Vixen
  Paire :
    - Comet
    - Cupid
  Paire :
    - Donner
    - Blitzen
  Paire :
    - Rudolph
```

#### sum

Retourne la somme d’un tableau de nombres.

Supposons que vous ayez ceci dans vos données :

```json title="JSON"
{
  "array": [1, 2, 3, 4, 5]
}
```

```liquid
{{array | sum}}
→ 15
```

#### to\_sentence

Convertit le tableau en une phrase séparée par des virgules où le dernier élément est relié par un mot de liaison.

```liquid
{% assign arr = "terre vent" | split: " " %}
{% assign arr = arr | push: "feu" %}

{{arr | to_sentence}}
→ terre, vent and feu

{{arr | to_sentence: ' - '}}
→ terre - vent and feu

{{arr | to_sentence: ' - ', 'et enfin '}}
→ terre - vent et enfin feu
```

#### where\_exp

Similaire au filtre [`where`](#where) de Liquid, mais accepte une expression.

Commençons par les données :

```json title="JSON"
{
  "products": [
    { "name": "Produit 1", "price": 1.00 },
    { "name": "Produit 2", "price": 2.00 },
    { "name": "Produit 3", "price": 3.00 },
    { "name": "Produit 4", "price": 2.00 },
    { "name": "Produit 5", "price": 1.00 }
  ]
}
```

```liquid
{% assign cheapProducts = products | where_exp: "prod", "prod.price < 1" %}

{% for product in cheapProducts %}
- {{product.name}}
{% endfor %}
```

``` title="Résultat"
- Produit 1
- Produit 5
```

### Filtres de date et heure

#### in\_time\_zone

Décale une date vers le fuseau horaire donné avant le formatage.

```liquid
{{"2050-01-02 12:34:56" | in_time_zone: "Pacific/Galapagos" | date: "%Y-%m-%d %H:%M"}}
→ 2050-01-02 06:34
```

### Filtres d’URL

#### ensure\_protocol

Il peut arriver que vous receviez des URLs d’assets sans protocole. Malheureusement, notre moteur de rendu ne prend pas en charge ce type d’URL. C’est pourquoi nous fournissons `ensure_protocol` qui ajoutera un protocole si nécessaire :

```liquid
{{"//example.com/some-picture.jpg" | ensure_protocol}}
→ https://example.com/some-picture.jpg

{{"//example.com/some-picture.jpg" | ensure_protocol: "http"}}
→ http://example.com/some-picture.jpg

{{"http://example.com/some-picture.jpg" | ensure_protocol}}
→ http://example.com/some-picture.jpg
```

### Filtres de nombres

Voir aussi [Faire des calculs](https://pdfmonkey.io/fr/docs/modeles-code/comment-faire-des-calculs.md) pour les filtres arithmétiques et des exemples pratiques de calcul.

#### format

Le filtre `format` est utile pour le formatage avancé de nombres. Pour un formatage plus simple, préférez [`with_delimiter`](#with_delimiter).

```liquid
{{5 | format: "%05d"}}
→ 00005

{{5 | format: "%08.3f"}}
→ 0005.000

{{5 | format: "%.2f"}}
→ 5.00

{{5.1234 | format: "%.2f"}}
→ 5.12
```

#### with\_delimiter

Pour le formatage basique de nombres comme les montants monétaires par exemple, le filtre `with_delimiter` vous aidera à définir un séparateur de milliers, un séparateur décimal et la précision.

**Utilisation de base** — ajoute une virgule tous les trois chiffres par défaut :

```liquid
{{12345678 | with_delimiter}}
→ 12,345,678

{{1234.567 | with_delimiter}}
→ 1,234.567
```

Le texte non numérique n’est pas modifié :

```liquid
{{'12345a' | with_delimiter}}
→ 12345a
```

**Séparateur personnalisé** — changer le séparateur de milliers :

```liquid
{{12345678 | with_delimiter, delimiter: " "}}
→ 12 345 678
```

**Précision** — contrôler le nombre de décimales :

```liquid
{{12345678 | with_delimiter, precision: 2}}
→ 12,345,678.00

{{1234.567 | with_delimiter, precision: 2}}
→ 1,234.57
```

**Supprimer les zéros non significatifs :**

```liquid
{{12345678 | with_delimiter, precision: 2, strip_insignificant_zeros: true}}
→ 12,345,678

{{1234.567 | with_delimiter, precision: 2, strip_insignificant_zeros: true}}
→ 1,234.57
```

**Combinaison d’options** — par exemple, un formatage à l’européenne :

```liquid
{{1234.567 | with_delimiter,
  delimiter: " ",
  separator: ",",
  precision: 2,
  strip_insignificant_zeros: true
}}
→ 1 234,57

{{1234.003 | with_delimiter,
  delimiter: " ",
  separator: ",",
  precision: 2,
  strip_insignificant_zeros: true
}}
→ 1 234
```

### Filtres HTML

#### entities

Ce filtre peut être très utile si vous devez gérer des caractères accentués ou spéciaux dans [l’en-tête ou le pied de page](https://pdfmonkey.io/fr/docs/modeles-code/en-tete-et-pied-de-page.md). Il convertira tout caractère non-latin en son [entité HTML](https://dev.w3.org/html5/html-author/charref).

```liquid
{{"Marie Skłodowska Curie" | entities}}
→ Marie Sk&lstrok;odowska Curie
```

### Filtres JSON

#### json

Si vous avez besoin d’insérer des [données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) dans leur format JSON d’origine (comme nous le faisons [pour les graphiques](https://pdfmonkey.io/fr/docs/modeles-code/javascript-personnalise.md#including-charts) par exemple), le filtre `json` est ce qu’il vous faut. Notez qu’il retourne une chaîne de caractères, pas l’objet lui-même.

```liquid
{{'banana, apple' | split: ', ' | json}}
→ ["banana", "apple"]
```

#### parse\_json

Transforme une chaîne JSON en objet ou tableau utilisable. Ce filtre est particulièrement utile lorsqu’une intégration (comme [Glide](https://pdfmonkey.io/fr/docs/integrations/glide.md) ou un webhook) ne peut envoyer que des valeurs textuelles simples : vous transmettez les données structurées sous forme de chaîne JSON et les analysez dans le modèle.

```liquid
{% assign obj = ‘{ "key": "value" }’ | parse_json %}
{{obj.key}}
→ value
```

Vous pouvez aussi analyser des tableaux et les parcourir en boucle :

```liquid
{% assign items = ‘[{"name":"Waffle","qty":12},{"name":"Donut","qty":5}]’ | parse_json %}
{% for item in items %}
  {{item.name}} x{{item.qty}}
{% endfor %}
→ Waffle x12
  Donut x5
```

Si l’entrée est vide ou n’est pas du JSON valide, `parse_json` renvoie `nil` par défaut. Vous pouvez fournir une valeur de repli en argument :

```liquid
{% assign data = invalidVariable | parse_json: "fallback" %}
{{data}}
→ fallback
```

> [!TIP]
> **Cas d’usage typique**
>
> Certaines intégrations ne prennent en charge que des paires clé/valeur simples et ne peuvent pas envoyer de tableaux. Construisez une chaîne JSON côté intégration (par exemple via une Joined List dans Glide) et analysez-la dans votre modèle avec `parse_json` pour obtenir un vrai tableau sur lequel itérer. Consultez la [solution pour les lignes de détail avec Glide](https://pdfmonkey.io/fr/docs/integrations/glide.md#workaround-json-string) pour un exemple complet.



## FAQ

**Comment formater des nombres avec des séparateurs de milliers dans PDFMonkey ?**

Utilisez le filtre with_delimiter. Par exemple, {{ 12345678 | with_delimiter }} produit 12,345,678. Vous pouvez personnaliser le délimiteur, le séparateur décimal et la précision avec des arguments nommés.

**Comment formater des dates dans un template Liquid PDFMonkey ?**

Utilisez le filtre date avec les codes de format strftime. Par exemple, {{ article.published_at | date: "%b %d, %Y" }}. Pour convertir dans un fuseau horaire spécifique d’abord, chaînez le filtre in_time_zone avant date.

**Comment parser une chaîne JSON dans un template PDFMonkey ?**

Utilisez le filtre parse_json pour convertir une chaîne JSON en objet ou tableau que vous pouvez parcourir. Par exemple : {% assign items = jsonString | parse_json %}. C’est particulièrement utile quand des intégrations comme Glide ne peuvent envoyer que des valeurs sous forme de chaînes de caractères.

**Comment gérer les caractères accentués dans les en-têtes et pieds de page PDFMonkey ?**

Utilisez le filtre entities pour convertir les caractères non-latins en entités HTML. Par exemple, {{ company.name | entities }} convertit « é » en &eacute;, ce qui s’affiche correctement dans les en-têtes et pieds de page via les paramètres.


---

# Faire des calculs

Source: https://pdfmonkey.io/fr/docs/modeles-code/comment-faire-des-calculs.md
Liquid n’a pas d’opérateurs mathématiques comme `+`, `-`, `*`, ou `/`. Toute l’arithmétique se fait à travers des **filtres** : vous passez une valeur à travers un filtre pour la transformer. Cette page présente les schémas de calcul courants dont vous aurez besoin lors de la construction de templates.

## Arithmétique de base

Les quatre filtres arithmétiques fondamentaux sont `plus`, `minus`, `times` et `divided_by`. Chacun prend une valeur à gauche et un paramètre à droite :

```liquid
{{ 10 | plus: 5 }}        -> 15
{{ 10 | minus: 3 }}       -> 7
{{ 10 | times: 4 }}       -> 40
{{ 10 | divided_by: 3 }}  -> 3
```

### Exemples pratiques

Calculer le total d’une ligne de commande à partir de vos données :

```liquid
{{ item.quantity | times: item.unit_price }}
```

Appliquer une remise de 10% :

```liquid
{% assign discounted = subtotal | times: 0.9 %}
{{ discounted }}
```

Ajouter 20 % de TVA à un sous-total :

```liquid
{{ subtotal | times: 1.20 }}
```

## Arrondis

Trois filtres contrôlent la précision décimale :

```liquid
{{ 4.6 | round }}     -> 5
{{ 4.3 | round }}     -> 4
{{ 4.123 | round: 2 }} -> 4.12

{{ 4.1 | ceil }}      -> 5
{{ 4.1 | floor }}     -> 4
```

> [!WARNING]
> **La division entière tronque**
>
> Lorsque `divided_by` reçoit un diviseur entier, il retourne un entier tronqué (pas un résultat arrondi) :
&gt; 
&gt; ```liquid
&gt; {{ 5 | divided_by: 3 }}    -&gt; 1  (pas 1.67)
&gt; {{ 5 | divided_by: 3.0 }}  -&gt; 1.6666666666666667
&gt; ```
&gt; 
&gt; Utilisez un diviseur décimal (comme `3.0`) si vous avez besoin d’un résultat précis.


## Chaîner les calculs

Les filtres peuvent être chaînés de gauche à droite. Chaque filtre reçoit le résultat du précédent :

```liquid
{{ price | times: quantity | times: 1.20 | round: 2 }}
```

Cela multiplie `price` par `quantity`, applique 20 % de TVA, et arrondit à 2 décimales (le tout en une seule expression).

Un exemple complet de ligne de facture :

```liquid
{% for item in lineItems %}
  <tr>
    <td>{{ item.product }}</td>
    <td>{{ item.quantity }}</td>
    <td>${{ item.price | with_delimiter, precision: 2 }}</td>
    <td>${{ item.price | times: item.quantity | with_delimiter, precision: 2 }}</td>
  </tr>
{% endfor %}
```

## Formater les nombres

Les filtres arithmétiques Liquid retournent des nombres bruts. Pour les afficher correctement (séparateurs de milliers, décimales fixes, formatage sprintf), utilisez les filtres [`with_delimiter`](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#with_delimiter) et [`format`](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#format).

## Pour aller plus loin

- [Filtres](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md) — référence complète de tous les filtres intégrés et spécifiques à PDFMonkey


## FAQ

**Comment faire des calculs dans les templates Liquid ?**

Liquid n’a pas d’opérateurs mathématiques. Utilisez des filtres à la place : plus, minus, times et divided_by. Par exemple, {{ 10 | plus: 5 }} renvoie 15.

**Pourquoi divided_by renvoie-t-il un résultat incorrect dans Liquid ?**

Quand le diviseur est un entier, divided_by tronque le résultat en entier. Utilisez un diviseur décimal (par ex. 3.0 au lieu de 3) pour obtenir un résultat en virgule flottante précis.

**Comment arrondir des nombres dans un template PDFMonkey ?**

Utilisez le filtre round pour un arrondi standard ({{ 4.6 | round }} renvoie 5), ceil pour arrondir au-dessus, ou floor pour arrondir en-dessous. Passez un argument de précision pour contrôler le nombre de décimales : {{ 4.123 | round: 2 }} renvoie 4.12.


---

# Conditions et boucles pour les modèles code

Source: https://pdfmonkey.io/fr/docs/modeles-code/conditions-et-boucles.mdLa plupart du temps, vous aurez besoin d’afficher certaines portions de contenu en fonction de la valeur d’un ou plusieurs éléments de données, ou de répéter du contenu pour chaque entrée d’une liste. Voyons comment cela se fait avec Liquid.

## Utiliser un simple « if »

La condition la plus simple que vous pouvez utiliser est une instruction `if` :

```liquid
{% if client.isNewClient == true %}
  <p>Félicitations pour votre première commande !</p>
{% endif %}
```

Le contenu sera affiché uniquement lorsque la condition est vraie.

### Combiner des conditions

Vous pouvez également combiner plusieurs conditions en utilisant `and` et `or` :

```liquid
{% if client.isExistingClient == true and client.orderedRecently == true %}
  <p>Un fan de notre marque, n’est-ce pas ? :D</p>
{% endif %}

{% if client.isNewClient == true or client.orderedALongTimeAgo == true %}
  <p>Félicitations pour votre première commande de l’année !</p>
{% endif %}
```

## Condition inverse avec « unless »

Si vous souhaitez inverser la condition, `unless` est votre allié :

```liquid
{% unless client.isNewClient %}
  <p>Ravi de vous revoir !</p>
{% endunless %}
```

Dans ce cas, le code serait équivalent à :

```liquid
{% if client.isNewClient != true %}
  <p>Ravi de vous revoir !</p>
{% endif %}
```

## Les deux cas avec « if ... else »

Un peu plus fréquent que `unless`, l’instruction `if ... else` permet de spécifier les deux cas :

```liquid
{% if client.isNewClient == true %}
  <p>Félicitations pour votre première commande !</p>
{% else %}
  <p>Ravi de vous revoir !</p>
{% endif %}
```

## Conditions multiples avec « if ... elsif ... else »

Il peut arriver que vous deviez vérifier plusieurs conditions pour trouver le bon contenu. Pour ces cas, l’instruction `if ... elsif ... else` est la solution :

```liquid
{% if client.isNewClient == true %}
  <p>Félicitations pour votre première commande !</p>
{% elsif client.fullName == "Pierre Dupont" %}
  <p>Bon retour Spide... hum... M. Dupont.</p>
{% else %}
  <p>Ravi de vous revoir {{client.fullName}} !</p>
{% endif %}
```

## Dispatcher selon une seule variable

Si vous souhaitez insérer du contenu selon la valeur d’une seule variable, vous pouvez remplacer l’instruction `if ... elsif ... else` par une simple instruction `case ... when ... end` :

```liquid
{% case client.fullName %}
  {% when "Pierre Dupont" %}
    <p>Bon retour Spide... hum... M. Dupont.</p>
  {% when "Diana Prince" %}
    <p>Ravie de vous revoir WonderW... enfin... Mlle Prince.</p>
  {% else %}
    <p>Rebonjour {{client.fullName}} !</p>
{% endcase %}
```

## Boucles

Itérer sur des listes est un besoin très fréquent. Voici les aspects essentiels de l’itération, mais vous pouvez en apprendre davantage dans [la documentation officielle](https://shopify.github.io/liquid/tags/iteration/).

### for

Utilisons les données que nous avons définies dans [une section précédente](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#defining-test-data) :

```json
{
  "orderId": 1234,
  "orderStatus": "pending",
  "invoiceId": null,
  "client": {
    "civility": "M.",
    "fullName": "Pierre Dupont",
    "isNewClient": true
  },
  "lineItems": [
    { "product": "Soie ultra résistante",    "quantity": 100, "price": 123.45 },
    { "product": "Composants électroniques", "quantity": 12,  "price": 12.34 }
  ]
}
```

Nous pouvons itérer sur le tableau `lineItems` pour lister nos produits en utilisant une boucle `for`. Elle répétera le code pour chaque élément du tableau :

```liquid
<table>
  <tr>
    <th>Produit</th>
    <th>Quantité</th>
    <th>Prix unitaire</th>
    <th>Total</th>
  </tr>

  {% for item in lineItems %}
    <tr>
      <td>{{item.product}}</td>
      <td>{{item.quantity}}</td>
      <td>${{item.price | with_delimiter, precision: 2}}</td>
      <td>${{item.price | times: item.quantity | with_delimiter, precision: 2}}</td>
    </tr>
  {% endfor %}
</table>
```

Le HTML résultant ressemblera à ceci :

```html
<table>
  <tr>
    <th>Produit</th>
    <th>Quantité</th>
    <th>Prix unitaire</th>
    <th>Total</th>
  </tr>

  <tr>
    <td>Soie ultra résistante<td>
    <td>100</td>
    <td>$123.45</td>
    <td>$12,345.00</td>
  </tr>

  <tr>
    <td>Composants électroniques</td>
    <td>12</td>
    <td>$12.34</td>
    <td>$148.08</td>
  </tr>
</table>
```

> [!NOTE]
> **Formatage des données**
>
> Nous formatons les valeurs monétaires en utilisant le filtre `with_delimiter` ici. Vous pouvez en savoir plus dans notre documentation sur les [Filtres](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#with_delimiter).


### L’objet forloop

À l’intérieur d’une boucle `for`, vous avez accès à un objet spécial qui stocke l’état actuel de la boucle. Il peut être utile pour construire des cas particuliers pour la première ou la dernière itération, par exemple.

```liquid
{% for item in lineItems %}
  {% if forloop.first == true %}
    <p>{{item.product}} est le premier article.</p>
  {% elsif forloop.last == true %}
    <p>{{item.product}} est le dernier article.</p>
  {% else %}
    <p>{{item.product}} est un article.</p>
  {% endif %}
{% endfor %}
```

> [!NOTE]
> **En savoir plus**
>
> Découvrez toutes les possibilités de `forloop` dans [la documentation dédiée](https://shopify.dev/api/liquid/objects/for-loops), notamment `index`, `index0` ou `length`.


### Limiter et décaler

Vous pouvez contrôler le nombre d’éléments sur lesquels une boucle itère en utilisant `limit` et `offset` :

```liquid
{% for item in lineItems limit: 1 %}
  <p>Premier article : {{item.product}}</p>
{% endfor %}

{% for item in lineItems offset: 1 %}
  <p>Articles restants : {{item.product}}</p>
{% endfor %}
```

Vous pouvez également itérer dans l’ordre inverse :

```liquid
{% for item in lineItems reversed %}
  <p>{{item.product}}</p>
{% endfor %}
```

> [!NOTE]
> **En savoir plus**
>
> Vous pouvez en apprendre davantage sur l’itération de listes dans [la documentation officielle de Liquid](https://shopify.github.io/liquid/tags/iteration/), y compris tous les paramètres de boucle disponibles.


### Filtres associés

Lorsque vous travaillez avec des boucles, ces filtres PDFMonkey sont particulièrement utiles :

- Le filtre [slice_by](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#slice_by) (découpe un tableau en groupes de N éléments)
- Le filtre [where_exp](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#where_exp) (filtre un tableau en utilisant une expression)


## FAQ

**Comment utiliser des conditions dans les modeles PDFMonkey ?**

Utilisez les balises conditionnelles Liquid : {% if condition %}, {% elsif %}, {% else %} et {% endif %} pour afficher ou masquer du contenu. Vous pouvez aussi utiliser {% unless %} pour les conditions inversees et {% case %} / {% when %} pour la logique a branches multiples.

**Comment iterer sur des donnees dans les modeles PDFMonkey ?**

Utilisez la balise {% for item in list %} pour repeter du HTML pour chaque element d’un tableau provenant du payload de votre document. A l’interieur de la boucle, accedez a l’objet forloop pour l’index courant, la longueur et les indicateurs first/last.

**Peut-on combiner plusieurs conditions dans les modeles Liquid PDFMonkey ?**

Oui. Utilisez "and" pour exiger que toutes les conditions soient vraies, ou "or" pour exiger qu’au moins une le soit. Par exemple : {% if client.isNewClient == true and order.total > 100 %}.


---

# Images et liens pour les modèles code

Source: https://pdfmonkey.io/fr/docs/modeles-code/images.mdLes images et les liens sont des éléments fondamentaux de la plupart des templates PDFMonkey. Cette page vous guide à travers chaque méthode pour inclure des éléments visuels et des liens cliquables dans vos PDF.

## Inclure des images

Il existe trois façons d’inclure des images dans vos templates. Voici un comparatif rapide pour vous aider à choisir :

| Méthode | Fonctionne en plan gratuit | Hébergement externe nécessaire | Idéal pour |
| --- | --- | --- | --- |
| [Images par URL](#images-par-url) | Non (payant uniquement) | Oui | La plupart des cas : photos produit, contenu dynamique |
| [Images intégrées](#images-intégrées) | Oui | Non | Petits éléments statiques comme les logos ou signatures |
| [SVG inline](#svg-inline) | Oui | Non | Icônes, graphiques simples |

### Images par URL {#images-par-url}

L’approche la plus courante consiste à référencer les images par URL. Si vos images sont déjà hébergées quelque part (un CDN, votre propre serveur, un bucket de stockage cloud), il suffit de pointer vers elles : simple et efficace.

> [!WARNING]
> **Compte payant uniquement**
>
> L’inclusion d’images par URL n’est disponible que sur les comptes payants. Les documents référençant des images externes échoueront sur un compte gratuit. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour plus de détails. Si vous êtes sur un plan gratuit, voir [Images intégrées](#images-intégrées) ci-dessous.


**Image statique** : codez l’URL en dur dans votre template :

```html title="HTML"
<img src="https://placekitten.com/200/300" />
```

**Image dynamique** : passez l’URL dans votre payload et référencez-la dans le template.

Payload :

```json
{
  "imageUrl": "http://placekitten.com/200/300"
}
```

Template :

```html title="HTML"
<img src="{{imageUrl}}" />
```

**Image de fond** : définissez une image de fond dans l’onglet CSS :

```css title="CSS"
.some-class {
  background-image: url("https://placekitten.com/200/300");
}
```

Puis appliquez-la à n’importe quel élément dans votre onglet HTML :

```html title="HTML"
<div class="some-class">
  ...
</div>
```

**Image de fond dynamique** : vous ne pouvez pas utiliser de données dynamiques depuis l’onglet CSS comme vous le faites dans l’onglet HTML, mais vous avez deux options.

Vous pouvez utiliser le style inline :

```html title="HTML"
<div style="background-image: url('{{imageUrl}}');">
  ...
</div>
```

Ou vous pouvez utiliser un bloc `<style>` intégré dans votre onglet HTML :

```html title="HTML"
<style>
  .some-class {
    background-image: url('{{imageUrl}}');
  }
</style>

<div class="some-class">
  ...
</div>
```

Vous pouvez également utiliser [la technique des propriétés personnalisées CSS](https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md#the-css-custom-properties-technique) si vous souhaitez garder tout votre CSS dans l’onglet CSS.

### Images intégrées {#images-intégrées}

Si vos images ne sont pas hébergées en ligne, ou si vous êtes sur un plan gratuit, vous pouvez intégrer les données de l’image directement dans votre template ou votre payload API. L’image est autonome : rien n’est chargé depuis internet au moment de la génération.

**Comment ça marche :** vous fournissez l’image sous forme d’une chaîne de texte contenant l’intégralité de ses données (techniquement appelée « data URI »). Cela ressemble à une longue chaîne `data:image/png;base64,R0lGODlhE...`. Pas besoin de comprendre le format : il suffit de produire la chaîne et de l’utiliser comme source de l’image.

> [!NOTE]
> **Comment obtenir cette chaîne ?**
>
> Recherchez « convertisseur image en data-URI » en ligne : vous trouverez des outils gratuits qui vous permettent d’envoyer une image et de récupérer la chaîne prête à coller.


**Image statique** : pour une image qui ne change jamais (un logo d’entreprise, un élément décoratif), collez-la directement dans votre template :

```html title="HTML"
<img src="data:image/png;base64,R0lGODlhE...UjIQA7" />
```

**Image dynamique** : si l’image provient de votre application (une photo d’utilisateur, une signature), envoyez-la dans votre payload et référencez-la dans le template.

Payload :

```json
{
  "imageUrl": "data:image/png;base64,R0lGODlhE...UjIQA7"
}
```

Template :

```html
<img src="{{imageUrl}}" />
```

> [!TIP]
> **Gardez les images intégrées légères**
>
> Puisque les données de l’image sont dans votre template ou votre payload, les images volumineuses peuvent rendre les choses lourdes. Les images intégrées conviennent mieux aux petits éléments comme les logos ou signatures. Pour les images plus grandes ou fréquemment mises à jour, les [images par URL](#images-par-url) sont plus adaptées.


### SVG inline {#svg-inline}

Pour les icônes, les formes simples ou les graphiques que vous contrôlez au niveau du code, vous pouvez insérer du balisage SVG directement dans votre HTML :

```html title="HTML"
<svg height="100" width="100">
  <circle cx="50" cy="50" r="40" stroke="purple" stroke-width="3" fill="pink" />
</svg>
```

Puisque le SVG inline fait partie du template lui-même, il fonctionne sur tous les plans et se charge instantanément.

## Conseils de performance

Si la vitesse de génération vous préoccupe, utiliser des images plus petites est l’amélioration la plus significative. Des images plus légères se chargent plus vite, ce qui signifie une génération de documents plus rapide.

Privilégiez les formats modernes qui produisent des fichiers légers. PDFMonkey prend en charge [WebP](https://developers.google.com/speed/webp) et [AVIF](https://en.wikipedia.org/wiki/AVIF). Des convertisseurs gratuits en ligne peuvent vous aider à réduire la taille de vos images sans perte de qualité visible.

Les images intégrées et le SVG inline évitent les requêtes réseau, ce qui aide également. Mais même dans ces cas, optimiser les données de l’image reste bénéfique.

Si vous préférez les formats classiques comme JPEG ou PNG, utilisez un outil comme [ImageOptim](https://imageoptim.com/) pour réduire la taille des fichiers.

> [!NOTE]
> **Vous cherchez à optimiser le poids de vos fichiers ?**
>
> Si vos documents générés sont plus volumineux que prévu, consultez [Résolution des images et poids des fichiers](https://pdfmonkey.io/fr/docs/modeles-code/poids-et-resolution-des-images.md) pour un guide détaillé sur les raisons du gonflement et les solutions.


## Utiliser des liens dans les PDF

Vous pouvez utiliser des liens internes et externes dans vos documents.

### Liens internes

Si vous souhaitez créer un lien vers des sections spécifiques de votre PDF, cela fonctionne exactement comme dans une page web classique. Commencez par définir une ancre vers laquelle vous voulez créer un lien :

```html
<div id="some-section">
  <!-- votre contenu ici -->
</div>
```

Puis créez un lien depuis un autre endroit du contenu :

```html
<a href="#some-section">Aller à la section</a>
```

### Liens externes

Vous pouvez créer un lien vers n’importe quelle page web sur internet en définissant un lien :

```html
<a href="https://www.pdfmonkey.io">Visitez notre site</a>
```

> [!NOTE]
> **Pas besoin de target=_blank**
>
> Puisque votre lien est rendu dans un PDF, ajouter `target=&#34;_blank&#34;` n’est pas nécessaire. Cela fonctionne lors de la visualisation du PDF dans un lecteur web (comme notre aperçu) mais sera ignoré dans la plupart des contextes.



## FAQ

**Comment ajouter des images a un modele PDFMonkey ?**

Trois methodes : les images par URL (referencer des images hebergees sur un CDN ou un serveur — forfaits payants uniquement), les images embarquees en URI de donnees Base64 (fonctionne sur tous les forfaits, ideal pour les petits elements comme les logos), et le SVG en ligne pour les icones et graphiques simples.

**Peut-on utiliser des images avec le forfait gratuit PDFMonkey ?**

Oui, mais uniquement des images embarquees en Base64 ou du SVG en ligne. Les images par URL necessitent un forfait payant car elles reposent sur des ressources externes. Consultez la page Ressources externes pour plus de details.

**Comment ajouter une image dynamique depuis mon payload API dans PDFMonkey ?**

Transmettez l’URL de l’image dans votre payload JSON (par exemple {"imageUrl": "https://example.com/photo.jpg"}) et referencez-la dans votre modele avec une balise img : <img src="{{imageUrl}}" />.


---

# Résolution des images et poids des fichiers

Source: https://pdfmonkey.io/fr/docs/modeles-code/poids-et-resolution-des-images.md
Si vos documents générés sont plus volumineux que prévu, les images en sont presque certainement la cause. Cette page explique comment les images se retrouvent dans vos fichiers, pourquoi elles gonflent le poids du fichier, et ce que vous pouvez faire pour y remédier.

## Comment les images se retrouvent dans votre document

PDFMonkey utilise un moteur basé sur Chromium pour générer les documents. Le processus fonctionne ainsi :

1. Votre HTML et CSS sont chargés dans le moteur de rendu.
2. Le moteur **rend** la page : il télécharge les images, applique les styles et peint chaque pixel.
3. Ce n’est qu’ensuite qu’il génère le PDF à partir du résultat rendu.

C’est important parce que le PDF n’est pas un simple assemblage de vos fichiers originaux. Le moteur ré-encode chaque image dans le cadre du processus de rendu. Le format de fichier original (JPEG, WebP, PNG) est abandonné ; ce qui se retrouve dans le PDF, ce sont les données pixel du rendu.

## Pourquoi les images gonflent le poids du fichier

Deux choses se produisent pendant le rendu qui peuvent augmenter considérablement la taille du fichier.

### Tous les pixels source sont conservés

Si votre image source fait 3000 x 3000 pixels mais que vous l’affichez à 500 x 500 pixels CSS, le moteur embarque quand même les 9 millions de pixels source dans le PDF. La taille d’affichage dans votre template n’a aucun effet sur ce qui est stocké.

Cela surprend souvent, car sur le web, le navigateur décode l’image en mémoire mais ne la sérialise jamais dans un fichier. Dans un PDF, l’intégralité des données pixel est écrite dans le fichier de sortie.

> [!NOTE]
> **La croissance des pixels est quadratique**
>
> Doubler la largeur et la hauteur d’une image signifie 4 fois plus de pixels, pas 2 fois. Passer de 1000 x 1000 à 3000 x 3000, c’est 9 fois plus de pixels.


### La compression JPEG est perdue

C’est le principal responsable du gonflement inattendu des fichiers.

> [!WARNING]
> **La compression JPEG ne se retrouve pas dans le PDF**
>
> Le moteur PDF de Chromium utilise une compression sans perte (similaire au PNG) pour toutes les images matricielles. Il n’utilise **pas** la compression JPEG. Quand vous incluez une image JPEG, le moteur la décode d’abord en pixels bruts, puis recompresse ces pixels sans perte. Un JPEG web de 100 Ko peut devenir plusieurs mégaoctets dans le PDF final.


Cela affecte tous les formats d’images matricielles de la même manière : JPEG, PNG, WebP et AVIF sont tous décodés en pixels puis ré-encodés de façon identique. Le format source n’a quasiment aucun impact sur la taille finale du PDF. Ce qui compte, c’est le **nombre de pixels**.

## Dimensionner les images pour l’impression

Quand votre document sera imprimé, vous voulez des images suffisamment nettes pour un bon rendu sur papier. Le concept clé est le **PPP** (pixels par pouce, ou PPI en anglais) : combien de pixels de données image correspondent à un pouce de sortie imprimée.

Notre moteur de rendu fonctionne à 72 DPI, tandis que le CSS utilise 96 pixels par pouce comme référence. Pour calculer le PPP effectif d’une image dans votre document :

> **PPP effectif = (largeur en pixels de l’image x 72) / (largeur d’affichage CSS x 0,75)**

En pratique, une façon plus simple d’y penser : multipliez la taille d’affichage CSS par le facteur de ce tableau pour obtenir la taille d’image source dont vous avez besoin.

| Qualité d’impression | PPP cible | Taille de l’image source | Exemple |
| --- | --- | --- | --- |
| Écran ou affichage numérique uniquement | 96 | 1x la taille CSS | 400 px CSS → 400 px source |
| Bonne qualité d’impression | 150 | 1,5x la taille CSS | 400 px CSS → 600 px source |
| Haute qualité d’impression | 200 | 2x la taille CSS | 400 px CSS → 800 px source |
| Maximale (rarement nécessaire) | 300 | 3x la taille CSS | 400 px CSS → 1200 px source |

Pour la plupart des documents imprimés (factures, rapports, certificats), **150 PPP suffit amplement**. Au-delà de 200 PPP, les gains sont imperceptibles pour la plupart des gens, alors que la taille du fichier augmente significativement.

> [!TIP]
> Si votre document est uniquement consulté à l’écran (pièces jointes ouvertes dans un lecteur PDF, par exemple), 96 PPP (1x la taille CSS) suffit. Il n’y a aucun bénéfice à inclure des pixels supplémentaires qui ne seront jamais imprimés.


## Ce qui alourdit le fichier (et quoi faire)

| Facteur | Impact | Que faire |
| --- | --- | --- |
| Images source surdimensionnées | Tous les pixels sont stockés dans le PDF, même ceux non affichés | Redimensionner à 1,5-2x la taille d’affichage CSS |
| Grandes dimensions d’image | 2x la largeur = 4x le poids du fichier (croissance quadratique) | Garder les images aussi petites que vos besoins de qualité le permettent |
| Nombreuses images par document | Effet cumulatif sur la taille totale | Compresser et redimensionner chaque image avant l’envoi |
| Filtres CSS et modes de fusion | Peuvent forcer une charge de rastérisation supplémentaire | Éviter `filter`, `mix-blend-mode` et les `clip-path` complexes sur les grandes images |
| Copies multiples de la même image | Dédupliquées automatiquement par le moteur de rendu | Aucune action nécessaire |

### CSS pour contraindre la taille d’affichage des images

Utilisez `max-width` et `max-height` pour contrôler l’affichage des images dans votre template. N’oubliez pas que cela ne change que la taille **d’affichage** ; vous avez toujours besoin d’images source de taille appropriée.

```css title="CSS"
.product-image {
  max-width: 400px;
  height: auto;
}
```

```html title="HTML"
<!-- L'image source devrait faire ~600-800px de large pour une bonne qualité d'impression -->
<img class="product-image" src="{{product.imageUrl}}" />
```

## Checklist pratique

> [!TIP]
> **Avant de générer**
>
> 1. **Redimensionnez les images source** à 1,5-2x leur taille d’affichage CSS. Pas plus.
&gt; 2. **Vérifiez les dimensions des images** avant de les envoyer. Une photo de 4000 x 3000 affichée à 300 x 225 pixels CSS gaspille plus de 95 % de ses données pixel.
&gt; 3. **Utilisez le SVG pour les icônes, logos et graphiques simples.** Le SVG reste vectoriel dans le PDF et n’ajoute quasiment aucun poids.
&gt; 4. **Évitez les filtres CSS sur les grandes images.** `filter: blur()`, `filter: drop-shadow()` et les effets similaires peuvent forcer une rastérisation supplémentaire.
&gt; 5. **Testez avec des données réalistes.** Générez un document avec les images réelles que vous prévoyez d’utiliser, pas des placeholders, pour détecter les problèmes de taille en amont.


## Questions fréquentes

**Quelle résolution utiliser pour mes images ?**

Pour les documents destinés à l’impression, 150 PPP est un bon choix par défaut. Cela signifie que votre image source doit faire environ 1,5x la taille d’affichage CSS. Pour un affichage écran uniquement, 1x (96 PPP) suffit.

**Mon document fait 20 Mo. Comment le réduire ?**

Vérifiez les dimensions en pixels de vos images source. C’est presque toujours la cause. Redimensionnez-les à 1,5-2x leur taille d’affichage dans le template. Une photo de 4000 px de large affichée à 500 px CSS stocke 64 fois plus de données pixel que nécessaire à 1x.

**Le format d’image a-t-il une importance (PNG, JPEG, WebP) ?**

Le format source a très peu d’impact sur la taille du PDF car le moteur de rendu ré-encode tout avec une compression sans perte. Un JPEG de 100 Ko et un PNG de 500 Ko de la même image produiront des tailles de PDF quasi identiques. Concentrez-vous sur les **dimensions en pixels**, pas sur le format de fichier.

**Les images SVG réduisent-elles le poids du document ?**

Oui. Les SVG restent des données vectorielles dans le PDF et occupent très peu d’espace quelle que soit la taille d’affichage. Utilisez-les pour tout ce qui n’a pas besoin d’être une photographie : icônes, logos, graphiques, éléments décoratifs.

**Utiliser la même image plusieurs fois augmente-t-il la taille du fichier ?**

Non. Le moteur de rendu déduplique les sources d’images identiques. Si vous référencez la même URL ou le même data URI dix fois, une seule copie est stockée. En revanche, des recadrages ou transformations CSS différents de la même source peuvent ne pas être dédupliqués.

**Les images en `background-image` CSS suivent-elles les mêmes règles ?**

Oui. Les images de fond suivent les mêmes règles que les éléments `<img>`. Les pixels source sont embarqués en intégralité, et les mêmes recommandations de dimensionnement s’appliquent.

## Pages associées

- [Images et liens](https://pdfmonkey.io/fr/docs/modeles-code/images.md) : comment inclure des images dans vos templates (par URL, intégrées, SVG inline)
- [Mise en page](https://pdfmonkey.io/fr/docs/modeles-code/mise-en-page.md) : tailles de page, marges et arrière-plans pleine page
- [Générer des images au lieu de PDF](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) : produire des fichiers WebP, PNG ou JPG
- [Nos moteurs](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md) : versions des moteurs de rendu et fonctionnalités


## FAQ

**Pourquoi mon PDF PDFMonkey est-il si volumineux ?**

Des images source surdimensionnées en sont presque toujours la cause. Le moteur de rendu embarque tous les pixels source dans le PDF quelle que soit la taille d’affichage. Redimensionnez vos images à 1,5–2× leur taille d’affichage CSS pour réduire drastiquement le poids du fichier.

**Quelle résolution d’image utiliser pour les PDF PDFMonkey ?**

Pour les documents imprimés, 150 PPP (environ 1,5× la taille d’affichage CSS) est une bonne valeur par défaut. Pour un affichage écran uniquement, 96 PPP (1× la taille CSS) suffit. Au-delà de 200 PPP, les gains sont minimes tandis que la taille du fichier augmente significativement.

**Le format JPEG ou PNG a-t-il un impact sur le poids du PDF dans PDFMonkey ?**

Non. Le format source a très peu d’impact, car le moteur de rendu de PDFMonkey ré-encode toutes les images matricielles avec une compression sans perte. Un JPEG de 100 Ko et un PNG de 500 Ko de la même image produisent des PDF de tailles quasi identiques. Concentrez-vous sur les dimensions en pixels.


---

# Mise en page

Source: https://pdfmonkey.io/fr/docs/modeles-code/mise-en-page.md
Cette page explique comment contrôler la structure et la mise en page de vos pages PDF : dimensionnement, marges, conteneurs pleine page, fonds pleine page et sauts de page. Pour styliser votre contenu avec CSS, consultez [CSS personnalisée](https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md).

## Taille de page et marges {#default-page-sizes-in-pixels}

Vous pouvez modifier la taille des pages de votre Document dans l’onglet Paramètres du Template. Sélectionnez l’une des tailles prédéfinies, ou définissez une taille personnalisée qui correspond précisément à vos besoins.

Les tailles sont exprimées en millimètres. Si vous avez besoin de pouces, 1 pouce = 25,4 mm.

### Tailles de page par défaut en pixels {#default-page-sizes-in-pixels-1}

#### Pour les Templates utilisant le moteur v5

| Format        | Pixels         |
| ------------- | -------------- |
| A0            | 3178 x 4495    |
| A1            | 2245 x 3179    |
| A2            | 1588 x 2246    |
| A3            | 1123 x 1588    |
| **A4**        | **795 x 1123** |
| A5            | 560 x 795      |
| A6            | 397 x 560      |
| **US Letter** | **815 x 1056** |

#### Pour les Templates utilisant les anciens moteurs

| Format        | Pixels         |
| ------------- | -------------- |
| A0            | 3177 x 4492    |
| A1            | 2242 x 3177    |
| A2            | 1586 x 2242    |
| A3            | 1121 x 1586    |
| **A4**        | **793 x 1120** |
| A5            | 560 x 795      |
| A6            | 397 x 560      |
| **US Letter** | **815 x 1055** |

### Ajouter des marges {#adding-margins}

Vous pouvez ajouter des marges en haut, à gauche, à droite et en bas de votre Document dans l’onglet Paramètres du template.

**Quand utiliser les marges :** Si vous définissez un en-tête et/ou un pied de page dans les paramètres, vous devrez leur laisser de l’espace en ajoutant une marge en haut et/ou en bas. Si vous avez un document très simple et souhaitez de belles marges autour, cela fonctionne aussi.

**Quand ne pas utiliser les marges :** Si vous avez besoin d’une couleur ou image de fond pleine page, les marges réduiront la taille du contenu imprimé et empêcheront la couleur ou l’image d’aller de bord à bord. Si vous créez un document de type présentation et que chaque page de contenu doit remplir une page entière en utilisant les tailles en pixels listées ci-dessus, n’utilisez pas de marges sinon cela perturbera la mise en page.

## Mise en page sur une seule page {#single-page-layout}

Si vous souhaitez créer un conteneur qui occupe toujours une page entière (ni plus, ni moins), vous pouvez le définir ainsi :

```css title="CSS"
.page {
  /* Définition d’une page A4 portrait */
  height: 1120px;
  width: 793px;

  /* Empêchera tout contenu comme les grandes images de perturber */
  /* la mise à l’échelle automatique du contenu imprimé */
  overflow: hidden;

  /* Permettra au contenu positionné en absolu d’être */
  /* placé relativement à la page par défaut */
  position: relative;
}
```

Vous pouvez ensuite l’utiliser dans votre HTML :

```html title="HTML"
<div class="page">
  Contenu pour une seule page
</div>
```

### Utiliser un fond pleine page {#using-a-full-page-background}

Si vous souhaitez appliquer un fond qui prend la page entière, utilisez la technique ci-dessus et définissez l’image de fond sur votre page :

```css title="CSS"
.page-with-bg {
  background-image: url('url-ou-datauri-du-fond');
  background-size: cover;
}
```

```html title="HTML"
<div class="page page-with-bg">
  Contenu pour une seule page
</div>
```

## Sauts de page {#page-breaks}

### Forcer un saut de page {#forcing-a-page-break}

La manière la plus simple de forcer un saut de page est d’utiliser la CSS. Vous pouvez utiliser la propriété `page-break-before` pour définir une classe comme celle-ci :

```css title="CSS"
.page-break {
  page-break-before: always;
}
```

Vous pouvez ensuite appliquer cette classe à tout élément avant lequel vous souhaitez insérer un saut de page.

### Empêcher un saut de page {#preventing-a-page-break}

Si vous souhaitez éviter qu’une section de votre document soit coupée entre deux pages, vous pouvez utiliser la propriété CSS `page-break-inside` :

```css title="CSS"
.avoid-page-break {
  page-break-inside: avoid;
}
```

Si vous appliquez cette classe à un élément, elle n’aura aucun effet pour un élément au milieu de la page, mais s’il risque d’être coupé entre deux pages, un saut de page sera inséré avant celui-ci.


## FAQ

**Quelle est la taille d’une page A4 en pixels pour les templates PDFMonkey ?**

Sur le moteur v5, une page A4 fait 795×1123 pixels. Sur les anciens moteurs (v2–v4), elle fait 793×1120 pixels. Le format US Letter fait 815×1056 (v5) ou 815×1055 (anciens moteurs).

**Comment forcer un saut de page dans un PDF PDFMonkey ?**

Ajoutez une classe CSS avec page-break-before: always et appliquez-la à tout élément où vous souhaitez le saut. Par exemple : .page-break { page-break-before: always; }.

**Comment mettre un fond pleine page dans un template PDFMonkey ?**

Créez un conteneur dimensionné pour correspondre exactement à une page (par ex. 793×1120px pour un A4), définissez overflow: hidden et position: relative, puis appliquez une background-image avec background-size: cover. N’utilisez pas de marges de page, sinon elles réduiront la zone de contenu.

**Comment empêcher le contenu de se couper entre deux pages ?**

Appliquez la propriété CSS page-break-inside: avoid à tout élément que vous souhaitez garder sur une seule page. Si l’élément devait être coupé, un saut de page est inséré avant à la place.


---

# Polices web

Source: https://pdfmonkey.io/fr/docs/modeles-code/polices-web.md
Les polices personnalisées vous permettent d’harmoniser votre identité de marque et de prendre en charge les scripts non-latins dans vos templates PDFMonkey. Cette page couvre l’import de polices, l’utilisation de polices d’icônes, l’intégration des polices dans les en-têtes et pieds de page, la gestion des caractères spéciaux et l’activation des emojis.

> [!WARNING]
> **Compte payant uniquement**
>
> Le chargement de polices externes via URL (y compris Google Fonts) n’est possible que sur un compte payant. Les Documents incluant des polices externes échoueront sur un compte gratuit. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour plus de détails.
&gt; 
&gt; En alternative, les utilisateurs du plan gratuit peuvent embarquer les polices en utilisant data-URI. Voir le [tutoriel d’intégration des polices dans les en-têtes et pieds de page](#fonts-in-headers-and-footers) pour un exemple de cette technique.


## Utiliser Google Fonts {#using-google-fonts}

Pour importer une police depuis Google Fonts, rendez-vous sur [https://fonts.google.com/](https://fonts.google.com/) et recherchez une police qui vous plaît. Une fois trouvée, vous pouvez sélectionner une ou plusieurs variantes (graisse, italique, etc.) que vous souhaitez utiliser.

Dans le panneau de droite, vous obtiendrez un code `<link>` que vous pouvez copier en haut de votre HTML.

Importons Roboto en sélectionnant ses styles regular et bold par exemple :

```html title="HTML"
<!-- Import de Roboto, regular et bold -->
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap" rel="stylesheet">
```

Une fois la police ajoutée, vous pouvez l’utiliser dans votre CSS :

```css title="CSS"
body {
  font-family: 'Roboto';
}
```

## Autres services de polices

Vous pouvez également utiliser tout service d’hébergement de polices payant auquel vous êtes abonné ou simplement utiliser des polices auto-hébergées.

Dans ces cas, importez les polices en utilisant une balise `<link>` pointant vers la CSS de la police. Cette CSS et les fichiers de police doivent être accessibles publiquement, sinon ils ne se chargeront pas dans PDFMonkey.

## Polices d’icônes

PDFMonkey prend en charge les polices d’icônes comme [Font Awesome](https://fontawesome.com/) ou [Material Icons](https://developers.google.com/fonts/docs/material\_icons#icon\_font\_for\_the\_web). Veuillez vous référer à la documentation de la police que vous souhaitez utiliser pour apprendre comment l’importer.

## Polices dans les en-têtes et pieds de page {#fonts-in-headers-and-footers}

Comme indiqué dans notre [documentation sur les en-têtes et pieds de page](https://pdfmonkey.io/fr/docs/modeles-code/en-tete-et-pied-de-page.md), les en-têtes et pieds de page comportent certaines limitations. Puisque le contenu de l’onglet CSS ne s’applique pas à l’intérieur de l’en-tête et du pied de page, les polices ne s’appliqueront pas non plus.

Cela dit, il existe une solution plutôt technique que vous pouvez utiliser pour mettre votre en-tête et pied de page au même niveau que le reste du contenu.

### Étape 1 : Obtenir la CSS des polices

Sélectionnez les polices que vous souhaitez sur Google Fonts, puis récupérez l’URL fournie et copiez son contenu. Prenons la police Dancing Script et sélectionnons uniquement sa variante Regular 400. L’URL que nous obtenons est [https://fonts.googleapis.com/css2?family=Dancing+Script\&display=swap](https://fonts.googleapis.com/css2?family=Dancing+Script\&display=swap)

En visitant cette URL, le contenu que nous obtenons est le suivant :

```css
/* vietnamese */
@font-face {
  font-family: 'Dancing Script';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/dancingscript/v22/If2cXTr6YS-zF4S-kcSWSVi_sxjsohD9F50Ruu7BMSo3Rep6hNX6plRPjLo.woff) format('woff');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Dancing Script';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/dancingscript/v22/If2cXTr6YS-zF4S-kcSWSVi_sxjsohD9F50Ruu7BMSo3ROp6hNX6plRPjLo.woff) format('woff');
  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Dancing Script';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/dancingscript/v22/If2cXTr6YS-zF4S-kcSWSVi_sxjsohD9F50Ruu7BMSo3Sup6hNX6plRP.woff) format('woff');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
```

Vous pouvez commencer par copier ce contenu.

> [!NOTE]
> **Ne gardez que ce dont vous avez besoin**
>
> Sauf si vous avez besoin des caractères vietnamiens ou latins étendus, vous pouvez ne garder que la section « latin ». Elle couvrira l’alphabet de base plus la plupart des alphabets et accents d’Europe occidentale.


### Étape 2 : Remplacer les URLs des polices par leur contenu data-URI

Puisque les polices ne peuvent pas être chargées depuis une URL dans l’en-tête et le pied de page, vous devrez remplacer l’URL Google Fonts par une version data-URI.

Vous pouvez trouver d’excellents convertisseurs en ligne qui feront cela pour vous. Certains prennent simplement une URL en entrée et vous donneront la version data-URI en retour.

Vous pouvez maintenant remplacer l’URL par le texte data-URI que vous avez obtenu.

```css
/* latin */
@font-face {
  font-family: 'Dancing Script';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url('data:font/woff;base64,d09GRgABAAAAAG6...') format('woff');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
```

> [!NOTE]
> **Attention aux guillemets**
>
> Remarquez que lors du remplacement de l’URL, nous avons également entouré le contenu de guillemets. N’oubliez pas de le faire.


### Étape 3 : Remplacer le schéma data-URI

En l’état, la police ne fonctionnera pas et la génération échouera. Pour la faire fonctionner, nous devrons retirer ce qu’on appelle le type MIME du contenu data-URI. Retirez simplement tout ce qui se trouve entre `data:` et `;base64`.

```css
/* latin */
@font-face {
  font-family: 'Dancing Script';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url('data:;base64,d09GRgABAAAAAG6...') format('woff');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
```

### Étape 4 : Donner du style à votre en-tête/pied de page

Maintenant que notre CSS de polices fonctionne, vous pouvez l’ajouter à votre template. Rendez-vous dans l’onglet Paramètres et activez l’en-tête/pied de page Avancé.

Vous pouvez ensuite coller votre CSS de police dans une balise `<style>` :

```html title="Paramètres > En-tête"
<style>
  /* latin */
  @font-face {
    font-family: 'Dancing Script';
    font-style: normal;
    font-weight: 400;
    font-display: swap;
    src: url('data:;base64,d09GRgABAAAAAG6...') format('woff');
    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
  }

  #header, #footer {
    font-family: 'Dancing Script';
  }
</style>

<div>Ce texte devrait utiliser Dancing Script</div>
```

> [!NOTE]
> **Les styles d’en-tête et de pied de page sont partagés**
>
> Vous n’avez pas besoin de dupliquer l’import de police dans l’en-tête et le pied de page car tout style défini dans l’un s’applique également à l’autre. C’est pourquoi nous pouvons utiliser le sélecteur `#header, #footer` dans l’exemple ci-dessus.


## Emojis

PDFMonkey peut afficher des emojis dans les PDF générés. Cette fonctionnalité est désactivée par défaut et doit être activée pour chaque template.

Pour activer le rendu des emojis, ouvrez votre template et rendez-vous dans l’onglet **Paramètres** (Settings). Activez l’option emoji. Une fois activée, tous les caractères emoji présents dans votre template ou vos données dynamiques seront rendus dans le PDF généré.

## Caractères spéciaux et texte non-latin

La police par défaut de PDFMonkey est Open Sans. Bien qu’elle soit suffisamment esthétique pour la plupart des cas, elle ne couvre pas grand-chose en matière de caractères non-latins.

Si vous devez afficher des caractères non-latins dans vos documents, vous aurez besoin d’une [police web différente](#using-google-fonts).

Voici quelques jeux de caractères fréquemment demandés sur Google Fonts :

- [Arabe](https://fonts.google.com/?subset=arabic)
- [Chinois (Hong Kong)](https://fonts.google.com/?subset=chinese-hongkong)
- [Chinois (simplifié)](https://fonts.google.com/?subset=chinese-simplified)
- [Chinois (traditionnel)](https://fonts.google.com/?subset=chinese-traditional)
- [Cyrillique](https://fonts.google.com/?subset=cyrillic)
- [Cyrillique étendu](https://fonts.google.com/?subset=cyrillic-ext)
- [Hébreu](https://fonts.google.com/?subset=hebrew)
- [Japonais](https://fonts.google.com/?subset=japanese)

Vous pouvez trouver d’autres langues en utilisant le champ de sélection dédié sur [Google Fonts](https://fonts.google.com/) :

![Sélecteur de langues Google Fonts](https://pdfmonkey.io/fr/docs/img/google-fonts-language-support.webp)


## FAQ

**Comment utiliser Google Fonts dans un template PDFMonkey ?**

Copiez la balise <link> depuis Google Fonts et collez-la en haut de votre onglet HTML, puis référencez la famille de polices dans votre CSS. Le chargement de polices par URL nécessite un forfait PDFMonkey payant.

**Peut-on utiliser des polices personnalisées dans les en-têtes et pieds de page PDFMonkey ?**

Oui, mais vous devez intégrer la police en tant que data URI Base64 dans une balise <style> dans les paramètres d’en-tête/pied de page. Les URL de polices externes ne fonctionnent pas dans les en-têtes et pieds de page via les paramètres.

**Comment afficher des emojis dans un PDF PDFMonkey ?**

L’affichage des emojis est désactivé par défaut. Ouvrez votre template, allez dans l’onglet Paramètres et activez l’option emoji. Une fois activée, les caractères emoji dans votre template ou vos données dynamiques s’afficheront dans le PDF.

**Comment afficher des caractères non-latins comme le chinois ou l’arabe dans PDFMonkey ?**

Importez une police web qui prend en charge le jeu de caractères dont vous avez besoin. Google Fonts propose des polices pour l’arabe, le chinois, le japonais, le cyrillique, l’hébreu et de nombreux autres scripts. La police Open Sans par défaut ne couvre que les caractères latins de base.


---

# JavaScript personnalisé

Source: https://pdfmonkey.io/fr/docs/modeles-code/javascript-personnalise.mdL’éditeur de templates fournit un onglet HTML et un onglet CSS mais pas d’onglet JavaScript dédié. Vous pouvez toutefois utiliser JavaScript en ajoutant des balises `script` directement dans votre HTML.

## Utiliser les balises Script

Pour utiliser JavaScript dans vos templates, ouvrez une balise `script` dans l’onglet HTML :

```html title="HTML"
<script>
  // Écrivez votre JavaScript ici.
</script>
```

Vous pouvez ajouter autant de balises script que nécessaire, n’importe où dans votre HTML.

## Accéder aux données du Document

Pour rendre JavaScript plus puissant dans vos templates, vous pouvez accéder au payload de votre Document en tant qu’objet JavaScript.

Commencez par activer l’injection JavaScript pour votre template dans son onglet Paramètres :

![](https://pdfmonkey.io/fr/docs/img/template-settings-js-injection.webp)

Une fois activé, un objet `$docPayload` devient disponible dans vos scripts. Par exemple, avec ce payload :

```json title="JSON"
{
  "movie": {
    "title": "12 Monkeys",
    "year": 1995
  }
}
```

Vous pouvez accéder aux données comme ceci :

```html title="HTML"
<script>
  const movieTitle = $docPayload.movie.title;
  const titleDiv = document.getElementById('mt');
  titleDiv.textContent = movieTitle;
</script>

<div id="mt"></div>
```

> [!WARNING]
> **Limitation d’accès aux données avec JavaScript**
>
> Lorsque vous accédez aux données avec JS, **vous ne pouvez pas les insérer** en utilisant la syntaxe `{{movieTitle}}`. Cette syntaxe est spécifique à [Liquid](https://pdfmonkey.io/fr/docs/modeles-code/la-syntaxe-liquid.md) et est exécutée avant que votre code JS ne s’exécute.
&gt; 
&gt; Cela dit, vous pouvez générer du code JS en utilisant Liquid :
&gt; 
&gt; ```html
&gt; &lt;script&gt;
&gt;   const movieTitle = &#34;{{movieTitle | upcase}}&#34;;
&gt; &lt;/script&gt;
&gt; ```


## Bibliothèques externes

> [!WARNING]
> **Compte payant uniquement**
>
> L’inclusion de JavaScript basé sur une URL n’est possible que sur un compte payant. Les Documents incluant des fichiers JavaScript externes échoueront sur un compte gratuit. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour la liste complète.


Si vous avez besoin d’une bibliothèque qui transforme du texte, applique des filtres aux images, ou [insère des graphiques](#including-charts) dans votre Document, vous pouvez l’importer comme vous le feriez dans une page HTML normale.

Par exemple, pour afficher une chaîne Markdown issue de votre payload avec [marked.js](https://marked.js.org/) :

```html title="HTML"
<div id="notes"></div>

<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
<script>
  document.getElementById('notes').innerHTML = marked.parse($docPayload.notes);
</script>
```

Toute bibliothèque chargeable via CDN peut être utilisée dans vos templates de cette manière.

## Formater les dates et heures

Le moteur de PDFMonkey fonctionne sur des serveurs AWS situés en Europe. Le fuseau horaire du serveur n’est peut-être pas celui dans lequel vous souhaitez afficher vos dates.

> [!TIP]
> **Utilisez Liquid en priorité**
>
> La plupart des besoins de formatage de dates sont couverts par les filtres Liquid seuls, sans JavaScript. Utilisez le filtre [in\_time\_zone](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#in_time_zone) pour définir un fuseau horaire et le filtre [date](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#date) pour formater une date.


Si les filtres Liquid ne couvrent pas vos besoins, JavaScript offre des options supplémentaires.

### toLocaleString(locales, options)

La méthode [toLocaleString](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString) retourne une chaîne avec une représentation de la date adaptée à la langue.

Les arguments `locales` et `options` vous permettent de spécifier la langue dont les conventions de formatage doivent être utilisées et de personnaliser le comportement de la fonction.

```html title="HTML"
<script>
  // Afficher la date actuelle (date de génération du PDF) avec les conventions françaises.
  //
  new Date().toLocaleString('fr-FR');
  //=> "25/10/2050, 12:34:56"

  // Afficher une date fournie dans le payload du Document avec les conventions US.
  // Exemple de payload
  // { "someDate": "2050-10-25 12:34:56" }
  //
  new Date($docPayload.someDate).toLocaleString('en-US');
  //=> "10/25/2050, 12:34:56 PM"

  // Afficher une date avec les conventions en-US dans un fuseau horaire personnalisé.
  //
  let date = new Date(Date.UTC(2050, 1, 1, 12, 34, 56));
  new Date(date).toLocaleString('en-GB', { timeZone: 'Pacific/Honolulu' });
  //=> "01/02/2050, 02:34:56"
</script>
```

Vous pouvez en apprendre davantage sur la méthode toLocaleString dans sa [page de documentation MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString).

### Utiliser une bibliothèque

> [!WARNING]
> **Compte payant uniquement**
>
> L’utilisation d’une bibliothèque JS externe ne fonctionnera que sur un compte payant. Sur un compte gratuit, l’aperçu et la génération seront bloqués.


Si vous avez besoin d’une bibliothèque plus puissante, vous pouvez charger celle dont vous avez besoin. La plus fréquemment utilisée est MomentJS mais nous recommandons [Luxon](https://moment.github.io/luxon/#/?id=luxon), une itération plus récente de la même idée par l’auteur même de MomentJS :

```html title="HTML"
<script src="https://cdn.jsdelivr.net/npm/luxon@2.3.1/build/global/luxon.min.js"></script>
<script>
  let { DateTime } = luxon;
  let date = DateTime.fromISO("2050-01-01T12:34:56");
  date.plus({ days: 3 }).setZone('Pacific/Honolulu').toLocaleString(DateTime.DATETIME_HUGE);
  //=> "Tuesday, 4 January 2050, 01:34 Hawaii-Aleutian Standard Time"
</script>
```

## Inclure des graphiques {#including-charts}

> [!WARNING]
> **Compte payant uniquement**
>
> L’inclusion de JavaScript basé sur une URL n’est possible que sur un compte payant. Les Documents incluant des fichiers JavaScript externes échoueront sur un compte gratuit. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour la liste complète.


Vous pouvez utiliser la plupart des bibliothèques de graphiques pour générer des graphiques dans PDFMonkey. D’après notre expérience, [Chart.js](https://www.chartjs.org/) est l’option la plus fiable : il s’affiche correctement dans tous les lecteurs PDF et propose une grande variété de types de graphiques.

Deux réglages sont essentiels pour les graphiques dans un PDF :

- **`animation: false`** — Les animations ne sont pas jouées dans un PDF. Si elles restent activées, le graphique risque d’être capturé en cours de transition, produisant un rendu vide ou incomplet.
- **`responsive: false`** — Désactiver cette option vous permet de contrôler la taille du graphique via les attributs `width` et `height` de l’élément `canvas`, évitant les surprises de mise en page.

### Exemple avec Chart.js {#chartjs-example}

L’exemple ci-dessous charge Chart.js depuis un CDN et affiche un graphique en barres à partir des données du payload du Document. Il inclut les deux réglages essentiels mentionnés ci-dessus.

Avec ce payload :

```json title="Payload"
{
  "chart": {
    "labels": ["Jan", "Fév", "Mar", "Avr", "Mai"],
    "values": [120, 190, 150, 210, 175]
  }
}
```

Ajoutez ceci dans le HTML de votre template :

```html title="HTML"
<canvas id="myChart" width="500" height="300"></canvas>

<script src="https://cdn.jsdelivr.net/npm/chart.js@4/dist/chart.umd.js"></script>
<script>
  new Chart(document.getElementById('myChart'), {
    type: 'bar',
    data: {
      labels: $docPayload.chart.labels,
      datasets: [{
        label: 'Ventes mensuelles',
        data: $docPayload.chart.values,
        backgroundColor: '#4f8bc6'
      }]
    },
    options: {
      animation: false,
      responsive: false
    }
  });
</script>
```

![Exemple de graphique en barres généré avec Chart.js](https://pdfmonkey.io/fr/docs/img/chart-example.webp)

Vous pouvez adapter cet exemple à n’importe quel [type de graphique Chart.js](https://www.chartjs.org/docs/latest/charts/) (courbes, camembert, anneau, radar, etc.) en changeant la valeur de `type` et en ajustant la structure de `data`.

> [!WARNING]
> **Compatibilité ApexCharts**
>
> [ApexCharts.js](https://apexcharts.com/) est connu pour produire des bordures noires autour des graphiques dans certains lecteurs PDF, notamment sous Windows et sur Android. Si vous utilisez ApexCharts, testez votre rendu sur plusieurs appareils avant de passer en production.


## Débogage

Si votre JavaScript ne se comporte pas comme prévu, utilisez le bouton **Debug** en haut de l’éditeur de templates. Il ouvre la version HTML de votre template, générée à partir de vos données de test, directement dans votre navigateur.

![](https://pdfmonkey.io/fr/docs/img/template-debug-button.webp)

Cela vous donne l’occasion d’inspecter les erreurs JS dans la console et devrait vous aider à comprendre ce qui ne fonctionne pas.

## Compatibilité navigateur

Notre moteur PDF actuel (v5) est basé sur **Chrome&nbsp;133**. Vous pouvez vérifier si une fonctionnalité JS spécifique est disponible en utilisant le [tableau de comparaison caniuse](https://caniuse.com/?compare=chrome+133&compareCats=JS,JS%20API).

> [!NOTE]
> Si vos templates utilisent une version de moteur plus ancienne, consultez [Nos moteurs](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md) pour voir quelle version de Chrome s’applique à votre moteur.



## FAQ

**Peut-on utiliser du JavaScript dans les modèles PDFMonkey ?**

Oui. Ajoutez des balises script directement dans l’onglet HTML de l’éditeur de modèle. Activez l’injection JavaScript dans les paramètres du modèle pour accéder aux données du document via l’objet $docPayload.

**Quelles bibliothèques JavaScript sont disponibles dans PDFMonkey ?**

Chart.js pour les graphiques et Day.js pour le formatage des dates sont intégrés au moteur de rendu. Sur les forfaits payants, vous pouvez également charger des bibliothèques JavaScript externes depuis un CDN.

**Comment accéder aux données du document depuis JavaScript dans PDFMonkey ?**

Activez l’injection JavaScript dans les paramètres du modèle. Un objet $docPayload devient alors disponible dans vos scripts, contenant l’intégralité du payload JSON transmis lors de la création du document.


---

# CSS personnalisée pour les modèles code

Source: https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md
L’éditeur de templates fournit un onglet CSS dédié dans lequel vous pouvez écrire n’importe quel CSS standard. Vos styles s’appliquent aux éléments HTML que vous insérez dans l’onglet HTML lors du rendu.

Si vous souhaitez savoir si une fonctionnalité CSS spécifique est disponible, vous pouvez consulter [cette liste de compatibilité pour Chrome&nbsp;133](https://caniuse.com/?compare=chrome+133&compareCats=CSS), la version utilisée par notre moteur actuel (v5). Chrome&nbsp;133 supporte la quasi-totalité des fonctionnalités CSS modernes, y compris **Flexbox**, **CSS Grid**, les **propriétés personnalisées**, les **container queries** et la **pseudo-classe `:has()`**.

> [!NOTE]
> Si vos templates utilisent une version de moteur plus ancienne, consultez [Nos moteurs](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md) pour voir quelle version de Chrome s’applique à votre moteur.


> [!TIP]
> **Vous cherchez la mise en page ?**
>
> Pour la taille de page, les marges, les mises en page sur une seule page, les fonds pleine page et les sauts de page, consultez [Mise en page](https://pdfmonkey.io/fr/docs/modeles-code/mise-en-page.md).


## Bibliothèques CSS externes

Écrire votre propre CSS est toujours possible, mais une bibliothèque CSS utilitaire peut accélérer considérablement le développement de templates. Les frameworks comme Bootstrap ont tendance à imposer des opinions marquées en matière de styles d’impression et peuvent perturber votre mise en page. Nous recommandons des outils plus légers comme [Tailwind CSS](https://tailwindcss.com/) ou [Tachyons](https://tachyons.io/).

> [!WARNING]
> **Compte payant uniquement (en général)**
>
> Le chargement de CSS via une URL nécessite un compte payant. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour la définition complète et la disponibilité par offre.
&gt; 
&gt; Cela dit, **une exception est faite pour la CSS hébergée sur nos propres serveurs** — voir [Versions hébergées de Tailwind CSS](#hosted-tailwind-css-versions) ci-dessous.


## Versions hébergées de Tailwind CSS {#hosted-tailwind-css-versions}

PDFMonkey fournit des Master Templates, et nous avons mis à disposition des versions hébergées des ressources utilisées pour les construire. Comme ces fichiers sont hébergés sur nos serveurs, ils fonctionnent sur les **comptes Free et payants** — aucune restriction de ressource externe ne s’applique.

### Tailwind CSS v4.x et v3.x (JIT)

Ces versions fonctionnent exactement comme celle disponible via le [CDN Tailwind CSS](https://tailwindcss.com/docs/installation/play-cdn). Incluez le script dans votre onglet HTML, en remplaçant le lien CDN officiel par le nôtre :

```html title="HTML"
<script src="https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-4.js"></script>
```

Versions disponibles :

* [tailwindcss-4.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-4.js) (dernière version, actuellement 4.1.17)
* [tailwindcss-4.1.17.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-4.1.17.js)
* [tailwindcss-4.0.1.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-4.0.1.js)
* [tailwindcss-3.4.3.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-3.4.3.js)
* [tailwindcss-3.3.3.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-3.3.3.js)
* [tailwindcss-3.2.6.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-3.2.6.js)
* [tailwindcss-3.2.0.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-3.2.0.js)
* [tailwindcss-3.0.23.js](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-3.0.23.js)

Pour les versions v3.x, vous pouvez personnaliser la configuration comme vous le feriez avec le CDN officiel :

```html title="HTML"
<script src="https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/js/tailwindcss-3.0.23.js"></script>
<script>
  tailwind.config = {
    theme: {
      extend: {
        colors: {
          clifford: '#da373d',
        }
      }
    }
  }
</script>
<style type="text/tailwindcss">
  @layer utilities {
    .content-auto {
      content-visibility: auto;
    }
  }
</style>
```

### Tailwind CSS v2.0.3 (historique)

Nous fournissons une version allégée de Tailwind CSS v2.0.3, débarrassée de tout style qui n’a pas de sens dans un contexte d’impression, comme les animations ou les utilitaires responsive. Elle pèse 165 Ko.

Vous pouvez l’importer depuis votre onglet CSS en utilisant :

```css title="CSS"
@import url("https://pdfmonkey-resources.s3.eu-west-3.amazonaws.com/css/tailwind-light.min.css");
```

Vous pouvez également l’importer depuis l’onglet HTML mais sachez que vos styles seront définis avant, et cela peut rendre plus difficile la surcharge des classes Tailwind.

## Styles par document {#the-css-custom-properties-technique}

Le code que vous écrivez dans l’onglet CSS ne peut pas appeler les variables fournies dans le payload du Document. Cela dit, vous pouvez utiliser les propriétés personnalisées CSS (aussi appelées variables CSS) pour passer des valeurs dynamiques à votre CSS sur une base par document.

Par exemple, si vous souhaitez passer une couleur dans vos données :

```json title="Payload JSON"
{
  "color": "#db2777"
}
```

Vous pouvez créer une propriété personnalisée qui prend sa valeur et la rend disponible pour votre CSS :

```html title="HTML"
<style>
  :root {
    --color: "{{color}}";
  }
</style>
```

```css title="CSS"
h1 {
  color: var(--color);
}
```

Cette technique fonctionne pour toute valeur CSS : couleurs, tailles de police, espacements ou même familles de polices.


## FAQ

**Peut-on utiliser Tailwind CSS dans les templates PDFMonkey ?**

Oui. PDFMonkey héberge plusieurs versions de Tailwind CSS (v2 à v4) sur ses propres serveurs, elles fonctionnent donc sur les comptes Free et payants. Incluez la balise script dans votre onglet HTML en pointant vers la version hébergée.

**Comment passer des valeurs CSS dynamiques dans PDFMonkey ?**

Utilisez les propriétés personnalisées CSS. Définissez une variable dans une balise <style> de votre HTML en utilisant la syntaxe Liquid (par ex. --color: "{{color}}"), puis référencez-la dans votre onglet CSS avec var(--color). Cela vous permet de changer les couleurs, polices ou espacements par document.

**Quelles fonctionnalités CSS PDFMonkey supporte-t-il ?**

Le moteur actuel de PDFMonkey (v5) est basé sur Chrome 133, qui supporte la quasi-totalité des fonctionnalités CSS modernes, y compris Flexbox, CSS Grid, les propriétés personnalisées, les container queries et la pseudo-classe :has().


---

# Utiliser les QR Codes pour les modèles code

Source: https://pdfmonkey.io/fr/docs/modeles-code/codes-qr.md
L’ajout de QR codes dans les documents PDF est un besoin courant pour les factures, les étiquettes d’expédition, les billets d’événements, et bien d’autres cas. PDFMonkey prend en charge plusieurs bibliothèques JavaScript qui vous permettent de générer des QR codes directement dans vos templates, avec un contrôle total sur le style et le contenu.

> [!WARNING]
> **Compte payant uniquement**
>
> Cette technique utilise JavaScript et n’est donc utilisable que sur un compte payant ou pendant [votre période d’essai de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md).


## qr-code-styling (recommandé) {#qr-code-styling}

[qr-code-styling](https://github.com/kozakdenys/qr-code-styling) est la bibliothèque que nous utilisons dans le Builder PDFMonkey. Elle offre le plus de personnalisation : plusieurs styles de points (square, dots, rounded, classy…), styles de coins, couleurs personnalisées, niveaux de correction d’erreur, et même un logo centré.

```html
<script src="https://cdn.jsdelivr.net/npm/qr-code-styling@^1.6/lib/qr-code-styling.js"></script>

<div id="qrcode"></div>

<script type="text/javascript">
  var qrCode = new QRCodeStyling({
    width: 200,
    height: 200,
    data: "https://pdfmonkey.io/",
    margin: 0,
    dotsOptions: {
      type: "rounded",
      color: "#0ea5e9"
    },
    cornersSquareOptions: {
     type: "extra-rounded"  // square, dot, extra-rounded
    }
  });

  qrCode.append(document.getElementById("qrcode"));
</script>
```

Vous pouvez également ajouter un logo au centre du QR code en passant `image` et `imageOptions` :

```html
<script src="https://cdn.jsdelivr.net/npm/qr-code-styling@^1.6/lib/qr-code-styling.js"></script>

<div id="qrcode"></div>

<script type="text/javascript">
  var qrCode = new QRCodeStyling({
    width: 200,
    height: 200,
    data: "https://pdfmonkey.io/",
    margin: 0,
    dotsOptions: {
      type: "rounded",
      color: "#0ea5e9"
    },
    cornersSquareOptions: {
     type: "extra-rounded"  // square, dot, extra-rounded
    },

    image: "https://example.com/logo.png",
    imageOptions: {
      imageSize: 0.4,
      margin: 4,
      crossOrigin: "anonymous"
    },
    qrOptions: {
      errorCorrectionLevel: "Q"  // utiliser Q ou H lorsqu’un logo est ajouté
    }
  });

  qrCode.append(document.getElementById("qrcode"));
</script>
```

![QR code généré avec qr-code-styling](https://pdfmonkey.io/fr/docs/img/qr-code-example.webp)

## bitjson/qr-code

[Cette bibliothèque](https://qr.bitjson.com/) offre un composant web très simple que vous pouvez utiliser pour insérer un QR Code dans votre document. Elle n’a aucune dépendance, vous pouvez donc simplement lier la bibliothèque via un CDN et insérer le composant dans votre code :

```html
<script src="https://cdn.jsdelivr.net/npm/@bitjson/qr-code@^1.0/dist/qr-code.js"></script>

<!--
  contents : le texte à transformer
  module-color : couleur des points
  position-ring-color : couleur des grands carrés environnants
  position-center-color : couleur des petits carrés environnants
-->
<qr-code
  contents="https://pdfmonkey.io/"
  module-color="#0ea5e9"
  position-ring-color="#db7222"
  position-center-color="#27db22"
  style="width: 200px;"
></qr-code>
```

> [!WARNING]
> **Évitez les animations**
>
> Les animations et le rendu PDF ne font généralement pas bon ménage. Évitez de copier-coller des morceaux de code qui utilisent des animations, ou retirez la partie animation, sinon le QR Code pourrait ne pas terminer son animation avant l’« impression », résultant en un QR Code absent ou incomplet.


### Points uniquement

Le principal inconvénient de cette bibliothèque est que vous êtes limité au style des points. Vous ne pouvez obtenir que des cercles.

## QRCode.js

Pour un QR Code d’aspect plus « classique », la bibliothèque [QRCode.js](https://davidshimjs.github.io/qrcodejs/) est une bonne option. Elle n’offre pas beaucoup de personnalisation mais devrait suffire dans la plupart des cas.

```html
<script src="https://cdn.jsdelivr.net/npm/qrcodejs@^1.0/qrcode.min.js"></script>

<div id="qrcode"></div>

<script type="text/javascript">
  new QRCode(
    document.getElementById("qrcode"),
    {
      text: "http://pdfmonkey.io/",
      width: 200,
      height: 200,
      correctLevel: QRCode.CorrectLevel.L
    }
  );
</script>

```

Ces trois bibliothèques fonctionnent avec le moteur de rendu PDF de PDFMonkey. Pour en savoir plus sur le chargement et l’utilisation de JavaScript dans vos templates, consultez [Custom JavaScript](https://pdfmonkey.io/fr/docs/modeles-code/javascript-personnalise.md).


## FAQ

**Comment ajouter un QR code à un PDF PDFMonkey ?**

Incluez une bibliothèque JavaScript de QR code via une balise script CDN dans votre HTML. PDFMonkey supporte qr-code-styling (recommandé), bitjson/qr-code et QRCode.js. Un forfait payant ou une période d’essai active est nécessaire car des scripts externes sont requis.

**Quelle bibliothèque de QR code utiliser avec PDFMonkey ?**

qr-code-styling est recommandé. C’est la bibliothèque qui offre le plus de personnalisation — styles de points, styles de coins, couleurs personnalisées, niveaux de correction d’erreur, et la possibilité d’intégrer un logo au centre du QR code.

**Peut-on ajouter un logo à l’intérieur d’un QR code dans PDFMonkey ?**

Oui. Utilisez la bibliothèque qr-code-styling et passez les propriétés image et imageOptions. Définissez le niveau de correction d’erreur sur Q ou H pour que le QR code reste lisible malgré le logo superposé.


---

# En-tête et pied de page

Source: https://pdfmonkey.io/fr/docs/modeles-code/en-tete-et-pied-de-page.md
Les en-têtes et pieds de page permettent de répéter des informations sur chaque page de votre PDF : un logo, un titre de document, des numéros de page, une date, des mentions légales, etc. PDFMonkey offre trois façons de les ajouter, chacune avec ses compromis. Choisissez la plus simple qui répond à vos besoins.

| Approche | Idéale pour | Images/polices externes | Numéros de page | Sauter la couverture |
|---|---|---|---|---|
| [Paramètres](#settings-based) | Contenu fluide (contrats, rapports) | Non (inline uniquement) | Oui | Non |
| [Dans le contenu](#in-content) | Mise en page fixe (certificats, livres) | Oui | Via compteur CSS | Oui |
| [Paged.js](#pagedjs) | Contenu fluide avec en-têtes riches | Oui | Oui | Oui |

## En-tête et pied de page via les paramètres {#settings-based}

L’approche la plus simple. Ouvrez l’onglet **Paramètres** de votre Template et remplissez les champs d’en-tête et/ou de pied de page. Le contenu est affiché sur chaque page, par-dessus le contenu du document.

> [!WARNING]
> **Définissez d’abord vos marges**
>
> Le contenu de l’en-tête et du pied de page ne s’affiche que si le Template possède une marge en haut et/ou en bas. Si rien n’apparaît, augmentez les marges dans l’onglet Paramètres.


### Mode basique

Les champs par défaut offrent trois emplacements (gauche, centre, droite) par en-tête et pied de page. Vous pouvez utiliser deux balises spéciales :

- `[page]` — numéro de la page courante
- `[topage]` — nombre total de pages

### Mode avancé

Passez en mode Avancé pour écrire du HTML personnalisé. Vous obtenez un contrôle total sur la mise en page et pouvez utiliser ces équivalents HTML pour les numéros de page :

```html
<span class="pageNumber"></span>  <!-- numéro de la page courante -->
<span class="totalPages"></span>  <!-- nombre total de pages -->
```

Vous pouvez également utiliser des données dynamiques (syntaxe Liquid) en mode avancé. Pour les caractères accentués, appliquez le filtre [`entities`](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#entities) :

```liquid
{{ company.name | entities }}
```

### Limitations

Les en-têtes et pieds de page via les paramètres sont rendus par le mécanisme intégré d’impression de Chromium, qui impose des contraintes strictes :

- **Pas de ressources externes** — les images, la CSS et les polices ne peuvent pas être chargées via HTTP. Utilisez des [data URI](https://css-tricks.com/data-uris/) pour les images et des balises `<style>` inline pour la CSS. Pour les polices, consultez [Polices dans les en-têtes et pieds de page](https://pdfmonkey.io/fr/docs/modeles-code/polices-web.md#fonts-in-headers-and-footers).
- **Pas d’UTF-8 pour les caractères accentués** — le texte fixe nécessite des [entités HTML](https://dev.w3.org/html5/html-author/charref) (ex. `&eacute;` pour `é`). Pour les données dynamiques, utilisez le filtre [`entities`](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#entities).
- **Pas d’exécution JavaScript** — aucune solution de contournement.
- **Impossible de sauter la page de couverture** — aucune solution de contournement.
- **Contrôle limité des styles** — l’onglet CSS ne s’applique pas à l’intérieur de la zone d’en-tête/pied de page. Les styles doivent être inline.

## En-tête et pied de page dans le contenu {#in-content}

Pour les documents à mise en page fixe où vous contrôlez chaque page individuellement — certificats, livres pour enfants, rapports de type diaporama — vous pouvez placer l’en-tête et le pied de page directement dans votre contenu HTML. Cette approche vous donne un accès complet à l’onglet CSS, aux images externes, aux polices web et au JavaScript. Aucune solution de contournement d’encodage nécessaire.

<span id="exception-powerpoint-like-documents"></span>

Un document est « à mise en page fixe » lorsque chaque page est un bloc distinct de taille connue et que le contenu ne s’écoule pas d’une page à la suivante. Chaque `<div class="page">` est autonome.

### Numéros de page avec les compteurs CSS

Puisque le contenu HTML ne sait pas sur quelle page il se trouve, vous utilisez un compteur CSS pour suivre les numéros de page. Voici un exemple en A4 portrait :

```html title="HTML"
<div class="page">
  <div>Contenu de la page 1</div>
  <div class="page-number"></div>
</div>

<div class="page">
  <div>Contenu de la page 2</div>
  <div class="page-number"></div>
</div>

<div class="page">
  <div>Contenu de la page 3</div>
  <div class="page-number"></div>
</div>
```

```css title="CSS"
/* Initialise un compteur nommé « page » à 0 */
/* Supprime les espacements par défaut pour un dimensionnement correct */
body {
  counter-reset: page;
  margin: 0;
  padding: 0;
}

/* Une page A4 portrait fait 793x1120px */
/* Cache le dépassement pour éviter les artefacts de zoom d’impression */
.page {
  height: 1120px;
  overflow: hidden;
  position: relative;
  width: 793px;
}

/* Positionne le numéro de page en bas à droite */
.page-number {
  bottom: 30px;
  position: absolute;
  right: 30px;
  text-align: right;
}

/* Incrémente le compteur et affiche sa valeur */
.page-number::before {
  counter-increment: page;
  content: counter(page);
}
```

![Numéros de page par compteur CSS](https://pdfmonkey.io/fr/docs/img/page-number-css-counter.webp)

Les compteurs CSS sont plus robustes que des numéros codés en dur dans le HTML car ils restent corrects lorsque des pages sont conditionnellement affichées/masquées ou générées dans une boucle.

### Limitations

- **Ne fonctionne que pour les documents à mise en page fixe.** Si votre contenu s’écoule d’une page à l’autre (comme un long contrat), vous ne pouvez pas prédire où les sauts de page tomberont et donc pas placer un pied de page en bas de chaque page. Utilisez [Paged.js](#pagedjs) à la place.

## En-tête et pied de page avec Paged.js {#pagedjs}

[Paged.js](https://pagedjs.org/about/) est une bibliothèque JavaScript qui implémente la spécification CSS Paged Media. Elle offre des en-têtes et pieds de page complets pour du contenu fluide — avec un support total de la CSS, des polices, des images et du JavaScript.

> [!WARNING]
> **Forfait payant requis**
>
> Le chargement de JavaScript externe par URL nécessite un forfait PDFMonkey payant. Les Documents incluant des scripts externes échoueront sur un forfait gratuit.


### Fonctionnement

Paged.js repose sur deux concepts CSS :

1. **Éléments flottants (running elements)** — vous définissez des éléments HTML et les déclarez comme `running()` en CSS. Ils sont retirés du flux normal.
2. **Boîtes de marge (margin boxes)** — dans une règle `@page`, vous placez ces éléments flottants dans les zones de marge de la page (`@top-center`, `@bottom-center`, etc.).

### Exemple pas à pas

**1. Définissez les éléments d’en-tête et de pied de page dans votre HTML :**

```html title="HTML"
<div id="pageHeader">
  <div class="header-content">
    <img src="https://placekitten.com/60/60" />
    <div>Texte d’en-tête</div>
  </div>
</div>

<div id="pageFooter">
  <div class="footer-content">
    <div>Pied de page gauche</div>
    <div>Pied de page droite</div>
  </div>
</div>

<div class="content">Le contenu de votre document va ici.</div>

<script src="https://cdn.jsdelivr.net/npm/pagedjs@0.3.5/dist/paged.polyfill.js"></script>
```

**2. Déclarez-les comme éléments flottants et stylisez-les dans l’onglet CSS :**

> [!WARNING]
> **Onglet CSS uniquement**
>
> Sauf si vous utilisez le CDN JavaScript de Tailwind CSS 3, la règle `@page` ci-dessous **doit** être dans l’onglet CSS et non dans une balise `&lt;style&gt;` à l’intérieur de l’onglet HTML. Sinon, cela ne fonctionnera pas.


```css title="CSS"
/* Déclarer comme éléments flottants */
#pageHeader {
  position: running(pageHeader);
}

#pageFooter {
  position: running(pageFooter);
}

/* Styliser le contenu de l’en-tête et du pied de page */
.header-content, .footer-content {
  align-items: center;
  background: #1f2937;
  color: #fff;
  display: flex;
  height: 80px; /* Doit correspondre à la marge @page ci-dessous */
  justify-content: space-between;
  padding: 0 30px;
}

.content {
  text-align: center;
}
```

**3. Placez-les dans les marges de la page :**

```css title="CSS"
@page {
  size: A4;

  /* Même hauteur que le contenu de l’en-tête/pied de page */
  margin: 80px 0;

  /* Placer les éléments flottants dans les marges de page */
  @top-center { content: element(pageHeader); }
  @bottom-center { content: element(pageFooter); }
}
```

Le résultat :

![En-tête et pied de page avec Paged.js](https://pdfmonkey.io/fr/docs/img/page-number-paged-js.webp)

> [!NOTE]
> **Taille de page**
>
> Cet exemple utilise le format A4. Vous pouvez utiliser d’autres tailles nommées comme `A3`, `Letter`, etc. ou des valeurs en pixels. Consultez les [tailles de page par défaut en pixels](https://pdfmonkey.io/fr/docs/modeles-code/mise-en-page.md#default-page-sizes-in-pixels).


> [!NOTE]
> **Les noms doivent correspondre**
>
> Le nom dans `running(pageHeader)` doit correspondre au nom dans `element(pageHeader)`. Si vous aviez utilisé `running(superHeader)`, vous appelleriez `element(superHeader)`.


### Problème connu : en-têtes de tableaux multi-pages

Paged.js peut casser les tableaux qui s’étendent sur plusieurs pages lorsqu’ils possèdent des éléments `<thead>`. Si vous rencontrez ce problème, consultez ce [contournement sur GitHub](https://gist.github.com/theinvensi/e1aacc43bb5a3d852e2e85b08cf85c8a).

### En savoir plus

Pour les compteurs de pages, le contenu dynamique dans les marges, les exceptions de première page et d’autres fonctionnalités avancées, consultez la documentation Paged.js sur le [Contenu généré dans les boîtes de marge](https://pagedjs.org/documentation/7-generated-content-in-margin-boxes/).


## FAQ

**Comment ajouter des en-têtes et pieds de page à un PDF PDFMonkey ?**

PDFMonkey propose trois approches : via les paramètres (remplir les champs d’en-tête/pied de page dans l’onglet Paramètres), dans le contenu (placer le HTML d’en-tête et pied de page directement dans votre template pour les documents à mise en page fixe), et Paged.js (une bibliothèque JavaScript pour le contenu fluide avec des en-têtes et pieds de page riches).

**Peut-on ajouter des numéros de page à un PDF PDFMonkey ?**

Oui. En mode paramètres, utilisez les balises [page] et [topage]. Pour les mises en page dans le contenu, utilisez les compteurs CSS. Avec Paged.js, utilisez le support intégré des compteurs de pages dans les boîtes de marge CSS.

**Pourquoi mes images d’en-tête et de pied de page ne s’affichent-elles pas dans PDFMonkey ?**

Les en-têtes et pieds de page via les paramètres ne peuvent pas charger de ressources externes via HTTP. Utilisez des data URI pour les images et des styles inline pour la CSS. Sinon, passez aux en-têtes dans le contenu ou via Paged.js qui supportent les images et polices externes.

**Comment sauter l’en-tête sur la première page de mon PDF ?**

Les en-têtes via les paramètres ne peuvent pas sauter la page de couverture. Utilisez plutôt l’approche Paged.js — elle prend en charge les exceptions de première page grâce aux règles CSS @page :first et aux éléments flottants.


---

# Composants de template réutilisables avec les Snippets et Partials

Source: https://pdfmonkey.io/fr/docs/modeles-code/reutiliser-du-code.md
PDFMonkey vous offre deux moyens de réutiliser du code et d’éviter la duplication :

- Les **Snippets** sont partagés entre les templates — définissez-les une fois sur la page Snippets et incluez-les dans n’importe quel template.
- Les **Partials** sont locaux à un seul template — définissez un bloc réutilisable en ligne et incluez-le plusieurs fois dans le même template.

Les deux utilisent le tag `include` pour afficher le bloc réutilisable avec les variables que vous lui passez.

## Snippets

Si vous avez besoin de partager du code entre plusieurs Templates, vous pouvez définir des snippets dans la page **Snippets** de votre compte PDFMonkey. Le nom que vous donnez à un Snippet est celui que vous utiliserez pour y faire référence plus tard dans vos Templates.

Définissons deux snippets :

```liquid title="Snippet : user-name"
{%- if userName -%}
  {{userName}}
{%- else -%}
  Quelqu’un
{%- endif -%}
```

```liquid title="Snippet : items-list"
{%- for item in list -%}
  <p>{{item}}</p>
{%- endfor -%}
```

Vous pouvez ensuite les charger et les inclure dans un Template :

```liquid title="Template"
{%- load_snippets 'user-name', 'items-list' -%}

<p>Bonjour {% include 'user-name', userName: "Jane Doe" %}</p>

{% include 'items-list', list: user.groceries %}
```

> [!NOTE]
> Vous devez charger les snippets avec `load_snippets` avant de pouvoir les inclure avec `include`. Listez tous les snippets nécessaires dans un seul appel `load_snippets` en haut de votre template.


## Partials

Les partials fonctionnent comme les Snippets mais sont définis directement dans un Template. Vous n’avez pas besoin de les charger avant de les inclure :

```liquid title="Template"
{%- partial 'line-item' -%}
  <tr>
    <td>{{product.name}}</td>
    <td>{{product.unitPrice}}</td>
    <td>{{product.quantity}}</td>
    <td>{{product.totalPrice}}</td>
  </tr>
{%- endpartial -%}

{% for lineItem in lineItems %}
  {% include 'line-item', product: lineItem %}
{% endfor %}
```

Les partials sont idéaux lorsque vous devez répéter un bloc au sein d’un même template — comme une ligne de tableau, une carte, ou tout élément récurrent — sans avoir à créer un Snippet partagé.


## FAQ

**Comment réutiliser du code entre plusieurs templates PDFMonkey ?**

Utilisez les Snippets. Définissez des blocs de code réutilisables dans la page Snippets de votre compte PDFMonkey, puis chargez-les dans n’importe quel template avec le tag load_snippets et incluez-les avec le tag include.

**Quelle est la différence entre les Snippets et les Partials dans PDFMonkey ?**

Les Snippets sont partagés entre les templates — définissez-les une fois et incluez-les dans n’importe quel template. Les Partials sont locaux à un seul template — définissez un bloc réutilisable en ligne et incluez-le plusieurs fois au sein du même template.

**Comment passer des variables à un Snippet ou un Partial dans PDFMonkey ?**

Passez les variables sous forme de paires clé-valeur dans le tag include. Par exemple : {% include 'user-name', userName: "Jane Doe" %}. Le Snippet ou le Partial peut ensuite utiliser ces variables dans son code Liquid.


---

# Formulaires PDF interactifs (AcroForms)

Source: https://pdfmonkey.io/fr/docs/code-templates/pdf-forms.md
PDFMonkey peut générer des formulaires PDF interactifs (AcroForms) en détectant des marqueurs spéciaux dans votre modèle et en les convertissant en champs de formulaire à remplir. Les PDF générés peuvent être complétés directement dans les lecteurs PDF comme Adobe Acrobat ou Aperçu.

## Activer les formulaires PDF

Pour activer les formulaires PDF dans votre modèle :

1. Allez dans l'onglet **Paramètres** de votre modèle
2. Activez l'option **PDF Forms**
3. Ajoutez des marqueurs de champs dans le contenu de votre modèle

Via l'API, définissez `use_forms: true` dans l'objet `settings` ou `settings_draft` de votre modèle.

## Syntaxe des marqueurs

Les marqueurs suivent une syntaxe spécifique qui indique à PDFMonkey quel type de champ créer et comment le configurer :

```
[% data_form_field_TYPE_NOM_OPTIONS %]
```

### Éléments obligatoires

- `[%` et `%]` — délimiteurs de début et de fin
- `data_form_field` — préfixe requis pour la détection
- `TYPE` — type de champ (text, checkbox, dropdown, etc.)

### Éléments optionnels

- `NOM` — nom personnalisé du champ (par ex. `firstname`, `email`)
- `OPTIONS` — dimensions, validation, alignement, etc.

### Exemples de base

```html
[% data_form_field_text_w200_h30 %]
[% data_form_field_checkbox_w20_h20 %]
[% data_form_field_dropdown_w250_h30_options[Option1,Option2,Option3] %]
```

## Types de champs

### Champs texte

#### Texte sur une ligne

```html
[% data_form_field_text_w300_h30 %]
[% data_form_field_text_firstname_w250_h30_required %]
```

Utilisez pour : noms, adresses, numéros de téléphone, texte court.

#### Texte multiligne (textarea)

```html
[% data_form_field_textarea_w400_h100 %]
[% data_form_field_textarea_comments_w500_h150_max500 %]
```

Utilisez pour : commentaires, descriptions, messages longs.

#### Champ mot de passe

```html
[% data_form_field_text_password_w250_h30_password %]
```

#### Champ e-mail (avec validation)

```html
[% data_form_field_text_email_w350_h30_email %]
[% data_form_field_text_contact_w400_h30_required_email %]
```

#### Champ téléphone

```html
[% data_form_field_text_phone_w200_h30_phone %]
```

### Champs de sélection

#### Case à cocher

```html
[% data_form_field_checkbox_w20_h20 %]
[% data_form_field_checkbox_accept_terms_w20_h20_required %]
```

Exemple dans un modèle :

```html
<p>☐ J'accepte les conditions [% data_form_field_checkbox_accept_w20_h20 %]</p>
<p>☐ S'inscrire à la newsletter [% data_form_field_checkbox_newsletter_w20_h20 %]</p>
```

#### Liste déroulante

```html
[% data_form_field_dropdown_w250_h30_options[Option1,Option2,Option3] %]
[% data_form_field_dropdown_country_w300_h30_options[France,Belgique,Suisse,Canada] %]
```

> [!WARNING]
> Vous devez spécifier toutes les options dans le marqueur avec `options[A,B,C]`. Une liste déroulante sans options ne sera pas créée.


#### Boutons radio

```html
[% data_form_field_radio_w20_h20_options[Homme,Femme,Autre] %]
[% data_form_field_radio_payment_w20_h20_options[Carte,Virement,Espèces] %]
```

Les boutons radio portant le même nom forment un groupe — une seule option peut être sélectionnée à la fois.

### Champs spécialisés

#### Champ numérique

```html
[% data_form_field_number_w100_h30 %]
[% data_form_field_number_age_w80_h30_min18_max120 %]
[% data_form_field_number_quantity_w60_h30_min1_max99 %]
```

#### Champ date

```html
[% data_form_field_date_w150_h30_format_dd_mm_yyyy %]
[% data_form_field_date_birthdate_w150_h30_format_dd_mm_yyyy_required %]
```

Formats disponibles :

- `format_dd_mm_yyyy` — JJ/MM/AAAA (européen)
- `format_mm_dd_yyyy` — MM/JJ/AAAA (américain)
- `format_yyyy_mm_dd` — AAAA-MM-JJ (ISO)

#### Champ peigne (pour les codes)

```html
[% data_form_field_text_zipcode_w150_h30_max5_comb %]
[% data_form_field_text_serial_w200_h30_max10_comb %]
```

Utilisez pour : codes postaux, numéros de série, codes de vérification. Chaque caractère a sa propre case visuelle.

#### Champs sans bordure

```html
[% data_form_field_text_w300_h30_noborder %]
[% data_form_field_text_user_id_w200_h30_invisible_readonly %]
```

Utilisez pour des formulaires élégants sans rectangles noirs, des champs de métadonnées invisibles, ou des valeurs pré-remplies. L'option `noborder` met la bordure à 0 et l'arrière-plan en transparent tout en gardant le champ fonctionnel.

**Technique des lignes pointillées :** combinez un marqueur en blanc, `noborder`, et des lignes pointillées en dessous :

```html
<p style="color: white;">[% data_form_field_text_email_w350_h30_noborder_email %]</p>
<p style="border-bottom: 1px dotted #999; width: 350px;"></p>
```

Le marqueur blanc est invisible dans le PDF, les lignes pointillées guident l'utilisateur, et le champ généré est transparent et fonctionnel.

## Options des champs

### Dimensions

Requises pour un rendu correct :

| Option | Description |
|:---|:---|
| `w{largeur}` | Largeur en pixels |
| `h{hauteur}` | Hauteur en pixels |

**Tailles recommandées :**

| Type de champ | Largeur | Hauteur |
|:---|:---|:---|
| Nom court | 150–250 px | 30 px |
| E-mail | 300–400 px | 30 px |
| Adresse | 400–500 px | 30 px |
| Zone de texte | 400–600 px | 80–150 px |
| Case à cocher | 20 px | 20 px |
| Liste déroulante | 200–300 px | 30 px |
| Date | 120–150 px | 30 px |
| Nombre | 60–100 px | 30 px |

### État du champ

| Option | Description |
|:---|:---|
| `required` | Champ obligatoire |
| `mandatory` | Alias de required |
| `readonly` | Lecture seule (non modifiable) |

### Contraintes

| Option | Description |
|:---|:---|
| `max{nombre}` | Longueur maximale (texte) ou valeur maximale (nombre) |
| `min{nombre}` | Valeur minimale (nombre uniquement) |

### Alignement et style

| Option | Description |
|:---|:---|
| `left` | Texte aligné à gauche (par défaut) |
| `center` | Texte centré |
| `right` | Texte aligné à droite |
| `font{taille}` | Taille de police (10, 12, 14, etc.) |

### Valeurs par défaut

Pré-remplissez un champ avec `default_{valeur}`. Remplacez les espaces par des tirets bas :

```html
[% data_form_field_text_country_w200_h30_default_France %]
[% data_form_field_text_w300_h30_default_Entrez_votre_nom %]
```

### Noms de champs personnalisés

Le premier élément non reconnu dans le marqueur devient le nom du champ :

```html
[% data_form_field_text_firstname_w200_h30 %]
```

Ici `firstname` est le nom du champ. Utilisez des noms descriptifs en snake_case (`user_email` plutôt que `email1`) pour faciliter le traitement des données.

## Exemples complets

### Formulaire de contact

```html
<h1>Formulaire de contact</h1>

<p>Nom : [% data_form_field_text_lastname_w300_h30_required %]</p>
<p>Prénom : [% data_form_field_text_firstname_w300_h30_required %]</p>
<p>E-mail : [% data_form_field_text_email_w350_h30_required_email %]</p>
<p>Téléphone : [% data_form_field_text_phone_w200_h30_phone %]</p>

<p>Message :</p>
<p>[% data_form_field_textarea_message_w500_h120_required_max1000 %]</p>

<p>☐ J'accepte d'être contacté(e) [% data_form_field_checkbox_accept_w20_h20 %]</p>
```

### Formulaire d'inscription

```html
<h1>Formulaire d'inscription</h1>

<h2>Informations personnelles</h2>
<p>Civilité : [% data_form_field_dropdown_civility_w100_h30_options[M.,Mme] %]</p>
<p>Nom : [% data_form_field_text_lastname_w250_h30_required %]</p>
<p>Prénom : [% data_form_field_text_firstname_w250_h30_required %]</p>
<p>Date de naissance : [% data_form_field_date_birthdate_w150_h30_format_dd_mm_yyyy %]</p>
<p>Âge : [% data_form_field_number_age_w80_h30_min18_max120 %]</p>

<h2>Contact</h2>
<p>E-mail : [% data_form_field_text_email_w350_h30_required_email %]</p>
<p>Téléphone : [% data_form_field_text_phone_w200_h30_phone %]</p>

<h2>Adresse</h2>
<p>Rue : [% data_form_field_text_address_w450_h30_required %]</p>
<p>Code postal : [% data_form_field_text_zipcode_w120_h30_max5_comb %]</p>
<p>Ville : [% data_form_field_text_city_w250_h30_required %]</p>
<p>Pays : [% data_form_field_dropdown_country_w250_h30_options[France,Belgique,Suisse,Canada] %]</p>

<h2>Conditions</h2>
<p>☐ J'accepte les conditions [% data_form_field_checkbox_accept_terms_w20_h20_required %]</p>
<p>☐ S'inscrire à la newsletter [% data_form_field_checkbox_newsletter_w20_h20 %]</p>
```

## Dépannage

### Marqueur non détecté

Le marqueur reste visible dans le PDF final. Vérifiez :

1. Le préfixe est exactement `data_form_field` (pas `form_field` ni `data_field`)
2. Les délimiteurs sont `[%` et `%]` (pas `{%` `%}` ni d'autres crochets)
3. Il n'y a pas de saut de ligne à l'intérieur du marqueur

### Champ mal positionné

Ajustez les dimensions `w` et `h` et assurez-vous qu'il y a suffisamment d'espace dans le modèle autour du marqueur.

### Liste déroulante ou radio sans options

Les listes déroulantes et les boutons radio nécessitent le paramètre `options[...]`. Sans lui, le champ n'est pas créé.

```
[% data_form_field_dropdown_country_w250_h30_options[France,Belgique,Suisse] %]
```

## Bonnes pratiques

1. **Commencez simple** — testez avec 2 ou 3 champs avant de construire un formulaire complet
2. **Nommez vos champs** — utilisez des noms descriptifs pour faciliter le traitement des données
3. **Testez en prévisualisation** — vérifiez toujours votre modèle avant de générer des documents
4. **Utilisez des valeurs par défaut** — pré-remplissez les champs courants pour réduire l'effort de saisie
5. **Masquez les marqueurs visuellement** — donnez au marqueur la même couleur que l’arrière-plan pour le rendre invisible sous le champ :
   ```html
   <span style="color: white;">[% data_form_field_text_name_w300_h30 %]</span>
   ```
6. **Combinez les styles de bordure** — utilisez des bordures classiques pour les champs obligatoires et `noborder` pour les champs secondaires afin de créer une hiérarchie visuelle

## Limitations

- Les champs de signature ne sont pas pris en charge en tant que champs de formulaire interactifs
- La validation complexe au-delà des types de base (e-mail, téléphone) est limitée
- Les champs fonctionnent au mieux avec le moteur PDF v5

## Pages associées

- [Mise en page](https://pdfmonkey.io/fr/docs/modeles-code/mise-en-page.md) — contrôler la taille des pages et les marges
- [CSS personnalisé](https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md) — styliser vos formulaires
- [Référence API Templates](https://pdfmonkey.io/fr/docs/api/templates.md) — documentation API pour les paramètres de modèle


## FAQ

**PDFMonkey peut-il générer des formulaires PDF à remplir ?**

Oui. Activez l'option Formulaires PDF dans les paramètres de votre modèle, puis ajoutez la syntaxe de marqueurs dans votre HTML. PDFMonkey détecte les marqueurs et les convertit en champs interactifs AcroForm dans le PDF généré.

**Quels types de champs de formulaire PDFMonkey prend-il en charge ?**

PDFMonkey prend en charge les champs texte, zones de texte multiligne, cases à cocher, listes déroulantes, boutons radio, champs numériques, champs de date et champs peigne. Chaque type de champ accepte des options de dimensions, validation, alignement et valeurs par défaut.

**Les champs de formulaire PDF fonctionnent-ils avec l'API ?**

Oui. Activez les formulaires via l'API en définissant use_forms: true dans les paramètres de votre modèle. La syntaxe de marqueurs dans le HTML du modèle est traitée lors de la génération, produisant des champs interactifs dans le PDF de sortie.


---

# CLI

Source: https://pdfmonkey.io/fr/docs/modeles-code/cli.md
Cet outil CLI est une excellente solution pour les développeurs qui souhaitent créer des templates PDFMonkey en utilisant leur propre éditeur de code et leur environnement de développement local.

## Installation

Le CLI PDFMonkey peut être installé via npm.

```bash
npm install -g @pdfmonkey/cli
```

Une fois installé, la commande `pdfmonkey` sera disponible dans votre terminal.

## Aide

Pour obtenir la liste des commandes disponibles et l’aide générale, exécutez la commande suivante :

```bash
pdfmonkey help
```

## Authentification

Il existe deux façons de s’authentifier avec le CLI PDFMonkey :

1. Toutes les commandes acceptent l’option `-k` ou `--api-key` pour spécifier une clé API.
2. Vous pouvez également définir la variable d’environnement `PDFMONKEY_API_KEY`.

> [!WARNING]
> **Clé API dans cette page**
>
> Les commandes ci-dessous **supposent que la clé API est définie dans la variable d’environnement.**


## Init

Pour commencer à éditer un template PDFMonkey, exécutez la commande suivante :

```bash
pdfmonkey init <template-id>
```

Vous serez ensuite invité à choisir le répertoire de destination pour les fichiers du template. Vous pouvez également spécifier le dossier de destination comme second argument.

```bash
pdfmonkey init <template-id> <dossier-destination>
```

> [!TIP]
> **Ouvrir dans l’éditeur**
>
> Vous pouvez également ouvrir le dossier créé dans votre éditeur par défaut en utilisant l’option `-e` ou `--edit`.
&gt; 
&gt; ```bash
&gt; pdfmonkey init &lt;template-id&gt; -e
&gt; ```


## Watch

Pour surveiller un dossier de template et synchroniser les modifications vers PDFMonkey, exécutez la commande suivante :

```bash
pdfmonkey watch -t <template-id>
```

Cela commencera à surveiller les fichiers dans **le dossier courant** et synchronisera automatiquement.

Pour surveiller un dossier différent, passez simplement le chemin comme premier argument :

```bash
pdfmonkey watch <chemin> -t <template-id>
```

> [!TIP]
> **ID du template et nom du dossier**
>
> Si le dossier surveillé porte le nom de l’ID du template, vous pouvez omettre l’option `-t`.
&gt; 
&gt; ```bash
&gt; pwd
&gt; /Users/pdfmonkey/templates/B1001CF2-53FC-4DC6-B51D-36B358743752
&gt; 
&gt; pdfmonkey watch
&gt; # Surveille le dossier courant et synchronise le template correspondant
&gt; ```


### Aperçu

La commande `watch` démarrera un serveur local pour prévisualiser le template. L’aperçu se rafraîchira automatiquement lorsque les modifications seront synchronisées.

Vous pouvez ouvrir l’aperçu lorsque le serveur est en cours d’exécution en utilisant l’option `-o` ou `--open-browser`.

```bash
pdfmonkey watch -o
```

Par défaut, le serveur d’aperçu fonctionne sur le port 2081 et le serveur de rechargement automatique sur le port 2082. Vous pouvez spécifier des ports différents en utilisant les options `-p/--port` et `-l/--livereload-port`.

```bash
pdfmonkey watch -p 2083 -l 2084
```

Vous pouvez également définir les variables d’environnement `PORT` et `LIVE_RELOAD_PORT` pour personnaliser les ports.

```bash
PORT=2083 LIVE_RELOAD_PORT=2084 pdfmonkey watch
```

### Aperçu de débogage

Parfois, il peut être plus facile de déboguer le HTML généré plutôt que le PDF. Vous pouvez le faire en utilisant l’option `-D` ou `--debug`.

```bash
pdfmonkey watch -D -o
```

Cela ouvrira l’aperçu de débogage dans votre navigateur par défaut.

### Gestion des conflits

Au lancement de la commande `watch`, le CLI vérifiera s’il y a des conflits entre les fichiers locaux et les données du template. S’il y en a, vous serez invité à choisir entre :

1. Écraser les fichiers locaux avec les données du template.
2. Garder les fichiers locaux et remplacer les données du template lors de la prochaine synchronisation.
3. Voir un diff des modifications.

Par défaut, l’outil de diff utilisé est `diff -u` et le patch est affiché avec le pager `less`. Vous pouvez spécifier un outil de diff et un pager différents en utilisant les variables d’environnement `DIFF` et `PAGER`, respectivement.

```bash
DIFF=delta PAGER=delta pdfmonkey watch
```

## Configuration

Voici un résumé des variables d’environnement qui peuvent être définies pour personnaliser le comportement du CLI :

* `PDFMONKEY_API_KEY` : La clé API à utiliser pour l’authentification.
* `DIFF` : L’outil de diff à utiliser.
* `PAGER` : Le pager à utiliser pour afficher les diffs.
* `PORT` : Le port sur lequel exécuter le serveur d’aperçu.
* `LIVE_RELOAD_PORT` : Le port sur lequel exécuter le serveur de rechargement automatique.


---

# Nos moteurs

Source: https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md
Lorsque vous générez un Document, PDFMonkey utilise un moteur web basé sur Chrome pour rendre votre contenu HTML/CSS puis l’« imprimer » en PDF. Le moteur actuel est le **v5**, basé sur **Chrome 133** : vous pouvez faire tout ce qui fonctionne dans un navigateur moderne (sauf les animations, bien entendu).

## Versions du moteur

PDFMonkey a sorti plusieurs versions de moteur au fil des années. Chaque version apporte une version plus récente de Chrome avec une compatibilité CSS et JavaScript plus large. Les templates restent sur la version du moteur avec laquelle ils ont été créés. Vous pouvez vérifier et changer la version du moteur dans l’onglet Paramètres de votre template.

| Moteur | Version Chrome | Statut     | Fonctionnalités clés                                                                           |
| ------ | -------------- | ---------- | ---------------------------------------------------------------------------------------------- |
| **v5** | Chrome 133     | **Actuel** | Dernières fonctionnalités CSS/JS, génération d’images, précision de rendu améliorée            |
| **v4** | Chrome 123     | Disponible | Pseudo-classe `:has()`, container queries, `text-wrap: balance`, import maps, emojis en option |
| **v3** | Chromium 86    | Historique | ES2020, Flexbox, Grid, propriétés personnalisées                                               |
| **v2** | Chromium 79    | Historique | Support CSS et JS moderne de base                                                              |

> [!TIP]
> **Passez à la v5**
>
> pour le meilleur rendu et la compatibilité la plus large. Les nouveaux templates sont créés en v5 par défaut.


### v5 (Chrome 133 (actuel))

Le moteur v5 est le plus récent et le plus performant. Basé sur Chrome 133, il supporte la quasi-totalité des fonctionnalités CSS et JavaScript modernes. Il a également introduit la **génération d’images** (sortie PNG/JPEG en plus du PDF) et amélioré la précision du rendu pour les tailles de page et les marges.

### v4 (Chrome 123)

Le moteur v4 a été une mise à jour majeure qui a apporté plusieurs fonctionnalités CSS très demandées :

- **Pseudo-classe `:has()`** (styliser les éléments parents en fonction de leurs enfants)
- **Container queries** (mises en page responsives basées sur la taille du conteneur plutôt que le viewport)
- **`text-wrap: balance`** (retour à la ligne équilibré pour les titres)
- **Import maps** (utiliser les imports de modules ES sans bundler)
- **Emojis en option** (support du rendu natif des emojis)

### v3 (Chromium 86, historique)

Le moteur v3 offre une prise en charge complète d’ES2020, de Flexbox, de CSS Grid et des propriétés personnalisées. Si cela s’affiche dans Chrome 86, cela s’affiche sur v3.

### v2 (Chromium 79, historique)

Le moteur v2 est le plus ancien moteur encore supporté. Il couvre les bases de la CSS et JavaScript modernes mais ne dispose pas de nombreuses fonctionnalités disponibles dans les moteurs plus récents.

## Limites de temps de génération

À partir du moteur v4, PDFMonkey a introduit des **temps de génération étendus** qui donnent à vos templates plus de temps pour rendre les documents complexes. Le temps de génération maximum dépend de votre forfait :

| Forfait | Temps de génération max |
| ------- | ----------------------- |
| Free    | 30 secondes             |
| Pro     | 2 minutes               |
| Pro+    | 3 minutes               |
| Premium | 5 minutes               |

> [!WARNING]
> Les templates sur le moteur v2 ou v3 sont limités à **30 secondes** quel que soit le forfait. Passez au moteur v4 ou v5 pour bénéficier des temps de génération étendus.



## FAQ

**Quel moteur de rendu PDFMonkey utilise-t-il ?**

PDFMonkey utilise un moteur basé sur Chrome pour convertir du HTML/CSS en PDF. La version actuelle est la v5, basée sur Chrome 133, qui supporte la quasi-totalité des fonctionnalités CSS et JavaScript modernes.

**Comment changer la version du moteur sur mon template PDFMonkey ?**

Ouvrez votre template et allez dans l’onglet Paramètres. La version du moteur y est affichée et peut être modifiée. Les templates restent sur le moteur avec lequel ils ont été créés, sauf si vous le changez manuellement.

**Quel est le temps de génération maximum d’un PDF dans PDFMonkey ?**

Cela dépend de votre forfait et de la version du moteur. Sur le moteur v4 ou v5, les limites vont de 30 secondes (Free) à 5 minutes (Premium). Les templates sur le moteur v2 ou v3 sont limités à 30 secondes quel que soit le forfait.


---

# Service professionnel de création de templates PDF

Source: https://pdfmonkey.io/fr/docs/modeles-code/offre-de-creation-de-modeles.md
Vous n’avez pas le temps ou les compétences pour créer vos propres templates ? PDFMonkey propose un service de **Template Authoring** : notre équipe conçoit et code des templates PDF prêts pour la production, directement dans votre compte.

## À qui s’adresse ce service ?

Le Template Authoring est fait pour vous si :

- Vous avez un design PDF finalisé mais pas les compétences HTML/CSS pour le mettre en œuvre
- Vous avez besoin d’une mise en page complexe (tableaux multi-pages, sections conditionnelles, graphiques) et souhaitez que ce soit bien fait du premier coup
- Vous êtes pressé par le temps et préférez confier le travail à des personnes qui connaissent la plateforme sur le bout des doigts

## Tarifs

| | Coût |
| --- | --- |
| **Prix de base** par template | À partir de 1 000 EUR |
| **Supplément urgence** (délai inférieur à 2 mois) | +500 EUR |

Le prix de base couvre un template standard avec les éléments dynamiques habituels. Le tarif final peut être plus élevé pour les designs complexes — graphiques, logique conditionnelle avancée ou nombre de pages inhabituellement élevé — et nous confirmons toujours le devis avant de commencer.

Tous les prix sont indiqués hors taxes. Selon votre localisation, la TVA ou d’autres taxes applicables peuvent s’ajouter.

> [!NOTE]
> **Pourquoi un supplément urgence ?**
>
> PDFMonkey est une équipe de deux personnes. Une seule personne s’occupe de tous les templates en plus du développement de la plateforme, notre bande passante est donc réellement limitée. Le supplément urgence reflète la perturbation de planning qu’un délai serré engendre.


## Comment ça fonctionne

1. **Envoyez-nous vos éléments.** Transmettez-nous par e-mail le design de votre PDF ainsi que tous les assets nécessaires : images, polices, clés de licence et bibliothèques personnalisées. Si vous avez des exemples de documents montrant différents scénarios de données, joignez-les aussi — cela accélère considérablement le travail.

2. **Décrivez le comportement dynamique.** Indiquez-nous les parties du document qui changent en fonction des données : paragraphes conditionnels, lignes répétées, champs calculés, etc. Plus les règles sont précises, moins nous aurons besoin d’allers-retours.

3. **Nous créons le template.** Nous construisons le template directement dans votre compte PDFMonkey et vous tenons informé tout au long du développement.

4. **Vous testez et validez.** Une fois le template prêt, testez-le en modifiant ses [données de test](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#defining-test-data) avec vos propres valeurs. Partagez vos retours et nous ajusterons le code jusqu’à ce que vous soyez satisfait.

## Modifications après livraison

Besoin de changements par la suite ? Contactez-nous avec une description de ce dont vous avez besoin et nous vous enverrons un devis en fonction de la charge de travail à prévoir.


## FAQ

**Combien coûte le service de création de templates PDFMonkey ?**

Le prix de base commence à 1 000 EUR par template. Un supplément urgence de 500 EUR s’applique pour les délais inférieurs à deux mois. Le tarif final peut être plus élevé pour les designs complexes impliquant des graphiques, de la logique conditionnelle avancée ou un grand nombre de pages.

**Que dois-je fournir pour le service de création de templates PDFMonkey ?**

Envoyez le design de votre PDF accompagné de tous les assets nécessaires : images, polices, clés de licence et bibliothèques personnalisées. Incluez des exemples de documents montrant différents scénarios de données et décrivez les parties dynamiques du document (paragraphes conditionnels, lignes répétées, champs calculés).

**Peut-on demander des modifications au template après livraison ?**

Oui. Contactez l’équipe PDFMonkey avec une description des modifications souhaitées et elle vous enverra un devis en fonction de la charge de travail à prévoir.



---

# Votre premier modèle

Source: https://pdfmonkey.io/fr/docs/modeles-builder/votre-premier-modele.md
Le builder visuel vous permet de créer des modèles PDF en glissant-déposant des blocs sur un canevas, sans avoir besoin de HTML ou CSS. Dans ce tutoriel, vous allez construire un modèle de document simple à partir de zéro, ajouter du texte et des images, connecter des données de test, et générer votre premier PDF.

## Ouvrir le builder

Depuis votre tableau de bord PDFMonkey, cliquez sur **New Template** (Nouveau modèle). Donnez un nom à votre modèle, puis sélectionnez **Builder** comme mode de modèle. Cliquez sur **Create** (Créer) pour ouvrir l’éditeur visuel.

## Découvrir l’interface

Le builder comporte trois zones principales :

![L’interface du builder montrant la disposition en trois panneaux](https://pdfmonkey.io/fr/docs/img/builder-overview.webp)

- **Panneau gauche :** bascule entre l’arbre **Éléments** (qui montre la structure de votre modèle) et le panneau **Blocks** (où vous choisissez de nouveaux blocs à ajouter).
- **Canevas central :** un aperçu en direct de votre modèle. Ce que vous voyez ici correspond à l’apparence finale de votre PDF.
- **Panneau droit :** bascule entre **Styles** (propriétés visuelles comme les couleurs, les espacements et les polices) et **Settings** (configuration spécifique au bloc et logique).

La barre d’outils en haut du canevas vous donne accès aux données de test, aux éditeurs de CSS et JavaScript personnalisés, aux ressources externes, et aux raccourcis clavier.

## Ajouter vos premiers blocs

Chaque nouveau modèle démarre avec un bloc **Page** déjà en place. Le bloc Page représente une page de votre PDF (il contrôle le format du papier, l’orientation et les marges).

Pour ajouter du contenu, basculez vers le panneau **Blocks** dans la barre latérale gauche. Les blocs sont organisés en trois catégories : **Layout**, **Content** et **Extra**.

![Le panneau Blocks montrant les trois catégories de blocs](https://pdfmonkey.io/fr/docs/img/blocks-panel.webp)

Commencez par ajouter un bloc **Container** à l’intérieur de la Page. Un Container regroupe d’autres blocs et contrôle leur disposition (empilement vertical, rangée horizontale ou grille). Faites-le glisser depuis le panneau Blocks vers le canevas, ou cliquez dessus pour l’ajouter à l’intérieur de l’élément actuellement sélectionné.

Ensuite, ajoutez un bloc **Heading** à l’intérieur du Container. Sélectionnez le Heading dans le canevas, puis regardez le panneau droit sous **Settings** pour choisir le niveau de titre (h1 à h6). Cliquez sur **Edit Heading Content** pour saisir le texte de votre titre.

Ajoutez un bloc **Text** sous le Heading. Les blocs Text supportent la mise en forme enrichie (gras, italique, listes et liens).

> [!TIP]
> Vous pouvez réorganiser les blocs en les faisant glisser dans l’arbre **Éléments** du panneau gauche. C’est souvent plus facile que de les déplacer directement sur le canevas.


## Modifier le contenu textuel

Sélectionnez un bloc Text et ouvrez l’onglet **Settings** dans le panneau droit. Cliquez sur **Edit Text Content** pour ouvrir l’éditeur de texte enrichi.

![La fenêtre de l’éditeur de texte enrichi pour modifier le contenu textuel](https://pdfmonkey.io/fr/docs/img/text-editor.webp)

L’éditeur vous propose une barre de mise en forme avec des options pour le gras, l’italique, le soulignement, le barré, les listes à puces, les listes numérotées et les liens. Saisissez votre contenu, appliquez la mise en forme souhaitée, puis fermez la fenêtre. Vos modifications apparaissent immédiatement sur le canevas.

Les blocs Heading fonctionnent de la même manière (cliquez sur **Edit Heading Content** dans Settings pour ouvrir l’éditeur).

## Ajouter une image

Ajoutez un bloc **Image** depuis la catégorie Content du panneau Blocks. Sélectionnez-le, puis ouvrez l’onglet **Settings** pour configurer la source de l’image.

![Les paramètres du bloc Image montrant le champ de saisie de l’URL source](https://pdfmonkey.io/fr/docs/img/image-settings.webp)

Vous avez trois options pour définir la source de l’image :

- **URL statique :** collez un lien direct vers une image hébergée en ligne.
- **Upload :** cliquez sur le bouton d’upload pour sélectionner un fichier depuis votre ordinateur. L’image est convertie en URI de données et intégrée directement dans le modèle.
- **Liaison dynamique :** cliquez sur le bouton du navigateur de variables pour lier la source à un champ de vos données de test (par exemple, `company.logo`). Cela permet à chaque document généré d’utiliser une image différente.

> [!NOTE]
> Pour de meilleures performances de rendu PDF, utilisez des images optimisées. Les fichiers volumineux en haute résolution augmentent le temps de génération.


## Utiliser les données de test

La plupart des modèles incluent du contenu dynamique (des données qui changent pour chaque document généré). Le builder vous permet de définir des données de test afin de prévisualiser l’apparence de votre modèle avec des valeurs réelles.

Cliquez sur le bouton **Edit Test Data** dans la barre d’outils au-dessus du canevas. Cela ouvre un éditeur JSON où vous définissez des données d’exemple.

![L’éditeur de données de test avec un exemple de payload JSON](https://pdfmonkey.io/fr/docs/img/test-data-editor.webp)

Saisissez un objet JSON avec les champs dont votre modèle a besoin. Par exemple :

```json
{
  "name": "Marie Dupont",
  "company": "Acme Corp",
  "items": [
    { "description": "Consulting", "amount": 1500 },
    { "description": "Développement", "amount": 3000 }
  ]
}
```

Une fois les données de test enregistrées, le navigateur de variables dans le builder affiche vos champs disponibles. Vous pouvez lier le contenu textuel, les sources d’images, les conditions de visibilité et les boucles à ces chemins de données. Les modifications des données de test mettent à jour l’aperçu du canevas immédiatement.

> [!TIP]
> L’éditeur de données de test supporte les commentaires JSON (lignes commençant par `//`). Utilisez-les pour documenter ce que chaque champ représente (ils sont supprimés lors de l’analyse et n’affectent pas votre modèle).


## Enregistrer votre modèle

Appuyez sur **Ctrl+S** (ou **Cmd+S** sur Mac) pour enregistrer votre modèle. Le builder envoie la requête de sauvegarde au tableau de bord, où votre modèle est stocké.

N’oubliez pas de **publier** votre modèle depuis le tableau de bord avant de générer des documents. Les modèles non publiés ne peuvent pas être utilisés pour la génération de documents.

## Générer un document

Une fois votre modèle publié, vous pouvez générer des documents de trois façons :

- [Depuis le tableau de bord](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md) — créez des documents manuellement via un formulaire.
- [Via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — générez des documents par programmation depuis votre application.
- [Via une intégration](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-une-integration.md) — connectez Zapier, Make, n8n et d’autres plateformes no-code.

Dans tous les cas, vous envoyez un payload JSON correspondant à la structure de vos données de test, et PDFMonkey produit un PDF.

## Prochaines étapes

Maintenant que vous avez construit votre premier modèle, explorez les autres fonctionnalités du builder :

- [Blocs disponibles](https://pdfmonkey.io/fr/docs/modeles-builder/blocs-disponibles.md) — découvrez tous les types de blocs et leurs options de configuration.
- [Images](https://pdfmonkey.io/fr/docs/modeles-builder/images.md) — approfondissez les images statiques, uploadées et dynamiques.
- [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md) — rendez le contenu conditionnel ou répétez-le pour chaque élément d’une collection.
- [Données de test](https://pdfmonkey.io/fr/docs/modeles-builder/donnees-de-test.md) — techniques avancées pour les données de test et le navigateur de variables.


---

# Blocs disponibles

Source: https://pdfmonkey.io/fr/docs/modeles-builder/blocs-disponibles.md
Le builder fournit des blocs que vous glissez sur le canevas pour construire votre modèle. Les blocs sont organisés en trois catégories : **Layout** pour les éléments structurels, **Content** pour le texte, les images et les données, et **Extra** pour les composants spécialisés.

![Le panneau Blocks montrant les catégories Layout, Content et Extra](https://pdfmonkey.io/fr/docs/img/blocks-panel-categories.webp)

## Layout

Les blocs Layout définissent la structure de votre modèle. Ils servent de conteneurs pour accueillir d’autres blocs.

### Page

Le bloc Page est l’élément racine de chaque modèle : il représente une page PDF. Lorsque vous créez un nouveau modèle, un bloc Page est ajouté automatiquement.

**Paramètres principaux :**
- **Paper format** (Format de papier) : A0, A1, A2, A3, A4, A5, A6, Letter et Custom.
- **Orientation** (portrait ou paysage).
- **Background color** (Couleur d’arrière-plan) : définissez un arrière-plan de page via le panneau Styles.
- **Padding** (Marges internes) : contrôlez l’espacement intérieur autour des bords de la page dans la section Spacing du panneau Styles.

La plupart des autres blocs peuvent être placés à l’intérieur d’une Page. Vous avez généralement un bloc Page par modèle, mais vous pouvez en ajouter pour des mises en page multi-pages.

### Container

Un Container est un élément de regroupement flexible. Voyez-le comme une `<div>` qui maintient d’autres blocs ensemble. Par défaut, un Container empile ses enfants verticalement (flex column).

**Paramètres principaux :**
- **Display** (Affichage) : block ou flex. Flex permet des capacités de mise en page avancées comme la direction, l’alignement et le contrôle de l’espacement.
- **Layout direction** (Direction de disposition) : vertical (colonne), horizontal (rangée) ou grille. Configurez dans la section Layout du panneau Styles.
- **Gap** (Espacement) : espace entre les éléments enfants.
- **Alignment** (Alignement) : contrôlez comment les enfants sont positionnés dans le conteneur (début, centre, fin, étirer, espace entre).

> [!TIP]
> Utilisez les Containers pour regrouper du contenu lié. Par exemple, encapsulez un titre et un paragraphe dans un Container, puis utilisez le panneau Logic pour afficher ou masquer l’ensemble du groupe selon une condition.


## Content

Les blocs Content affichent les informations réelles de votre modèle : texte, titres, images, HTML brut et tableaux.

### Text

Le bloc Text contient du texte enrichi. Sélectionnez-le et cliquez sur **Edit Text Content** dans le panneau Settings pour ouvrir l’éditeur de texte enrichi.

**Options de mise en forme :**
- Gras, italique, soulignement, barré
- Listes à puces et listes numérotées
- Liens
- Taille de police, couleur et alignement (via le panneau Styles)

Les blocs Text n’acceptent pas de blocs enfants.

### Heading

Le bloc Heading affiche un élément de titre (h1 à h6). Il fonctionne comme le bloc Text mais est stylé comme un titre par défaut.

**Paramètres principaux :**
- **Heading level** (Niveau de titre) : sélectionnez h1, h2, h3, h4, h5 ou h6 dans le panneau Settings.
- **Edit Heading Content** : ouvre le même éditeur de texte enrichi que le bloc Text.

Utilisez les niveaux de titre pour créer une hiérarchie visuelle dans votre document, pas uniquement pour la taille de police. Les lecteurs d’écran et les outils d’accessibilité s’appuient sur la structure des titres.

### Image

Le bloc Image affiche une image dans votre modèle. Vous configurez sa source dans le panneau Settings.

**Options de source :**
- **Static URL** (URL statique) : collez un lien direct vers une image.
- **Upload** : sélectionnez un fichier depuis votre ordinateur. Il est converti en URI de données et intégré dans le modèle.
- **Dynamic binding** (Liaison dynamique) : liez la source à un champ de vos données de test (par exemple, `user.avatar`) afin que chaque document généré puisse afficher une image différente.

Pour plus de détails, consultez [Images](https://pdfmonkey.io/fr/docs/modeles-builder/images.md).

### HTML

Le bloc HTML vous permet d’insérer du contenu HTML brut à l’aide d’un éditeur de code. C’est utile lorsque vous avez besoin de balisage que les blocs visuels ne peuvent pas produire, comme des SVG personnalisés ou des mises en page de tableaux complexes.

Cliquez sur **Edit HTML Content** dans le panneau Settings pour ouvrir l’éditeur de code et écrire votre balisage.

> [!CAUTION]
> **Les scripts ne s’exécutent pas dans l’éditeur par défaut**
>
> Les balises `&lt;script&gt;` dans les blocs HTML ne s’exécutent que lors de la génération PDF, pas dans l’aperçu de l’éditeur. Si votre bloc HTML repose sur du JavaScript pour afficher son contenu, activez le bouton **Run scripts in editor** dans le panneau Settings, sinon le bloc apparaîtra vide dans l’aperçu.


#### Mise en forme

Les blocs HTML contournent le système de styles visuels du builder. Le contenu d’un bloc HTML doit être stylé directement avec des styles en ligne, du [CSS personnalisé](https://pdfmonkey.io/fr/docs/modeles-builder/css-personnalise.md) ou des classes utilitaires Tailwind — Tailwind est chargé globalement et disponible dans l’ensemble du template, y compris dans les blocs HTML.

### Table

Le bloc Table crée un tableau de données avec une structure auto-générée. Lorsque vous en ajoutez un, le builder crée toute la hiérarchie : `thead`, `tbody`, rangées, cellules d’en-tête et cellules de données, pour que vous commenciez avec un tableau prêt à l’emploi. Gérez les rangées et colonnes dans le panneau Settings, stylisez les cellules individuelles dans le panneau Styles, et utilisez le paramètre de répétition pour générer des rangées dynamiquement à partir de vos données.

Pour plus de détails, consultez [Tableaux](https://pdfmonkey.io/fr/docs/modeles-builder/tableaux.md).

## Extra

La catégorie Extra contient des blocs spécialisés pour des cas d’utilisation spécifiques.

### QR Code

Le bloc QR Code génère une image de QR code directement dans votre modèle.

**Paramètres principaux :**
- **Content** (Contenu) : les données encodées dans le QR code. Peut être une valeur statique (comme une URL) ou liée à une variable de données.
- **Size** (Taille) : la largeur et la hauteur du QR code en pixels.
- **Foreground/background colors** (Couleurs premier plan/arrière-plan) : personnalisez les couleurs des points du QR code et de l’arrière-plan.
- **Reliability level** (Niveau de fiabilité) : niveau de correction d’erreur (L, M, Q ou H). Les niveaux supérieurs rendent le QR code plus résistant aux dommages mais augmentent sa densité.
- **Dot style** (Style de point) : square, dots, rounded, extra-rounded, classy ou classy-rounded.
- **Corner style** (Style de coin) : square, dot ou extra-rounded.
- **Logo** : une image optionnelle placée au centre du QR code. Peut être une URL statique ou une valeur liée aux données.

Pour plus de détails, consultez [QR Codes](https://pdfmonkey.io/fr/docs/modeles-builder/codes-qr.md).

## Paramètres communs à tous les blocs

Chaque bloc partage quelques paramètres disponibles dans le panneau Settings :

- **Élément info :** affiche le type de bloc et la balise HTML qu’il utilise pour le rendu.
- **Panneau Logic :** configurez l’affichage conditionnel ou la répétition pour n’importe quel bloc sauf l’élément Document racine. Consultez [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md) pour plus de détails.

Le panneau Styles est également disponible pour chaque bloc, vous donnant le contrôle sur la disposition, les espacements, la typographie, les bordures, les arrière-plans et le positionnement. Pour des techniques de style avancées, consultez [CSS personnalisée](https://pdfmonkey.io/fr/docs/modeles-builder/css-personnalise.md) et [Styles situationnels](https://pdfmonkey.io/fr/docs/modeles-builder/style-conditionnel.md).

## Prochaines étapes

- Suivez le tutoriel [Votre premier modèle](https://pdfmonkey.io/fr/docs/modeles-builder/votre-premier-modele.md) pour construire un modèle complet à partir de zéro.
- Découvrez les [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md) pour rendre vos modèles dynamiques.
- Explorez la [CSS personnalisée](https://pdfmonkey.io/fr/docs/modeles-builder/css-personnalise.md) et le [JS personnalisé](https://pdfmonkey.io/fr/docs/modeles-builder/js-personnalise.md) pour une personnalisation avancée.


## FAQ

**Quels types de blocs sont disponibles dans le builder visuel PDFMonkey ?**

Le builder propose des blocs répartis en trois catégories : Layout (Page et Container), Content (Text, Heading, Image, HTML et Table) et Extra (QR Code). Chaque bloc peut être glissé sur le canevas et configuré via les panneaux Settings et Styles.

**Qu'est-ce qu'un bloc Container dans PDFMonkey ?**

Un Container est un élément de regroupement flexible qui contient d’autres blocs. Il prend en charge l’affichage block ou flex, les directions de disposition verticale/horizontale/grille, l’espacement (gap) et les contrôles d’alignement. Utilisez les Containers pour regrouper du contenu lié et appliquer une logique comme la visibilité conditionnelle ou la répétition.

**Peut-on écrire du HTML brut dans un modèle builder PDFMonkey ?**

Oui. Le bloc HTML vous permet d’insérer du HTML brut via un éditeur de code. C’est utile pour les SVG personnalisés, les mises en page complexes ou le balisage que les blocs visuels ne peuvent pas produire. Stylisez le contenu avec des styles en ligne, la CSS personnalisée ou les classes utilitaires Tailwind.


---

# Images pour les modèles builder

Source: https://pdfmonkey.io/fr/docs/modeles-builder/images.md

Les images sont parmi les éléments les plus courants dans les modèles PDF : logos, photos de produits, avatars, graphiques. Le builder vous offre trois façons de définir une source d’image : coller une URL, uploader un fichier, ou lier la source à une variable de vos données de document.

## Ajouter un bloc Image

Ouvrez le panneau **Blocks** sur le côté gauche du builder et cherchez dans la catégorie **Content**. Faites glisser un bloc **Image** sur le canevas ou cliquez dessus pour l’ajouter à l’intérieur du conteneur actuellement sélectionné.

![Le bloc Image sélectionné dans la liste des blocs](https://pdfmonkey.io/fr/docs/img/adding-an-image-block.webp)

Lorsque vous sélectionnez le bloc Image, le panneau droit bascule vers l’onglet **Settings** où vous trouverez la section **Image Settings** avec un champ de saisie d’URL.

## Définir la source de l’image

La section Image Settings affiche un champ de saisie d’URL avec deux boutons à droite : un bouton **navigateur de variables** (icône accolades) et un bouton **upload** (icône upload).

![Le panneau Image Settings montrant le champ URL avec les boutons navigateur de variables et upload](https://pdfmonkey.io/fr/docs/img/image-settings-panel.webp)

### URL statique

Saisissez ou collez une URL complète (commençant par `https://`) directement dans le champ de saisie et appuyez sur Entrée ou cliquez ailleurs. L’image se charge immédiatement dans l’aperçu du canevas.

```text
https://example.com/logo.png
```

> [!WARNING]
> **Comptes payants uniquement**
>
> Inclure des images via leur URL n’est possible que sur un compte payant ou pendant la [période d’essai](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md). Les documents contenant des images externes échoueront sur un compte gratuit. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) pour la liste complète.


### Uploader un fichier

Cliquez sur le **bouton upload** (icône upload) pour ouvrir un sélecteur de fichiers. Sélectionnez un fichier image depuis votre ordinateur. Le builder le convertit en URI de données et l’intègre directement dans le modèle.

> [!WARNING]
> **Attention à la taille des fichiers**
>
> Les images uploadées sont intégrées en tant qu’URI de données dans le modèle. Les images volumineuses :
&gt; 
&gt; - augmentent la taille du modèle,
&gt; - ralentissent la génération PDF,
&gt; - rendent la sauvegarde du modèle sensiblement plus lente puisque l’intégralité du contenu est envoyée à chaque fois.
&gt; 
&gt; Gardez les images uploadées sous 200 Ko dans la mesure du possible. Pour les images plus grandes, hébergez-les sur un serveur et utilisez une URL statique à la place.


Après l’upload, le champ de saisie est remplacé par un aperçu miniature de l’image avec des boutons pour la remplacer ou la supprimer.

### Liaison dynamique

Cliquez sur le bouton **navigateur de variables** (icône accolades) pour ouvrir une liste déroulante affichant tous les chemins de données disponibles depuis vos données de test. Sélectionnez un chemin qui contient une URL d’image (par exemple, `company.logo` ou `user.avatar_url`).

![La liste déroulante du navigateur de variables montrant les chemins de données disponibles](https://pdfmonkey.io/fr/docs/img/image-variable-browser.webp)

Vous pouvez également saisir un chemin de variable directement dans le champ. Le builder détecte automatiquement qu’une valeur comme `company.logo` est une liaison de données (pas une URL) et la traite en conséquence.

> [!TIP]
> Le navigateur de variables n’affiche que les chemins qui existent dans vos données de test actuelles. Si vous ne voyez pas le chemin dont vous avez besoin, ouvrez l’éditeur de données de test et ajoutez le champ correspondant avec un exemple d’URL d’image.


## Images d’arrière-plan

N’importe quel élément dans le builder (pas seulement les blocs Image) peut avoir une image d’arrière-plan. Sélectionnez un élément, basculez vers l’onglet **Styles** dans le panneau droit et développez la section **Background** (Arrière-plan).

La section Background inclut :

| Paramètre | Ce qu’il contrôle |
|---|---|
| Background Color | Couleur unie derrière l’élément |
| Background Image | Une URL d’image ou une liaison de données pour l’arrière-plan |
| Background Repeat | Si l’image se répète en mosaïque (`repeat`, `no-repeat`, etc.) |
| Background Size | Comment l’image s’adapte (`cover`, `contain`, ou une taille spécifique) |
| Background Position | Où l’image s’ancre (`center`, `top left`, etc.) |

Utilisez les images d’arrière-plan lorsque vous avez besoin d’une image derrière d’autres contenus (par exemple, un filigrane, un en-tête décoratif ou un motif d’arrière-plan pleine page).

## Conseils pour travailler avec les images

- **Gardez des tailles de fichier raisonnables.** Les images volumineuses ralentissent la génération PDF. Redimensionnez et compressez les images avant de les utiliser.
- **Utilisez des URL pour les images qui changent.** Si l’image diffère par document (un logo client, une photo de produit), utilisez une liaison dynamique pour que chaque PDF généré récupère la bonne image depuis vos données.
- **Utilisez les uploads pour les images fixes.** Si l’image est toujours identique d’un document à l’autre (le logo de votre entreprise à une taille fixe), l’upload simplifie les choses et évite les dépendances externes.
- **Vérifiez le CORS pour les URL externes.** Les images chargées depuis des serveurs externes doivent autoriser les requêtes cross-origin. Si une image ne s’affiche pas dans le PDF généré, vérifiez si le serveur d’hébergement supporte le CORS.


## FAQ

**Comment ajouter une image à un modèle builder PDFMonkey ?**

Glissez un bloc Image depuis le panneau Blocks sur le canevas. Dans l’onglet Settings, vous pouvez coller une URL statique, uploader un fichier depuis votre ordinateur, ou lier la source à une variable de vos données de document pour des images dynamiques.

**Peut-on utiliser des images dynamiques qui changent par document dans PDFMonkey ?**

Oui. Cliquez sur le bouton du navigateur de variables (icône accolades) dans le panneau Image Settings et sélectionnez un chemin de données comme company.logo ou user.avatar_url. Chaque document généré récupérera son image depuis les données du payload que vous fournissez.

**Quelle est la taille de fichier recommandée pour les images uploadées dans PDFMonkey ?**

Maintenez les images uploadées en dessous de 200 Ko. Les fichiers uploadés sont intégrés sous forme de data URI dans le modèle, les images volumineuses augmentent donc la taille du modèle et ralentissent à la fois la sauvegarde et la génération PDF. Pour les images plus lourdes, hébergez-les sur un serveur et utilisez une URL à la place.

**Comment ajouter une image d'arrière-plan à un élément dans le builder PDFMonkey ?**

Sélectionnez n’importe quel élément, basculez vers l’onglet Styles et développez la section Background. Définissez une URL d’image d’arrière-plan ou une liaison de données, puis configurez les paramètres de repeat, size et position pour contrôler l’affichage de l’image derrière le contenu de l’élément.


---

# Tableaux

Source: https://pdfmonkey.io/fr/docs/modeles-builder/tableaux.md

Le bloc Table crée automatiquement un tableau HTML sémantique complet : lorsque vous en ajoutez un, le builder génère toute la structure pour que vous commenciez avec un tableau prêt à l’emploi.

## Structure du tableau

Lorsque vous ajoutez un bloc Table, le builder crée toute la hiérarchie : un élément `table` contenant `thead` et `tbody`, chacun avec des rangées (`tr`), des cellules d’en-tête (`th`) et des cellules de données (`td`). Ces sous-éléments n’apparaissent pas dans le panneau Blocks : ils ne sont visibles que dans l’arbre Elements lorsque vous développez le bloc Table.

![Un bloc Table montrant la structure auto-générée dans l’arbre Elements](https://pdfmonkey.io/fr/docs/img/table-block-structure.webp)

## Gérer les rangées et les colonnes

Utilisez le panneau **Settings** pour ajouter ou supprimer des rangées (dans `thead` ou `tbody` séparément) et des colonnes (ce qui affecte toutes les rangées en même temps).

Sélectionnez des cellules `th` ou `td` individuelles dans l’arbre Elements et modifiez leur contenu textuel comme un bloc Text classique.

## Modes de bordure

Le bloc Table prend en charge deux modes de rendu des bordures :

- **Border-collapse** : les bordures des cellules adjacentes fusionnent en une seule bordure partagée.
- **Border-separate** : chaque cellule conserve sa propre bordure indépendante, et vous pouvez contrôler l’espacement entre elles.

Basculez entre les deux dans le panneau **Styles**.

## Styliser les cellules

Sélectionnez n’importe quelle cellule (`th` ou `td`) dans l’arbre Elements, puis passez au panneau **Styles** pour ajuster le padding, la couleur d’arrière-plan, l’alignement du texte, les bordures et la typographie.

> [!TIP]
> Utilisez la fonctionnalité de copier/coller de styles (menu contextuel par clic droit ou raccourcis clavier) pour appliquer le même style à plusieurs cellules rapidement. Cela fait gagner beaucoup de temps lorsque vous avez besoin d’un formatage cohérent sur une rangée ou colonne entière.


## Rangées dynamiques

Vous pouvez générer des rangées de tableau à partir de vos données grâce au paramètre de répétition. Sélectionnez l’élément `tr` à l’intérieur de `tbody`, ouvrez le panneau Logic et configurez la répétition pour itérer sur une collection de vos données.

Par exemple, si vos données contiennent un tableau `items`, configurez la répétition pour boucler sur `items`. Chaque cellule de cette rangée peut alors référencer `item.name`, `item.quantity`, `item.price`, etc.

Consultez [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md) pour tous les détails sur les liaisons de répétition.

## Style pair/impair des rangées

Pour des tableaux à bandes alternées (zebra-striping), utilisez les styles situationnels pour appliquer des arrière-plans différents aux rangées paires et impaires. Cela rend les grands tableaux plus faciles à parcourir.

Consultez [Styles situationnels](https://pdfmonkey.io/fr/docs/modeles-builder/style-conditionnel.md) pour les instructions de configuration.


## FAQ

**Comment ajouter un tableau à un modèle builder PDFMonkey ?**

Glissez un bloc Table depuis le panneau Blocks sur le canevas. Le builder crée automatiquement toute la structure — thead, tbody, rangées, cellules d’en-tête et cellules de données — pour que vous commenciez avec un tableau prêt à l’emploi.

**Comment générer des rangées de tableau dynamiques à partir de données dans PDFMonkey ?**

Sélectionnez l’élément tr à l’intérieur de tbody, ouvrez le panneau Logic et configurez la Repetition pour itérer sur une collection de vos données. Chaque cellule de cette rangée peut ensuite référencer les propriétés de l’élément comme item.name ou item.price.

**Peut-on styliser des cellules de tableau individuelles dans le builder PDFMonkey ?**

Oui. Sélectionnez n’importe quelle cellule th ou td dans l’arbre Elements, puis utilisez le panneau Styles pour ajuster le padding, la couleur d’arrière-plan, l’alignement du texte, les bordures et la typographie. Vous pouvez aussi copier-coller les styles entre cellules.


---

# Conditions et boucles pour les modèles builder

Source: https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md

Le panneau Logic du builder vous permet de contrôler quand les éléments apparaissent et comment ils se répètent. Vous pouvez rendre n’importe quel élément conditionnel (visible uniquement quand une condition sur les données est remplie), ou le répéter une fois pour chaque élément d’une collection. Ces deux fonctionnalités couvrent les schémas de contenu dynamique les plus courants : afficher ou masquer des sections selon le contexte, et générer des rangées à partir d’une liste d’éléments.

## Le panneau Logic

Sélectionnez n’importe quel élément sur le canevas (sauf la racine du document), puis basculez vers l’onglet **Settings** dans le panneau droit. La section **Logic** apparaît sous la section Élément Info, avec deux boutons bascule : **Visibility Condition** (Condition de visibilité) et **Répétition**.

Un petit point indigo apparaît à côté du titre « Logic » lorsque l’une ou l’autre des fonctionnalités est active sur l’élément sélectionné.

## Conditions de visibilité

Activez **Visibility Condition** pour qu’un élément n’apparaisse que lorsqu’une condition est vraie. Un champ de saisie apparaît dans lequel vous entrez une expression JavaScript évaluée par rapport aux données de test de votre document.

![Le panneau Logic avec une condition de visibilité active, montrant le statut vert « visible »](https://pdfmonkey.io/fr/docs/img/logic-panel-visibility-condition.webp)

### Écrire des conditions

La condition est une expression JavaScript qui a accès à vos données de test. Quelques exemples :

| Condition | Ce qu’elle fait |
|---|---|
| `customer.isPremium` | Affiche l’élément quand le client est premium |
| `items.length > 0` | Affiche l’élément quand le tableau items n’est pas vide |
| `order.status === 'paid'` | Affiche l’élément quand le statut de la commande est « paid » |
| `total >= 1000` | Affiche l’élément quand le total est de 1 000 ou plus |

### Évaluation en temps réel

Le panneau Logic évalue votre condition par rapport aux données de test actuelles en temps réel et affiche le résultat :

- **Vert (« Element is currently visible »)** : la condition s’évalue à une valeur truthy avec vos données de test actuelles, donc l’élément apparaît dans l’aperçu.
- **Rouge (« Element is currently hidden »)** : la condition s’évalue à une valeur falsy, donc l’élément est masqué dans l’aperçu.

![Le panneau Logic montrant le statut rouge « hidden » quand la condition s’évalue à false](https://pdfmonkey.io/fr/docs/img/logic-panel-hidden-status.webp)

Si la condition contient une erreur de syntaxe, un bandeau d’erreur rouge apparaît en bas du builder.

Un lien vers **Edit test data** apparaît sous l’indicateur de statut, vous permettant d’ajuster rapidement vos données de test pour essayer différents scénarios.

## Répétition

Activez **Répétition** pour répéter un élément une fois pour chaque item d’une collection de vos données de test. Deux champs de saisie apparaissent :

- **Collection :** le chemin vers un tableau dans vos données de test (par exemple, `invoice.products` ou `users`)
- **Item name** (Nom de l’item) : le nom de variable pour l’item courant dans la boucle (auto-suggéré en mettant au singulier le nom de la collection)

![Le panneau Logic avec la Répétition active, montrant les champs collection et item avec les variables disponibles](https://pdfmonkey.io/fr/docs/img/logic-panel-repetition.webp)

### Comment ça fonctionne

Lorsque vous entrez un chemin de collection comme `lineItems`, le builder suggère automatiquement un nom d’item `lineItem` (la forme singulière). Vous pouvez le changer pour n’importe quel nom de votre choix.

Le panneau affiche ensuite un résumé de ce que fait la boucle et liste les variables disponibles :

| Variable | Description |
|---|---|
| La variable d’item (ex. `lineItem`) | L’item courant de la collection |
| La variable d’index (ex. `lineItemIndex`) | La position à base zéro de l’item courant |

Le panneau montre également des expressions d’aide que vous pouvez copier pour des vérifications courantes :

- **Vérification du premier item :** `lineItemIndex === 0`
- **Vérification du dernier item :** `lineItemIndex === lineItems.length - 1`

### Utiliser les variables de boucle dans les éléments enfants

Les éléments enfants d’un élément répété peuvent référencer les variables d’item et d’index. Par exemple, si vous répétez un conteneur sur `lineItems` avec le nom d’item `lineItem`, un bloc Text à l’intérieur de ce conteneur peut afficher `lineItem.name` ou `lineItem.price` en utilisant le navigateur de variables.

## Visibilité et répétition sont mutuellement exclusives

Vous ne pouvez pas activer à la fois Visibility Condition et Répétition sur le même élément. Le builder impose cette règle : quand un bouton bascule est actif, l’autre est désactivé. Combiner les deux sur un même élément HTML produirait un comportement ambigu.

> [!TIP]
> **Solution :**
>
> Si vous avez besoin de répéter des éléments et aussi d’en afficher certains conditionnellement, imbriquez deux éléments. Placez un Container avec la **Répétition** activée, et à l’intérieur, placez un élément enfant avec une **Visibility Condition**. Le conteneur se répète pour chaque item, et l’enfant à l’intérieur apparaît ou se masque selon la condition.


## Combiner avec les styles situationnels

Les éléments répétés fonctionnent bien avec les [styles situationnels](https://pdfmonkey.io/fr/docs/modeles-builder/style-conditionnel.md). Une fois qu’un élément se répète sur une collection, vous pouvez appliquer des styles différents pour les items pairs et impairs, mettre en évidence le premier ou le dernier item, ou afficher un contenu de remplacement quand la collection est vide. Consultez la page [Styles situationnels](https://pdfmonkey.io/fr/docs/modeles-builder/style-conditionnel.md) pour plus de détails.


## FAQ

**Comment afficher ou masquer un élément de façon conditionnelle dans le builder PDFMonkey ?**

Sélectionnez l’élément, ouvrez l’onglet Settings, puis activez Visibility Condition dans la section Logic. Saisissez une expression JavaScript évaluée par rapport aux données de votre document — par exemple, « customer.isPremium » ou « items.length > 0 ». L’élément n’apparaît que lorsque la condition est vraie.

**Comment boucler sur une liste d'éléments dans un modèle builder PDFMonkey ?**

Sélectionnez l’élément que vous souhaitez répéter, ouvrez le panneau Logic et activez Repetition. Saisissez le chemin vers un tableau dans vos données (par ex. « invoice.products ») comme Collection et choisissez un nom d’élément (Item name). Le builder répète l’élément une fois pour chaque entrée du tableau.

**Peut-on utiliser à la fois les conditions de visibilité et la répétition sur le même élément ?**

Non. Le builder n’autorise qu’une seule option à la fois sur un même élément. Pour répéter des éléments et en afficher certains de façon conditionnelle, imbriquez un enfant avec une Visibility Condition à l’intérieur d’un Container parent sur lequel la Repetition est activée.


---

# Styles situationnels

Source: https://pdfmonkey.io/fr/docs/modeles-builder/style-conditionnel.md

Les styles situationnels vous permettent de modifier l’apparence d’un élément en fonction de sa position parmi ses éléments frères. Vous pouvez définir des couleurs d’arrière-plan différentes pour les enfants pairs et impairs, mettre en évidence le premier ou le dernier élément, ou afficher un message de remplacement quand une collection est vide (le tout sans écrire une seule ligne de code).

## Le sélecteur de situation

Chaque élément dispose d’un menu déroulant **Situation** en haut du panneau **Styles**. Par défaut, il est réglé sur « Default », ce qui signifie que les styles définis s’appliquent dans tous les contextes.

![Le menu déroulant Situation dans le panneau Styles affichant les six options](https://pdfmonkey.io/fr/docs/img/situation-selector-dropdown.webp)

Cliquez sur le menu déroulant pour choisir une situation différente. Les styles que vous définissez lorsqu’une situation autre que Default est sélectionnée ne s’appliquent que lorsque la condition correspondante est remplie.

## Situations disponibles

Le builder propose six situations :

| Situation | Quand les styles s’appliquent |
|---|---|
| **Default** | Toujours (ce sont les styles de base de l’élément) |
| **When odd** | Lorsque l’élément est à une position impaire (1er, 3e, 5e...) parmi ses frères |
| **When even** | Lorsque l’élément est à une position paire (2e, 4e, 6e...) parmi ses frères |
| **When first** | Uniquement pour le premier enfant parmi ses frères |
| **When last** | Uniquement pour le dernier enfant parmi ses frères |
| **When empty** | Lorsque l’élément n’a aucun enfant visible |

## Définir des styles situationnels

1. Sélectionnez un élément sur le canevas.
2. Ouvrez l’onglet **Styles** dans le panneau de droite.
3. Choisissez une situation dans le menu déroulant **Situation** (par exemple, « When even »).
4. Définissez les styles souhaités pour cette situation (couleur d’arrière-plan, couleur du texte, bordures, ou toute autre propriété de style).
5. Revenez à « Default » pour continuer à éditer les styles de base.

Les styles définis sous une situation autre que Default agissent comme des surcharges. Ils remplacent les styles par défaut correspondants uniquement lorsque la condition est remplie. Les propriétés non définies dans un contexte situationnel conservent leurs valeurs par défaut.

## L’indicateur de surcharge

Lorsqu’un élément a des styles définis pour une situation autre que Default, un petit **point indigo** apparaît à côté du menu déroulant Situation. Cet indicateur visuel vous aide à repérer les éléments disposant de surcharges situationnelles sans avoir à parcourir chaque situation manuellement.

En survolant le point, une infobulle indique quelles situations ont des surcharges définies.

![Survol de l’indicateur de surcharge pour afficher les situations avec des surcharges](https://pdfmonkey.io/fr/docs/img/situation-selector-hover.webp)

## Cas d’utilisation courants

### Alternance de couleurs de lignes

L’utilisation la plus courante des styles situationnels est l’alternance de couleurs (effet zèbre) dans une liste répétée :

1. Créez un conteneur et activez la [Répétition](https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md) dessus (par exemple, sur `invoice.items`).
2. Définissez l’arrière-plan **Default** sur blanc.
3. Passez à **When even** et définissez l’arrière-plan sur un gris clair.

Chaque ligne générée alterne automatiquement entre blanc et gris.

### Mise en évidence du dernier élément

Pour ajouter une bordure inférieure uniquement au dernier élément d’une liste :

1. Sélectionnez l’élément répété.
2. Passez à **When last**.
3. Ajoutez une bordure inférieure.

### Contenu de remplacement pour collection vide

Pour afficher un message quand une collection ne contient aucun élément :

1. Créez un conteneur avec la Répétition activée sur la collection.
2. À l’intérieur, ajoutez le contenu qui doit se répéter.
3. Sélectionnez le conteneur répété lui-même.
4. Passez à **When empty**.
5. Définissez des styles qui rendent le contenu d’état vide visible (par exemple, une hauteur minimale et un texte centré).

> [!TIP]
> « When empty » est particulièrement utile combiné avec un bloc Text enfant contenant un texte tel que « Aucun élément à afficher. » Le conteneur parent s’affiche avec les styles d’état vide, et le texte enfant fournit le message.


## Combinaison avec conditions et boucles

Les styles situationnels fonctionnent de pair avec les fonctionnalités [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-builder/conditions-et-boucles.md). Un schéma typique est :

1. Configurez la **Répétition** sur un conteneur pour boucler sur une collection de données.
2. Appliquez des **styles situationnels** sur l’élément répété ou ses enfants pour varier l’apparence.
3. Ajoutez éventuellement des **conditions de visibilité** sur les éléments enfants à l’intérieur de la boucle pour afficher ou masquer du contenu spécifique par élément.

Cette combinaison couvre la plupart des besoins de mise en page dynamique sans écrire de CSS personnalisée.


## FAQ

**Comment créer des rangées zébrées dans un modèle builder PDFMonkey ?**

Activez la Repetition sur un Container, définissez l’arrière-plan Default en blanc, puis basculez le menu déroulant Situation sur « When even » et définissez cet arrière-plan en gris clair. Chaque rangée répétée alterne automatiquement les couleurs.

**Quels styles situationnels sont disponibles dans le builder PDFMonkey ?**

Le builder propose six situations : Default (toujours), When odd, When even, When first, When last et When empty. Chacune permet de surcharger les styles en fonction de la position de l’élément parmi ses frères ou selon qu’il possède des enfants visibles.

**Comment afficher un message de remplacement quand une collection répétée est vide ?**

Sélectionnez le Container avec la Repetition activée, basculez le menu déroulant Situation sur « When empty » et définissez des styles rendant le contenu de l’état vide visible. Ajoutez un bloc Text enfant à l’intérieur avec votre message de remplacement, par exemple « Aucun élément à afficher ».


---

# QR Codes pour les modèles builder

Source: https://pdfmonkey.io/fr/docs/modeles-builder/codes-qr.md

Le builder inclut un bloc QR Code dédié pour intégrer des QR codes directement dans vos modèles. Vous pouvez encoder du texte statique ou des URL, lier le contenu à une variable de données dynamique, personnaliser les couleurs et les styles de points, et même ajouter un logo centré.

## Ajouter un bloc QR Code

Le QR Code se trouve dans la catégorie **Extra** du panneau Blocks. Faites-le glisser sur le canevas ou cliquez dessus pour l’ajouter à l’intérieur du conteneur actuellement sélectionné.

![Un bloc QR Code affiché sur le canevas](https://pdfmonkey.io/fr/docs/img/qr-code-block-canvas.webp)

Une fois ajouté, le QR code s’affiche immédiatement sur le canevas avec ses paramètres par défaut. Sélectionnez le bloc pour le configurer dans le panneau droit.

## Paramètres du QR Code

Sélectionnez un bloc QR Code et ouvrez l’onglet **Settings** dans le panneau droit pour accéder à toutes les options de configuration.

### Contenu

Le champ **Content** définit le texte ou l’URL encodé dans le QR code. Vous pouvez saisir une valeur statique (comme `https://example.com`) ou la lier à une variable de données de votre payload.

Pour utiliser du contenu dynamique, cliquez sur le bouton du navigateur de variables à côté du champ et sélectionnez une propriété de vos données de test (par exemple, `invoice.paymentUrl`). Le QR code se met à jour en temps réel lorsque vous modifiez les données de test.

### Taille

Le paramètre **Size** contrôle la largeur et la hauteur du QR code en pixels. Les deux dimensions sont toujours égales puisque les QR codes sont carrés.

### Couleurs

- **Foreground color** (Couleur de premier plan) : la couleur des points du QR code (par défaut : noir).
- **Background color** (Couleur d’arrière-plan) : la couleur derrière les points (par défaut : blanc).

Vous pouvez utiliser n’importe quelle valeur de couleur valide. Un contraste élevé entre le premier plan et l’arrière-plan est important pour la lisibilité.

> [!WARNING]
> Évitez les combinaisons de couleurs à faible contraste. La plupart des lecteurs QR s’attendent à des points sombres sur un fond clair. Inverser les couleurs (clair sur foncé) peut provoquer des échecs de lecture sur certains appareils.


### Niveau de fiabilité

Le niveau de fiabilité définit la capacité de **correction d’erreur** du QR code :

| Niveau | Nom | Capacité de récupération |
|-------|------|-------------------|
| **L** | Low | ~7 % |
| **M** | Medium | ~15 % |
| **Q** | Quartile | ~25 % |
| **H** | High | ~30 % |

Les niveaux supérieurs rendent le code plus résistant aux dommages ou à l’obstruction partielle, mais produisent des motifs plus denses (plus complexes). Si vous prévoyez d’ajouter un logo au centre du QR code, utilisez **Q** ou **H** pour que le code reste lisible même si le logo recouvre une partie.

### Style de point

Le style de point change la forme des modules individuels du QR code :

- **Square :** modules rectangulaires standard (par défaut)
- **Dots :** points circulaires
- **Rounded :** rectangles arrondis
- **Extra-rounded :** arrondi plus prononcé
- **Classy :** variante carrée stylisée
- **Classy-rounded :** stylisé avec coins arrondis

### Style de coin

Le style de coin affecte les trois grands carrés de positionnement aux coins du QR code :

- **Square :** coins carrés standard (par défaut)
- **Dot :** coins circulaires
- **Extra-rounded :** coins arrondis

Combiner les styles de points et de coins vous permet d’adapter le QR code à l’esthétique de votre marque tout en le gardant lisible.

### URL du logo

Le champ **Logo URL** vous permet de placer une image au centre du QR code. Entrez une URL directe vers une image PNG ou SVG, ou liez le champ à une variable de données pour des logos dynamiques.

> [!TIP]
> Lorsque vous utilisez un logo, définissez le niveau de fiabilité à **Q** ou **H**. Le logo recouvre physiquement des modules du QR, et une correction d’erreur plus élevée garantit que le code reste lisible malgré l’obstruction.


## QR codes dynamiques

Pour les documents générés avec des données différentes, liez les champs **Content** et **Logo URL** à des variables de votre payload. Chaque document généré produira un QR code unique basé sur ses données.

Par exemple, si votre payload contient :

```json
{
  "ticket": {
    "checkInUrl": "https://example.com/checkin/abc123",
    "eventLogo": "https://example.com/logos/event.png"
  }
}
```

Liez le champ Content à `ticket.checkInUrl` et le Logo URL à `ticket.eventLogo`. Chaque document reçoit un QR code lisible pointant vers sa propre URL d’enregistrement, avec le logo de l’événement.

![Un bloc QR Code avec des valeurs dynamiques liées aux variables du payload](https://pdfmonkey.io/fr/docs/img/qr-code-dynamic-values.webp)


## FAQ

**Comment ajouter un QR code à un modèle PDFMonkey ?**

Glissez un bloc QR Code depuis la catégorie Extra du panneau Blocks sur le canevas. Configurez le champ Content avec une URL statique ou liez-le à une variable de données. Vous pouvez aussi personnaliser la taille, les couleurs, le style des points, le style des coins et ajouter un logo centré.

**Peut-on générer des QR codes dynamiques dans PDFMonkey ?**

Oui. Liez les champs Content et Logo URL à des variables de votre payload de document. Chaque document généré produira un QR code unique basé sur ses données — par exemple, une URL d’enregistrement unique par billet d’événement.

**Quel niveau de correction d'erreur utiliser pour les QR codes avec un logo ?**

Utilisez le niveau Quartile (Q) ou High (H) lorsque vous ajoutez un logo. Le logo recouvre physiquement des modules du QR code, et un niveau de correction d’erreur plus élevé garantit que le code reste lisible malgré l’obstruction.


---

# CSS personnalisée pour les modèles builder

Source: https://pdfmonkey.io/fr/docs/modeles-builder/css-personnalise.md

Le panneau Styles du builder couvre les besoins de mise en forme courants : couleurs, espacement, typographie et disposition. Quand vous avez besoin de quelque chose que les contrôles visuels n’offrent pas, l’éditeur CSS et les ressources externes vous permettent d’aller plus loin.

## L’éditeur CSS

Cliquez sur le bouton **Custom CSS** dans la barre d’outils en haut du canevas pour ouvrir l’éditeur CSS global. Écrivez vos règles CSS et appuyez sur **Ctrl+Entrée** (ou **Cmd+Entrée** sur Mac) pour enregistrer.

![L’éditeur CSS avec des exemples de styles](https://pdfmonkey.io/fr/docs/img/css-editor-monaco.webp)

La CSS écrite ici s’applique globalement à l’ensemble du modèle. C’est particulièrement utile pour styliser les blocs HTML — qui ne disposent pas de contrôles visuels — et pour ajouter des effets que le panneau Styles ne prend pas en charge.

```css
/* Styliser le contenu d'un bloc HTML */
.product-card {
  border: 1px solid #e5e7eb;
  border-radius: 8px;
  padding: 16px;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
}

/* Ajouter un soulignement décoratif aux titres */
h2 {
  border-bottom: 2px solid #db2777;
  padding-bottom: 8px;
}
```

> [!TIP]
> Le builder génère des classes utilitaires Tailwind CSS pour ses styles visuels. Vos règles CSS personnalisées prennent effet aux côtés des utilitaires Tailwind. Si vous devez remplacer un style généré par Tailwind, augmentez la spécificité de votre sélecteur ou utilisez `!important` en dernier recours.


## Styles arbitraires

Le panneau Styles comporte une section **Custom** en bas. Elle permet d’appliquer de la CSS arbitraire à des éléments individuels sans écrire de règles globales.

![La section Custom en bas du panneau Styles](https://pdfmonkey.io/fr/docs/img/custom-style-panel.webp)

Les styles arbitraires utilisent la syntaxe entre crochets de Tailwind : `[property:value]`. Par exemple, ajouter `[outline:2px_solid_purple]` et `[outline-offset:10px]` trace un contour violet autour de cet élément spécifique.

C’est utile pour des ajustements ponctuels — un `mix-blend-mode` spécifique, un `filter`, ou n’importe quelle propriété CSS que les contrôles visuels n’exposent pas.

## Polices web personnalisées

La section **Text** du panneau Styles inclut un sélecteur de famille de police avec accès à Google Fonts. Pour les polices provenant d’autres fournisseurs, utilisez `@font-face` ou `@import` dans l’éditeur CSS :

```css
/* Police auto-hébergée ou tierce */
@font-face {
  font-family: 'Brand Sans';
  src: url('https://your-cdn.example.com/fonts/brand-sans.woff2') format('woff2');
  font-weight: 400;
  font-style: normal;
}

.brand-heading {
  font-family: 'Brand Sans', sans-serif;
}
```

> [!NOTE]
> Le chargement des polices web ajoute un peu de temps à la génération des documents. Limitez-vous à une ou deux familles de polices quand c’est possible pour garder un rendu rapide.


## Feuilles de styles externes

Pour les bibliothèques ou frameworks CSS, utilisez le gestionnaire **External Assets** (Ressources externes). Cliquez sur le bouton **External Assets** dans la barre d’outils, puis ajoutez l’URL CDN de la feuille de styles que vous souhaitez inclure.

![L’éditeur External Assets avec une URL CDN CSS](https://pdfmonkey.io/fr/docs/img/external-assets-css.webp)

Les feuilles de styles externes sont chargées avant le rendu du modèle, donc toutes leurs classes et styles sont disponibles immédiatement. Les utilisations courantes incluent :

- **Bibliothèques d’icônes** — Font Awesome, Material Icons, Bootstrap Icons
- **Outils spécialisés** — feuilles de styles dédiées à l’impression, bibliothèques de graphiques CSS

> [!WARNING]
> Les ressources externes nécessitent une connexion internet active pendant la génération des documents. Assurez-vous que vos URL CDN sont fiables et accessibles publiquement. Si une URL est injoignable, les styles ne s’appliqueront pas.


## Différence avec les modèles Code

Dans les [modèles Code](https://pdfmonkey.io/fr/docs/modeles-code/css-personnalise.md), vous écrivez la CSS dans un onglet CSS dédié. Le builder sépare les responsabilités différemment : les styles globaux vont dans l’éditeur CSS, les styles arbitraires par élément passent par la section Custom du panneau Styles, et les bibliothèques externes passent par le gestionnaire External Assets.

## Pages associées

- [JS personnalisé](https://pdfmonkey.io/fr/docs/modeles-builder/js-personnalise.md) — JavaScript global, scripts en ligne dans les blocs HTML et bibliothèques JS externes


## FAQ

**Comment ajouter de la CSS personnalisée à un modèle builder PDFMonkey ?**

Cliquez sur le bouton Custom CSS dans la barre d’outils du builder pour ouvrir l’éditeur CSS global. Écrivez vos règles et appuyez sur Ctrl+Entrée (Cmd+Entrée sur Mac) pour enregistrer. La CSS s’applique globalement à l’ensemble du modèle, y compris à l’intérieur des blocs HTML.

**Peut-on utiliser des polices web personnalisées dans les modèles builder PDFMonkey ?**

Oui. Le panneau Styles inclut un sélecteur Google Fonts. Pour les polices d’autres fournisseurs, utilisez des règles @font-face ou @import dans l’éditeur CSS avec une URL pointant vers vos fichiers de polices hébergés.

**Comment ajouter des bibliothèques CSS externes à un modèle PDFMonkey ?**

Utilisez le gestionnaire External Assets dans la barre d’outils du builder et ajoutez l’URL CDN de la feuille de styles. Les feuilles de styles externes se chargent avant le rendu du modèle, toutes leurs classes sont donc immédiatement disponibles. Les utilisations courantes incluent les bibliothèques d’icônes comme Font Awesome.

**Comment appliquer de la CSS arbitraire à un seul élément dans le builder PDFMonkey ?**

Sélectionnez l’élément, ouvrez l’onglet Styles et descendez jusqu’à la section Custom en bas. Saisissez des valeurs en utilisant la syntaxe à crochets de Tailwind, comme [outline:2px_solid_purple], pour appliquer des propriétés CSS ponctuelles que les contrôles visuels n’exposent pas.


---

# JS personnalisé

Source: https://pdfmonkey.io/fr/docs/modeles-builder/js-personnalise.md

Le builder vous permet d’ajouter du JavaScript global à votre modèle pour une logique personnalisée, des calculs ou l’intégration de bibliothèques tierces. Vous pouvez également exécuter des scripts en ligne dans des blocs HTML individuels et charger des bibliothèques JS externes depuis des URL CDN.

## L’éditeur JavaScript

Cliquez sur le bouton **Custom JS** dans la barre d’outils en haut du canevas pour ouvrir l’éditeur JavaScript global. Écrivez votre code et appuyez sur **Ctrl+Entrée** (ou **Cmd+Entrée** sur Mac) pour enregistrer.

![L’éditeur JavaScript avec un exemple de code](https://pdfmonkey.io/fr/docs/img/js-editor-monaco.webp)

Le code dans l’éditeur Custom JS s’exécute dans le contexte du modèle lors du rendu du document. C’est ici que vous définissez les fonctions utilitaires, formatez les valeurs ou mettez en place toute logique dont votre modèle a besoin.

## Rendre les fonctions accessibles au modèle

Pour qu’une fonction ou une variable soit utilisable dans les liaisons de propriétés ou les blocs HTML, assignez-la à `window` :

```javascript
// Formater un montant en devise
window.formatCurrency = function (amount, currency) {
  return new Intl.NumberFormat('fr-FR', {
    style: 'currency',
    currency: currency || 'EUR',
  }).format(amount);
};

// Formater une date
window.formatDate = function (dateString) {
  return new Date(dateString).toLocaleDateString('fr-FR', {
    year: 'numeric',
    month: 'long',
    day: 'numeric',
  });
};
```

Une fois définies sur `window`, ces fonctions peuvent être appelées depuis les liaisons ailleurs dans le modèle (par exemple, en liant le contenu d’un bloc Text à `formatCurrency(invoice.total)`).

> [!TIP]
> Gardez votre Custom JS concentré sur les fonctions utilitaires et le formatage de données. Les calculs lourds ou la manipulation du DOM peuvent ralentir la génération des documents.


## Scripts dans les blocs HTML

Le bloc HTML dispose d’un bouton bascule dédié pour l’exécution des scripts en ligne. Sélectionnez un bloc HTML, ouvrez l’onglet **Settings** et activez **Run scripts in editor**.

![Le panneau Settings d’un bloc HTML montrant le bouton bascule Run scripts in editor](https://pdfmonkey.io/fr/docs/img/html-block-run-scripts.webp)

Lorsqu’il est activé, toutes les balises `<script>` à l’intérieur du contenu du bloc HTML s’exécutent lors du rendu. C’est utile pour une logique spécifique au bloc qui n’a pas sa place dans l’éditeur Custom JS global.

```html
<div id="chart-container"></div>
<script>
  // Ceci ne s'exécute que si "Run scripts in editor" est activé
  const ctx = document.getElementById('chart-container');
  // ... afficher un graphique ou exécuter une logique spécifique au bloc
</script>
```

> [!WARNING]
> Les scripts dans les blocs HTML s’exécutent indépendamment de l’éditeur Custom JS global. Si un script de bloc HTML dépend d’une fonction de l’éditeur global, assurez-vous que le script global l’assigne à `window` pour qu’elle soit accessible.


## Bibliothèques JavaScript externes

Pour les bibliothèques tierces, utilisez le gestionnaire **External Assets** (Ressources externes). Cliquez sur le bouton **External Assets** dans la barre d’outils, puis ajoutez l’URL CDN de la bibliothèque JavaScript que vous souhaitez inclure.

![L’éditeur External Assets avec une URL CDN JavaScript](https://pdfmonkey.io/fr/docs/img/external-assets-js.webp)

Les scripts externes sont chargés avant le rendu du modèle, donc leurs variables et fonctions globales sont disponibles aussi bien pour l’éditeur Custom JS que pour les scripts des blocs HTML.

Exemples courants :

| Bibliothèque | URL CDN | Cas d’utilisation |
|---------|---------|----------|
| Chart.js | `https://cdn.jsdelivr.net/npm/chart.js` | Graphiques et diagrammes |
| Day.js | `https://cdn.jsdelivr.net/npm/dayjs` | Formatage de dates |

> [!NOTE]
> Les ressources externes nécessitent une connexion internet pendant la génération des documents. Vérifiez que vos URL CDN sont accessibles publiquement et renvoient la version attendue de la bibliothèque.


## Différence avec les modèles Code

Dans les [modèles Code](https://pdfmonkey.io/fr/docs/modeles-code/javascript-personnalise.md), le JavaScript est intégré directement dans des balises `<script>` au sein du HTML. Le builder sépare le JavaScript en trois emplacements distincts :

- **Les scripts globaux** vont dans l’éditeur Custom JS (bouton de la barre d’outils) et s’exécutent pour l’ensemble du modèle
- **Les scripts spécifiques aux blocs** vont dans les blocs HTML avec le bouton bascule « Run scripts in editor » activé
- **Les bibliothèques externes** sont chargées via le gestionnaire External Assets

Cette séparation permet d’organiser la logique globale, le comportement par bloc et les dépendances tierces. Pour les fonctions de formatage globales, utilisez l’éditeur Custom JS. Pour le rendu spécifique à un bloc (comme les graphiques), utilisez un bloc HTML avec les scripts activés. Pour les bibliothèques, utilisez External Assets au lieu de balises `<script src="...">` manuelles.

## Pages associées

- [CSS personnalisée](https://pdfmonkey.io/fr/docs/modeles-builder/css-personnalise.md) — styles globaux, propriétés personnalisées par élément et bibliothèques CSS externes


## FAQ

**Comment ajouter du JavaScript personnalisé à un modèle builder PDFMonkey ?**

Cliquez sur le bouton Custom JS dans la barre d’outils du builder pour ouvrir l’éditeur JavaScript global. Écrivez votre code et appuyez sur Ctrl+Entrée (Cmd+Entrée sur Mac) pour enregistrer. Les fonctions assignées à window sont disponibles dans les liaisons et les blocs HTML du modèle.

**Peut-on utiliser des bibliothèques JavaScript externes dans les modèles PDFMonkey ?**

Oui. Cliquez sur le bouton External Assets dans la barre d’outils et ajoutez l’URL CDN de la bibliothèque que vous souhaitez inclure. Les scripts externes se chargent avant le rendu du modèle, leurs fonctions sont donc disponibles à la fois dans l’éditeur Custom JS et dans les scripts des blocs HTML.

**Comment exécuter des scripts en ligne dans un bloc HTML du builder PDFMonkey ?**

Sélectionnez le bloc HTML, ouvrez l’onglet Settings et activez le bouton bascule « Run scripts in editor ». Les balises script à l’intérieur de ce bloc s’exécuteront alors pendant le rendu. Sans cette option, les scripts ne s’exécutent que lors de la génération du PDF, pas dans l’aperçu de l’éditeur.


---

# Données de test

Source: https://pdfmonkey.io/fr/docs/modeles-builder/donnees-de-test.md

Les données de test vous permettent de prévisualiser le rendu de votre modèle avec des valeurs réelles avant de générer le moindre document. Vous saisissez un exemple JSON dans l’éditeur de payload, et le builder reflète immédiatement ces données sur le canevas (les blocs Text affichent votre contenu, les images se chargent depuis vos URL, et les boucles se répètent sur vos tableaux).

## Ouvrir l’éditeur de payload

Cliquez sur le bouton **Edit Test Data** dans la barre d’outils en haut du canevas. Cela ouvre une fenêtre contenant un éditeur JSON complet propulsé par Monaco (le même éditeur utilisé dans VS Code).

## Format JSON

Saisissez vos données de test sous forme d’objet JSON. Les clés de premier niveau deviennent les variables disponibles dans l’ensemble de votre modèle. Consultez les [règles de nommage](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour savoir quels formats de clés sont valides.

```json
{
  "name": "Marie Dupont",
  "company": "Acme Corp",
  "date": "2025-03-15",
  "items": [
    { "description": "Widget A", "quantity": 2, "price": 19.99 },
    { "description": "Widget B", "quantity": 1, "price": 49.99 }
  ],
  "logo_url": "https://example.com/logo.png"
}
```

> [!TIP]
> L’éditeur de payload supporte les commentaires JSON (commentaires en ligne `//` et commentaires en bloc `/* */`). Les commentaires sont supprimés lors de l’analyse, ils n’affectent donc jamais votre modèle. Utilisez-les pour noter quels champs sont requis ou quel format une valeur doit respecter :
&gt; 
&gt; ```json
&gt; {
&gt;   // Informations client
&gt;   &#34;name&#34;: &#34;Marie Dupont&#34;,
&gt;   &#34;email&#34;: &#34;marie@example.com&#34;,
&gt; 
&gt;   /* Tableau d&#39;articles - chaque article nécessite description, quantity et price */
&gt;   &#34;items&#34;: []
&gt; }
&gt; ```


### Données de test par défaut

Les nouveaux modèles sont fournis avec un payload par défaut contenant des champs courants comme `name`, `company`, `items`, `date` et `url`. Remplacez-les par des données correspondant à vos payloads de documents réels (les valeurs par défaut ne sont qu’un point de départ).

## Comment les données de test se connectent à votre modèle

Les données de test sont le pont entre la conception de votre modèle et les valeurs dynamiques qui apparaîtront dans le PDF final. Trois fonctionnalités du builder lisent directement vos données de test :

### Navigateur de variables

Lorsque vous configurez une liaison de propriété (par exemple, en définissant la source d’un bloc Image), une liste déroulante du navigateur de variables apparaît. Elle répertorie chaque chemin disponible dans vos données de test. Si vos données de test contiennent `logo_url` au premier niveau et `items[0].description` imbriqué dans un tableau, les deux chemins apparaissent comme options sélectionnables.

### Conditions de visibilité

Le paramètre d’affichage conditionnel du panneau Logic évalue des expressions JavaScript par rapport à vos données de test. Quand vous saisissez une condition comme `items.length > 0`, le panneau montre immédiatement si l’élément est actuellement visible ou masqué en fonction des valeurs des données de test.

### Répétition

Lorsque vous configurez la répétition sur un élément et le pointez vers une collection comme `items`, le builder itère sur ce tableau dans vos données de test. Le canevas affiche une copie de l’élément pour chaque item, ce qui vous permet de voir exactement à quoi ressemble votre mise en page répétée avec des données réelles.

## Aperçu en direct

Les modifications des données de test mettent à jour le canevas immédiatement. Modifiez un nom, ajoutez un élément à un tableau, ou changez une URL, et le modèle se re-rend en temps réel. Cela fait de l’éditeur de payload l’outil principal pour déboguer le contenu dynamique (si quelque chose ne va pas, vérifiez d’abord vos données de test).

## Lien avec la génération de documents

La structure JSON que vous utilisez comme données de test est la même structure que vous transmettez en tant que `payload` lors de la génération de documents via l’API ou le tableau de bord. Garder vos données de test réalistes garantit que ce que vous voyez dans le builder correspond à ce que vous obtenez dans le PDF final.

> [!NOTE]
> Les données de test sont enregistrées avec le modèle. Vous pouvez fermer l’éditeur et revenir plus tard sans perdre votre payload d’exemple.


## Conseils pour des données de test efficaces

- **Couvrez toutes les branches :** si votre modèle a des conditions de visibilité, incluez des données de test qui déclenchent à la fois l’état visible et l’état masqué. Changez les valeurs entre les essais pour vérifier les deux chemins.
- **Utilisez des longueurs de tableau réalistes :** si votre modèle se répète sur une liste d’articles, testez avec un article, quelques-uns, et suffisamment d’articles pour déclencher un saut de page. Les cas limites dans la répétition sont plus faciles à détecter tôt.
- **Reproduisez votre payload de production :** plus vos données de test ressemblent aux vrais payloads API, moins vous aurez de surprises lors de la génération de documents réels.


## FAQ

**Que sont les données de test dans le builder PDFMonkey ?**

Les données de test sont un exemple JSON que vous saisissez dans l’éditeur de payload pour prévisualiser le rendu de votre modèle avec du contenu réaliste. Le builder les utilise pour remplir le texte, les images et les boucles en temps réel avant de générer des documents.

**Quels formats de clés JSON sont valides pour les données de test PDFMonkey ?**

Les clés doivent être des identifiants JavaScript valides : camelCase, snake_case ou noms préfixés par un dollar fonctionnent. Les clés contenant des points, des espaces, des tirets ou commençant par un chiffre sont invalides car le builder les traite comme des expressions JavaScript.

**Les données de test sont-elles sauvegardées avec mon modèle PDFMonkey ?**

Oui. Les données de test sont sauvegardées avec le modèle, vous pouvez donc fermer l’éditeur et y revenir plus tard sans perdre votre payload d’exemple.

**La structure JSON des données de test correspond-elle au payload de l'API ?**

Oui. La structure JSON que vous utilisez comme données de test est la même que celle que vous transmettez comme payload lors de la génération de documents via l’API. Garder des données de test réalistes garantit que l’aperçu du builder correspond au PDF final.



---

# Générer des documents depuis le tableau de bord

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md
Vous pouvez générer des documents directement depuis le tableau de bord PDFMonkey sans écrire de code. C’est utile pour les documents ponctuels, pour tester un modèle avant d’intégrer l’API, ou quand des membres non techniques de l’équipe ont besoin de produire des PDF. Pour un guide complet, consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

## Prérequis

Avant de générer un document, vous avez besoin de :

- Un compte PDFMonkey ([inscrivez-vous ici](https://dashboard.pdfmonkey.io/register))
- Un modèle publié — si vous n’en avez pas encore créé, suivez le [tutoriel de démarrage](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md)

## Créer et générer un document

1. Rendez-vous sur [la page Documents](https://dashboard.pdfmonkey.io/documents).
2. Cliquez sur **Create my first Document** (ou **New Document** si vous avez déjà des documents).
3. Sélectionnez un modèle dans la liste déroulante et cliquez sur **Create a draft**. L’éditeur de document s’ouvre.
4. Dans l’onglet **Data**, fournissez le payload JSON attendu par votre modèle — il suit la même structure que les données de test définies dans votre modèle.
5. Si nécessaire, basculez vers l’onglet **Meta data** pour définir un [nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) ou d’autres métadonnées.
6. Cliquez sur **Save** pour actualiser le panneau d’aperçu à droite, puis cliquez sur **Generate**.

## Et ensuite ?

Lorsque vous cliquez sur **Generate**, le document entre dans le [cycle de vie](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md). Quand son statut atteint **success**, une [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) temporaire apparaît sur la page du document. Vous pouvez aussi retrouver tous vos documents générés sur la [page Documents](https://dashboard.pdfmonkey.io/documents).

En cas de problème, consultez la section [Dépannage](https://pdfmonkey.io/fr/docs/depannage/_index.md).


---

# Générer des PDF avec l’API

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md
L’API REST PDFMonkey vous permet de générer des documents PDF à partir de vos modèles en envoyant des requêtes HTTP avec des données JSON. Utilisez-la pour créer des factures, reçus, rapports, attestations et tout PDF à partir de données dynamiques — c’est l’approche idéale pour les workflows automatisés dans votre propre application.

> [!NOTE]
> **Prérequis**
>
> Vous aurez besoin d’un [compte PDFMonkey](https://dashboard.pdfmonkey.io/users/sign_up) et d’au moins un modèle. Si vous n’avez pas encore créé de modèle, consultez [De zéro au premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).


## Générer un PDF

### 1. Récupérez votre clé API

Récupérez votre clé secrète depuis la [page Clé API](https://dashboard.pdfmonkey.io/api_key) de votre tableau de bord. Consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md) pour plus de détails.

### 2. Créez un document

Envoyez une requête POST à `/api/v1/documents` avec l’identifiant de votre modèle et vos données dynamiques. Le paramètre `"status": "pending"` lance la génération immédiatement.

Des exemples sont disponibles en curl, Ruby, Node.js, Python et PHP :








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  -H &#39;Content-Type: application/json&#39; \
  -d &#39;{
    &#34;document&#34;: {
      &#34;document_template_id&#34;: &#34;YOUR-TEMPLATE-ID&#34;,
      &#34;status&#34;: &#34;pending&#34;,
      &#34;payload&#34;: {
        &#34;name&#34;: &#34;Jane Doe&#34;
      }
    }
  }&#39;
```

**Ruby**

```ruby
# generate! attend que le PDF soit prêt avant de retourner le résultat
document = Pdfmonkey::Document.generate!(
  document_template_id: &#39;YOUR-TEMPLATE-ID&#39;,
  payload: { name: &#39;Jane Doe&#39; }
)

document.status       # =&gt; &#39;success&#39;
document.download_url # =&gt; &#39;https://…&#39;
```

**Node.js**

```javascript
const response = await fetch(&#39;https://api.pdfmonkey.io/api/v1/documents&#39;, {
  method: &#39;POST&#39;,
  headers: {
    &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    &#39;Content-Type&#39;: &#39;application/json&#39;,
  },
  body: JSON.stringify({
    document: {
      document_template_id: &#39;YOUR-TEMPLATE-ID&#39;,
      status: &#39;pending&#39;,
      payload: { name: &#39;Jane Doe&#39; },
    },
  }),
});

const data = await response.json();
console.log(data.document);
```

**Python**

```python
import requests

response = requests.post(
    &#39;https://api.pdfmonkey.io/api/v1/documents&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    json={
        &#39;document&#39;: {
            &#39;document_template_id&#39;: &#39;YOUR-TEMPLATE-ID&#39;,
            &#39;status&#39;: &#39;pending&#39;,
            &#39;payload&#39;: {&#39;name&#39;: &#39;Jane Doe&#39;},
        },
    },
)

print(response.json())
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/documents&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_POST =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
        &#39;Content-Type: application/json&#39;,
    ],
    CURLOPT_POSTFIELDS =&gt; json_encode([
        &#39;document&#39; =&gt; [
            &#39;document_template_id&#39; =&gt; &#39;YOUR-TEMPLATE-ID&#39;,
            &#39;status&#39; =&gt; &#39;pending&#39;,
            &#39;payload&#39; =&gt; [&#39;name&#39; =&gt; &#39;Jane Doe&#39;],
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

print_r(json_decode($response, true));
```



L’API renvoie le document avec son statut actuel. Notez l’`id` — vous en aurez besoin pour vérifier l’avancement de la génération.

```json title="201 Created (résumé)"
{
  "document": {
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "status": "pending",
    "download_url": null,
    ...
  }
}
```

### 3. Vérifiez l’état de la génération

Le PDF n’est pas encore prêt — interrogez l’endpoint `document_cards` jusqu’à ce que le statut atteigne `success`, puis lisez la `download_url`.








**curl**

```bash
curl -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  https://api.pdfmonkey.io/api/v1/document_cards/DOCUMENT_ID
# Quand le statut est &#34;success&#34;, le champ download_url contient un lien signé vers le PDF
```

**Ruby**

```ruby
# Pas nécessaire avec generate! — le document est déjà prêt
card = Pdfmonkey::Document.fetch_card(&#39;DOCUMENT_ID&#39;)

card.status       # =&gt; &#39;success&#39;
card.download_url # =&gt; &#39;https://…&#39;
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/document_cards/DOCUMENT_ID&#39;,
  {
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

const data = await response.json();
console.log(data.document_card.status);       // =&gt; &#39;success&#39;
console.log(data.document_card.download_url); // =&gt; &#39;https://…&#39;
```

**Python**

```python
import requests

response = requests.get(
    &#39;https://api.pdfmonkey.io/api/v1/document_cards/DOCUMENT_ID&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
)

card = response.json()[&#39;document_card&#39;]
print(card[&#39;status&#39;])       # =&gt; &#39;success&#39;
print(card[&#39;download_url&#39;]) # =&gt; &#39;https://…&#39;
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_cards/DOCUMENT_ID&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$card = json_decode($response, true)[&#39;document_card&#39;];
echo $card[&#39;status&#39;];       // =&gt; &#39;success&#39;
echo $card[&#39;download_url&#39;]; // =&gt; &#39;https://…&#39;
```



> [!TIP]
> Plutôt que d’interroger l’API régulièrement, vous pouvez configurer un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour être notifié lorsque le document est prêt. C’est l’approche recommandée en production.


## Génération asynchrone vs synchrone

Par défaut, la génération de documents est **asynchrone** : vous créez le document, puis vous interrogez l’API ou configurez un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour savoir quand il est prêt. C’est l’approche la plus adaptée en production, en particulier pour les gros volumes.

Si vous préférez attendre le résultat en une seule requête, utilisez l’endpoint **synchrone** `/api/v1/documents/sync`. C’est pratique pour le prototypage ou les cas d’utilisation interactifs à faible volume. Consultez [Génération synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation) pour les détails et les limitations.

## Questions fréquentes

**Quel format utiliser pour le payload ?**

Le champ `payload` accepte tout objet JSON valide. Sa structure doit correspondre aux variables utilisées dans votre modèle — voir [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md).

**Combien de temps prend la génération d’un PDF ?**

La plupart des documents sont prêts en quelques secondes. Les modèles complexes avec de nombreuses pages ou des images volumineuses peuvent prendre plus de temps. Utilisez un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour être notifié dès que le PDF est disponible.

**Y a-t-il une limite de requêtes ?**

Il n’y a pas de limite stricte sur l’API, mais le quota mensuel de documents de votre plan s’applique. Consultez [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) pour les détails des quotas.

**Peut-on générer plusieurs PDF en une seule requête ?**

Pas directement — chaque appel API génère un document. Pour générer des PDF en masse, envoyez plusieurs requêtes en parallèle ou utilisez une plateforme d’automatisation comme [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md) ou [Make](https://pdfmonkey.io/fr/docs/integrations/make.md).

---

- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des endpoints
- [Statuts des documents et cycle de vie](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre les statuts des documents
- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — comment récupérer le PDF généré


---

# Convertir du HTML en PDF avec l'API PDFMonkey

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/html-vers-pdf.md
**PDFMonkey peut fonctionner comme une API HTML vers PDF.** Envoyez votre HTML complet — `<head>`, styles et `<body>` inclus — sous forme de chaîne dans le payload du document, et PDFMonkey le convertit en PDF tel quel. Aucun travail de templating côté PDFMonkey n'est nécessaire.

C'est utile lorsque le HTML vit déjà dans votre propre pipeline : un moteur d'e-mails transactionnels réutilisé pour des reçus, un export depuis un dashboard, ou un template de facture HTML existant.

> [!NOTE]
> **Quand utiliser cette approche**
>
> N&#39;adoptez ce schéma que lorsque le HTML est produit et maintenu en dehors de PDFMonkey. Si la mise en page du document sera toujours générée par PDFMonkey, un [Modèle Code](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) classique avec des données dynamiques et de la logique Liquid vous servira bien mieux.


## Comment PDFMonkey convertit votre HTML en PDF

PDFMonkey n'expose pas de point d'entrée HTML brut. Chaque PDF est généré à partir d'un Template. La solution consiste en un Modèle Code minimaliste qui sert de relais transparent :

1. Le template contient une seule balise de sortie Liquid : `{{htmlContent}}`
2. Vous envoyez votre HTML complet comme valeur de `htmlContent` dans le payload du document
3. Liquid rend la balise sans l'échapper, donc votre HTML est injecté verbatim
4. Le moteur PDF convertit la page résultante en PDF

## Étape 1 — Créer le template relais

Créez un nouveau **Modèle Code** (cela ne fonctionne pas avec les Modèles Builder — voir plus bas). Dans l'onglet HTML, n'écrivez rien de plus que :

```liquid
{{htmlContent}}
```

Ouvrez les **Paramètres** et configurez le format de page, les marges et la version du moteur souhaités. Ces réglages s'appliquent au niveau du template, quel que soit le HTML que vous envoyez.

Cliquez sur **Publier** pour rendre le template disponible via l'API.

> [!WARNING]
> **Envoyez un document HTML complet**
>
> Le template ne rend que ce qui se trouve dans `htmlContent`. Votre HTML doit tout inclure : une déclaration `&lt;!DOCTYPE html&gt;`, un `&lt;head&gt;` avec vos balises `&lt;style&gt;` ou `&lt;link&gt;`, et un `&lt;body&gt;`. PDFMonkey n&#39;ajoute rien autour.


## Étape 2 — Envoyer votre HTML dans le payload du document

Envoyez votre HTML comme champ de type chaîne `htmlContent` à l'intérieur de l'objet `payload` :

```bash
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H 'Authorization: Bearer YOUR_SECRET_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "document": {
      "document_template_id": "YOUR-TEMPLATE-ID",
      "status": "pending",
      "payload": {
        "htmlContent": "<!DOCTYPE html><html><head><style>p { color: #333 }</style></head><body><p>Hello\nWorld!</p></body></html>"
      }
    }
  }'
```

La plupart des bibliothèques HTTP (Node.js `fetch`, Python `requests`, Ruby `net/http`) sérialisent les chaînes automatiquement — vous passez le HTML comme une chaîne normale et la bibliothèque gère l'échappement. Si vous construisez le JSON à la main, échappez :

- les guillemets doubles → `\"`
- les retours à la ligne → `\n`
- les antislashs → `\\`

Voir [Générer des PDFs avec l'API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) pour le flux de génération complet, y compris la récupération de l'URL de téléchargement.

## Combiner votre HTML avec du Liquid

Le template passe toujours par Liquid, donc vous pouvez superposer de la logique PDFMonkey sur votre HTML. Par exemple, ce template ajoute un filigrane sans toucher à votre HTML :

```liquid
{{htmlContent}}

{% if watermark %}
  <div class="watermark">{{watermark}}</div>
{% endif %}
```

Envoyez `htmlContent` et `watermark` dans le payload. La balise `{% raw %}` est disponible si un champ de votre payload contient des caractères `{{` littéraux qui ne doivent pas être évalués.

## Assets, polices et encodage

Quelques points à vérifier pour que votre HTML s'affiche correctement.

**Les images et feuilles de style externes doivent utiliser des URL absolues.** Le moteur PDF n'a aucune notion de votre système de fichiers ou de votre serveur. Un chemin relatif comme `./img/logo.png` ou `/assets/style.css` ne sera pas résolu et l'asset sera ignoré silencieusement. Utilisez des URL complètes en `https://` à la place.

**Les polices externes se chargent normalement si elles sont accessibles.** Un `<link>` vers Google Fonts ou un CDN public fonctionne comme prévu — le moteur les récupère lors du rendu. Les polices hébergées derrière une authentification ou sur localhost ne se chargeront pas.

**Déclarez votre encodage de caractères.** Incluez toujours `<meta charset="utf-8">` dans le `<head>`. Sans cela, les caractères non-ASCII (lettres accentuées, CJK, symboles) peuvent s'afficher sous forme de caractères corrompus selon la version du moteur.

## Compromis et limites

| Compromis | Détails |
|-----------|---------|
| Pas de layout réutilisable | Les en-têtes, pieds de page et styles partagés doivent vivre dans votre propre pipeline HTML |
| Payloads plus volumineux | Chaque document transporte la chaîne HTML complète ; les gros payloads comptent dans les [limites de stockage](https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md) |
| Pas d'aperçu en direct | L'onglet Données de test peut contenir un exemple, mais les changements ne se prévisualisent pas comme avec un template classique |
| Pas de logique Liquid intégrée | Conditions, boucles et filtres doivent être dans votre moteur, pas dans PDFMonkey |

Si vous avez besoin de ces fonctionnalités, basculez sur un [Modèle Code](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) et laissez PDFMonkey gérer le rendu.

## Les Modèles Builder ne supportent pas ce schéma

Les Modèles Builder rendent leurs bindings via Vue, qui **échappe le HTML par défaut** dans les expressions `{{ ... }}`. Du HTML brut envoyé via un binding Builder s'affiche comme du texte visible.

Pour injecter du HTML déjà construit dans un Modèle Builder, déposez un [bloc HTML](https://pdfmonkey.io/fr/docs/modeles-builder/blocs-disponibles.md#html) sur le canvas et collez votre balisage directement dans son éditeur de code. Les blocs HTML sont statiques — ils font partie du template, pas du payload.

## Pages liées

- [Générer des PDFs avec l'API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — le flux de génération complet avec le suivi de statut et le téléchargement
- [Utiliser les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) — la façon standard de passer des données structurées à un template
- [La syntaxe Liquid](https://pdfmonkey.io/fr/docs/modeles-code/la-syntaxe-liquid.md) — balises de sortie, logique et filtres dans les Modèles Code
- [Blocs disponibles dans le Builder](https://pdfmonkey.io/fr/docs/modeles-builder/blocs-disponibles.md#html) — le bloc HTML pour les Modèles Builder


## FAQ

**Puis-je utiliser PDFMonkey comme API HTML vers PDF ?**

Oui. Créez un Modèle Code contenant uniquement {{htmlContent}}, puis envoyez votre HTML complet comme valeur de htmlContent dans le payload du document. Le moteur Liquid de PDFMonkey n'échappe pas le HTML, donc le balisage est rendu tel quel et le fichier généré est retourné.

**Comment envoyer du HTML déjà construit à PDFMonkey pour obtenir un PDF ?**

1. Créez un Modèle Code avec une seule ligne : {{htmlContent}}. 2. Publiez le template. 3. Envoyez une requête POST à /api/v1/documents avec votre HTML comme chaîne dans le champ htmlContent du payload. PDFMonkey génère le PDF et retourne le document avec une URL de téléchargement.

**Cette approche HTML vers PDF fonctionne-t-elle avec un Modèle Builder ?**

Non. Les Modèles Builder utilisent Vue, qui échappe le contenu interpolé par défaut. Le HTML brut envoyé via un binding Builder s'affiche comme du texte visible, pas comme du balisage rendu. Utilisez plutôt un Modèle Code, ou déposez un bloc HTML sur le canvas du Builder.

**Pourquoi faut-il quand même un template si j'envoie tout le HTML moi-même ?**

PDFMonkey génère toujours les documents à partir d'un template. Ce dernier porte le format de page, les marges, la version du moteur et les contrôles d'accès — même lorsqu'il ne contient qu'un placeholder Liquid pour votre HTML.

**Quel échappement est nécessaire pour envoyer du HTML dans un payload JSON ?**

Les guillemets doubles doivent être échappés en \", les retours à la ligne en \n et les antislashs en \\. La plupart des bibliothèques HTTP et des sérialiseurs JSON gèrent cela automatiquement — l'échappement manuel n'est nécessaire que lorsque vous construisez des chaînes JSON brutes à la main.


---

# Générer des PDF avec des intégrations no-code

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-une-integration.md
PDFMonkey s’intègre aux plateformes d’automatisation les plus populaires pour vous permettre de générer des documents sans écrire la moindre ligne de code. Connectez votre CRM, votre outil de formulaires, votre base de données ou toute autre application à PDFMonkey et produisez des PDF automatiquement.

## Quand utiliser une intégration

Les intégrations no-code sont le bon choix lorsque :

- Vous souhaitez **automatiser la génération de PDF** en réaction à des événements dans d’autres applications (nouvelle soumission de formulaire, nouveau deal CRM, ligne de tableur mise à jour, etc.)
- Vous préférez un **workflow visuel en glisser-déposer** plutôt que d’écrire du code
- Vous devez connecter PDFMonkey à des **applications sans backend** que vous contrôlez (Google Sheets, Airtable, Typeform, etc.)

Si vous avez besoin d’un contrôle programmatique complet ou que vous développez une application sur mesure, utilisez plutôt l’[API REST](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md).

## Comment ça fonctionne

Quelle que soit la plateforme choisie, le workflow général est le même :

1. **Créez un template** dans PDFMonkey — soit avec le [Builder visuel](https://pdfmonkey.io/fr/docs/modeles-builder/_index.md), soit avec du [code HTML/CSS](https://pdfmonkey.io/fr/docs/modeles-code/_index.md).
2. **Connectez votre compte PDFMonkey** dans la plateforme d’automatisation à l’aide de votre clé API secrète (disponible sur la page [Mon compte](https://dashboard.pdfmonkey.io/account)).
3. **Configurez un déclencheur** — l’événement qui lance la génération du PDF (par ex. une nouvelle ligne dans un tableur, une soumission de formulaire, un nouvel enregistrement dans un CRM).
4. **Associez vos données** aux variables du template. La plateforme d’automatisation transmet les valeurs du déclencheur vers les champs dynamiques de votre template.
5. **Générez et distribuez** — PDFMonkey crée le PDF et renvoie une URL de téléchargement. Vous pouvez ensuite l’envoyer par e-mail, le déposer sur un espace de stockage distant ou le transmettre à une autre étape de votre workflow.

> [!TIP]
> La plupart des intégrations renvoient une **URL de téléchargement** après la génération. Cette URL est temporaire (elle expire au bout d’une heure). Si vous avez besoin d’un lien permanent, utilisez un [lien de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) ou déposez le PDF vers votre propre espace de stockage dans le cadre du workflow.


## Intégrations disponibles

| Plateforme | Idéale pour | Détails |
| ---------- | ----------- | ------- |
| [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md) | Connecter 6 000+ applications avec un modèle simple déclencheur-action | Déclencheurs, actions et mapping de champs |
| [Make](https://pdfmonkey.io/fr/docs/integrations/make.md) | Construire des scénarios visuels multi-étapes avec des embranchements | Module complet : générer, récupérer et télécharger |
| [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md) | Workflows auto-hébergés ou cloud avec un outil open-source | Noeud dédié avec toutes les opérations CRUD |
| [Workato](https://pdfmonkey.io/fr/docs/integrations/workato.md) | Automatisation entreprise avec une orchestration avancée | Recettes pour générer, supprimer et réagir aux documents |
| [Bubble](https://pdfmonkey.io/fr/docs/integrations/bubble.md) | Ajouter la génération de PDF à une application Bubble no-code | Plugin pour une intégration directe |
| [Glide](https://pdfmonkey.io/fr/docs/integrations/glide.md) | Générer des documents depuis une application Glide | Intégration légère |

Parcourez toutes les intégrations — dont le [SDK Ruby](https://pdfmonkey.io/fr/docs/integrations/sdk-ruby.md) — dans la section [Intégrations](https://pdfmonkey.io/fr/docs/integrations/_index.md).

## Intégrations personnalisées

Pour les plateformes non listées ci-dessus, vous avez deux options :

- **Webhooks** — Configurez un [endpoint webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) dans PDFMonkey pour recevoir une notification (avec les données du document et l’URL de téléchargement) à chaque fois qu’un document est généré. Votre système peut ensuite traiter le PDF comme vous le souhaitez.
- **Requêtes HTTP directes** — Toute plateforme prenant en charge les requêtes HTTP peut appeler l’[API REST PDFMonkey](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) directement. Envoyez une requête POST avec l’identifiant de votre template et les données dynamiques pour créer un document.

## Prochaines étapes

- Choisissez une plateforme et suivez son guide dédié dans la section [Intégrations](https://pdfmonkey.io/fr/docs/integrations/_index.md)
- Vous débutez avec PDFMonkey ? Commencez par [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) pour créer un template
- Besoin de réagir aux documents générés ? Découvrez les [webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md)


## FAQ

**Peut-on générer des PDF sans coder avec PDFMonkey ?**

Oui. PDFMonkey s’intègre avec Zapier, Make, n8n, Workato, Bubble et Glide. Vous concevez un template dans PDFMonkey, puis vous le connectez à votre plateforme d’automatisation pour générer des documents automatiquement lorsque des événements se produisent dans d’autres applications — aucun code requis.

**Avec quelles plateformes no-code PDFMonkey s’intègre-t-il ?**

PDFMonkey dispose d’intégrations officielles avec Zapier (plus de 6 000 connecteurs), Make (scénarios visuels multi-étapes), n8n (workflows open source), Workato (automatisation entreprise), Bubble (applications web no-code) et Glide (applications mobiles no-code).

**Comment fonctionnent les intégrations no-code avec PDFMonkey ?**

Le processus est le suivant : 1) Concevez un template dans PDFMonkey, 2) Connectez votre compte PDFMonkey dans la plateforme d’automatisation avec votre clé API, 3) Configurez un événement déclencheur, 4) Associez les champs de données aux variables du template, 5) PDFMonkey génère le document et retourne une URL de téléchargement.


---

# Statuts des documents et cycle de vie

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md
Chaque document dans PDFMonkey passe par une série de statuts au fil de sa progression, de la création jusqu’au PDF final. Comprendre ce cycle de vie vous aide à construire des intégrations fiables et à résoudre les problèmes de génération.

## Vue d’ensemble des statuts

| Statut | Signification | Ce que vous pouvez faire |
|:---|:---|:---|
| `draft` | Créé mais pas encore mis en file d’attente | Modifier le payload, prévisualiser, supprimer |
| `pending` | En file d’attente, en attente d’un worker | Attendre — le traitement démarre automatiquement |
| `generating` | Activement transformé en PDF | Attendre — le worker traite le document |
| `success` | Le PDF est prêt | Télécharger, partager, intégrer une prévisualisation |
| `failure` | Une erreur s’est produite pendant la génération | Examiner l’erreur, corriger le problème, réessayer |

```mermaid
stateDiagram-v2
    [*] --> draft: Création via API ou tableau de bord
    draft --> pending: Génération demandée
    pending --> generating: Pris en charge par un worker
    generating --> success: PDF prêt
    generating --> failure: Erreur survenue
    failure --> pending: Nouvelle tentative
```

## Brouillon (Draft) {#draft}

Un document commence au statut **draft** lorsque vous le créez, que ce soit via l’API ou le Dashboard. C’est le statut par défaut — si vous ne définissez pas `"status": "pending"` dans votre appel API, le document reste dans cet état.

**Ce que vous pouvez faire :**

- Modifier les données dynamiques (payload) du document
- Prévisualiser le document via le champ `preview_url` (voir [Intégrer une prévisualisation de document](https://pdfmonkey.io/fr/docs/generation-de-documents/integrer-un-apercu.md))
- Supprimer le document

**Transition sortante :** Demandez la génération en appelant l’API avec `"status": "pending"` ou en cliquant sur **Generate** dans le Dashboard. Le document passe au statut **pending**.

> [!TIP]
> Vous pouvez passer l’étape du brouillon. Définissez `&#34;status&#34;: &#34;pending&#34;` dès la création du document pour lancer immédiatement la génération — c’est l’approche la plus courante pour les intégrations API.


## En attente (Pending) {#pending}

Un document au statut **pending** est en file d’attente et attend d’être pris en charge par un worker de génération.

**Ce que cela signifie :** La demande de génération a été acceptée mais le traitement n’a pas encore commencé. En conditions normales, les documents quittent ce statut en quelques secondes.

**Transition sortante :** Un worker prend en charge le document et le fait passer au statut **generating**. Cela se produit automatiquement — aucune action n’est requise de votre côté.

> [!NOTE]
> Définir `&#34;status&#34;: &#34;pending&#34;` déclenche une vérification du quota. Si votre compte a dépassé son quota mensuel de documents, l’API rejette la requête avec une erreur de validation. Consultez [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) pour les détails des quotas.


## En cours de génération (Generating) {#generating}

Un document au statut **generating** est activement traité. Le template est rendu avec le payload du document puis converti en PDF (ou en image, selon le [format de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) du template).

**Ce que cela signifie :** Le worker construit le document. Cela prend généralement quelques secondes, mais les templates complexes avec de nombreuses pages ou des ressources lourdes peuvent prendre plus de temps.

**Transition sortante :** Le document passe au statut **success** ou **failure** selon le résultat.

## Succès (Success) {#success}

Un document au statut **success** a été généré et son PDF est disponible au téléchargement.

**Ce que vous pouvez faire :**

- Télécharger le PDF via le champ `download_url` — il s’agit d’une URL signée temporaire valide pendant 1 heure, renouvelée à chaque appel API (voir [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md))
- Partager le document via son `public_share_link` si activé (voir [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md))
- Recevoir une notification [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) lorsque la génération est terminée

> [!WARNING]
> Le `download_url` expire après 1 heure. Récupérez le document à nouveau depuis l’API pour obtenir une URL fraîche. Consultez [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour plus de détails.


## Échec (Failure) {#failure}

Un document au statut **failure** a rencontré une erreur pendant la génération. Le champ `failure_cause` dans la réponse de l’API contient une description lisible de l’erreur. Le champ `generation_logs` fournit des détails supplémentaires pour le débogage.

**Causes fréquentes :**

- Erreurs de syntaxe dans le template (Liquid, HTML ou la CSS)
- Données dynamiques invalides ou manquantes
- Échec du chargement de ressources (URLs d’images cassées, ressources externes inaccessibles)
- Timeout dû à une complexité excessive du template

**Ce que vous pouvez faire :**

- Examiner les champs `failure_cause` et `generation_logs` pour comprendre l’erreur
- Corriger le problème sous-jacent dans le template ou le payload
- Relancer la génération en remettant le statut du document à `"pending"` via l’API

**Transition sortante :** Lorsque vous demandez une nouvelle tentative, le document repasse au statut **pending** et traverse à nouveau le cycle de génération.

## Réagir aux changements de statut

Vous n’avez pas besoin de faire des appels en boucle à l’API pour savoir quand un document est prêt. Configurez un [endpoint webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour recevoir une notification lorsque la génération réussit ou échoue. C’est l’approche recommandée pour les intégrations en production.

Si vous préférez un flux synchrone, utilisez l’endpoint `/api/v1/documents/sync` pour attendre le résultat en une seule requête. Consultez [Génération synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation) pour les détails et les limitations.

## Pages associées

- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — fonctionnement des liens de téléchargement temporaires
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) — recevoir des notifications lors des changements de statut
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des endpoints et des champs
- [Dépannage : l’URL de téléchargement est vide](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-est-vide.md) — raisons courantes pour lesquelles `download_url` est `null`
- [Dépannage : l’URL de téléchargement retourne une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md) — comment gérer les URLs expirées


## FAQ

**Quels sont les statuts possibles d’un document PDFMonkey ?**

Les documents passent par cinq statuts : draft (créé mais non mis en file d’attente), pending (en attente de traitement), generating (en cours de rendu), success (le fichier est prêt à télécharger) et failure (une erreur s’est produite lors de la génération).

**Peut-on ignorer le statut draft lors de la génération d’un document PDFMonkey ?**

Oui. Définissez le statut sur pending lors de la création du document via l’API pour lancer immédiatement la génération. C’est le schéma le plus courant pour les intégrations API.

**Que se passe-t-il quand un document PDFMonkey échoue ?**

Le document passe au statut failure avec un champ failure_cause décrivant l’erreur. Vous pouvez inspecter l’erreur, corriger le modèle ou les données, puis relancer en remettant le statut sur pending.


---

# URL de téléchargement

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md
Lorsqu’un document atteint le [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) **success**, la réponse de l’API inclut un champ `download_url`. Il s’agit d’une URL signée temporaire pointant vers le PDF ou l’image généré et stocké sur S3. Elle déclenche un téléchargement de fichier (pas un affichage dans le navigateur) et expire après 1 heure.

```json title="Réponse d'un document généré avec succès (simplifiée)"
{
  "document": {
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "status": "success",
    "download_url": "https://pdfmonkey-production.s3.eu-west-1.amazonaws.com/...",
    "preview_url": "https://preview.pdfmonkey.io/...",
    "public_share_link": null
  }
}
```

## Quand l’URL de téléchargement apparaît

Le champ `download_url` n’est renseigné que lorsque le statut du document est `success`. Pour tous les autres statuts (`draft`, `pending`, `generating`, `failure`), le champ renvoie `null`.

Si vous venez de créer un document et que l’URL est null, la raison la plus probable est que la génération n’est pas encore terminée. Consultez [L’URL de téléchargement est vide](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-est-vide.md) pour un diagnostic complet.

## Expiration de l’URL (1 heure)

> [!WARNING]
> **Les URL de téléchargement expirent après 1 heure**
>
> Chaque URL de téléchargement est valide pendant **1 heure**. Passé ce délai, le lien renvoie une erreur **403 Forbidden**. C’est un comportement normal : l’URL est conçue pour être éphémère pour des raisons de sécurité. Consultez [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md) si vous rencontrez ce problème.


Chaque fois que vous récupérez les détails du document (via l’API ou une intégration), vous recevez une **URL fraîche** avec une nouvelle fenêtre d’une heure. Vous n’avez jamais besoin de régénérer le document lui-même pour obtenir un lien fonctionnel.

Si vous avez besoin d’une URL permanente qui n’expire jamais, utilisez plutôt les [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md).

## Renouveler une URL de téléchargement expirée

Si une URL de téléchargement a expiré, récupérez le document à nouveau pour en obtenir une nouvelle :

- **Via l’API :** `GET /api/v1/document_cards/:id` — voir la [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md)
- **Via une intégration :** Utilisez une action « Get Document » ou « Find Document » dans [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [Make](https://pdfmonkey.io/fr/docs/integrations/make.md) ou une autre plateforme
- **Via le tableau de bord :** Ouvrez la page de détail du document — le lien de téléchargement est toujours à jour

Vous n’avez **pas** besoin de régénérer le document. Le fichier reste sur S3 jusqu’à sa [suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) — seule l’URL signée expire.

## URL de téléchargement vs. autres champs d’URL

| Champ | Utilisation | Expiration |
|:------|:-----------|:-----------|
| `download_url` | URL signée temporaire qui télécharge le fichier généré. Renseignée uniquement au statut `success`. | 1 heure |
| `preview_url` | Affiche un aperçu du document dans le navigateur. Fonctionne même pour les brouillons. **Ce n’est pas un lien de téléchargement** — ne l’utilisez pas pour récupérer le fichier final. Voir [Intégrer une prévisualisation](https://pdfmonkey.io/fr/docs/generation-de-documents/integrer-un-apercu.md). | N’expire pas |
| `public_share_link` | URL publique permanente pour consulter et télécharger le fichier. Disponible uniquement sur les plans Pro+ et Premium. Voir [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md). | N’expire pas |

## Bonnes pratiques

- **Téléchargez rapidement.** Lorsque vous recevez une notification [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) ou que vous interrogez l’API pour vérifier que le document est prêt, téléchargez le fichier immédiatement.
- **Stockez le fichier, pas l’URL.** Si vous avez besoin du fichier plus tard, enregistrez-le dans votre propre stockage (S3, Google Drive, etc.) plutôt que de compter sur l’URL de téléchargement temporaire.
- **Récupérez à nouveau si nécessaire.** Si vous avez besoin de l’URL plus tard, appelez l’API à nouveau pour en obtenir une nouvelle — cela ne prend qu’une seule requête GET.
- **Utilisez les liens de partage pour la diffusion.** Si vous avez besoin d’une URL stable pour l’intégrer dans des e-mails ou des pages web, utilisez `public_share_link` à la place (nécessite un plan Pro+ ou Premium). Voir [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md).

## Dépannage

- [L’URL de téléchargement est vide](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-est-vide.md) — raisons courantes pour lesquelles l’URL est `null`
- [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md) — comment gérer les URL expirées

## Pages associées

- [Statuts des documents et cycle de vie](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre quand `download_url` devient disponible
- [Générer des PDF avec l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — flux de génération de bout en bout
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) — être notifié lorsqu’un document est prêt à télécharger
- [Suppression automatique (TTL)](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) — durée de stockage des fichiers avant nettoyage
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des champs


## FAQ

**Combien de temps une URL de téléchargement PDFMonkey est-elle valide ?**

Chaque URL de téléchargement est un lien signé temporaire valide pendant 1 heure. Passé ce délai, elle renvoie une erreur 403 Forbidden. Récupérez le document à nouveau via l’API pour obtenir une URL fraîche — pas besoin de régénérer le document.

**Pourquoi le champ download_url est-il null ?**

Le champ download_url n’est renseigné que lorsque le statut du document est "success". Si le document est en statut draft, pending, generating ou failure, le champ renvoie null. Assurez-vous de définir le statut sur "pending" lors de la création du document et attendez la fin de la génération.

**Comment obtenir une nouvelle URL de téléchargement après expiration ?**

Récupérez le document à nouveau via l’API (GET /api/v1/document_cards/:id) ou via une intégration. Chaque appel renvoie une URL fraîche avec une nouvelle fenêtre d’une heure. Pas besoin de régénérer le document.


---

# Définir un nom de fichier personnalisé pour les documents générés

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md
Par défaut, PDFMonkey nomme les fichiers générés avec un identifiant interne. Vous pouvez remplacer ce comportement en passant une clé `_filename` dans les **métadonnées** du document — cela fonctionne aussi bien pour les PDF que pour les images.

## Définir le nom de fichier via l’API

Incluez la clé `_filename` dans l’objet `meta` lorsque vous [créez](https://pdfmonkey.io/fr/docs/api/documents.md#create-a-document) ou [mettez à jour](https://pdfmonkey.io/fr/docs/api/documents.md#update-a-document) un document :

```bash
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H 'Authorization: Bearer YOUR_SECRET_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "document": {
      "document_template_id": "YOUR_TEMPLATE_ID",
      "status": "pending",
      "payload": { "name": "Jane Doe" },
      "meta": {
        "_filename": "facture-2050-03.pdf"
      }
    }
  }'
```

Le champ `meta` accepte un objet JSON. Vous pouvez inclure d’autres clés de métadonnées en plus de `_filename` — consultez la [référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md#create-a-document) pour tous les détails.

## Définir le nom de fichier depuis le tableau de bord

1. Ouvrez un document dans l’éditeur de document.
2. Passez à l’onglet **Meta data**.
3. Saisissez la clé `_filename` et le nom souhaité :

```json
{
  "_filename": "facture-2050-03.pdf"
}
```

4. Cliquez sur **Save**, puis sur **Generate**.

Pour un guide complet, consultez [Générer des documents depuis le tableau de bord](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md).

## Gestion de l’extension de fichier

PDFMonkey gère automatiquement l’extension en fonction du format de sortie (PDF, PNG, WebP ou JPG) :

- **Si vous incluez l’extension correspondante** (par ex. `facture.pdf` pour un modèle PDF), PDFMonkey la retire et la ré-ajoute pour garder le nom propre.
- **Si vous omettez l’extension**, PDFMonkey ajoute automatiquement la bonne.
- **Si vous incluez une extension incorrecte** (par ex. `.png` sur un document PDF), elle est traitée comme faisant partie du nom et l’extension correcte est quand même ajoutée.

> [!TIP]
> Inutile de vous soucier de l’extension. Fournissez simplement le nom souhaité et laissez PDFMonkey faire le reste.


## Assainissement du nom de fichier

PDFMonkey assainit la valeur de `_filename` pour garantir sa compatibilité avec tous les systèmes de fichiers :

| Règle | Exemple |
|:------|:--------|
| Les caractères accentués sont translittérés en ASCII | `cafe-resume` devient `cafe-resume` |
| Les caractères autres que lettres, chiffres, tirets, underscores et espaces sont remplacés par un tiret | `report@2050/03` devient `report-2050-03` |
| Les tirets consécutifs sont fusionnés | `report---final` devient `report-final` |
| Les tirets en début et fin de chaîne sont supprimés | `-my-file-` devient `my-file` |
| Les espaces en début et fin de chaîne sont supprimés | `" invoice "` devient `"invoice"` |

Par exemple, une valeur `"Facture n 2050/03"` pour un modèle PDF produit le nom de fichier `Facture n-2050-03.pdf`.

## Fonctionne aussi avec les images

La clé `_filename` fonctionne de la même manière pour les [formats d’image](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md). L’extension est ajustée en fonction du type d’image (`.webp`, `.png` ou `.jpg`) :

```json
{
  "meta": {
    "_filename": "social-card-march",
    "_type": "png"
  }
}
```

Cela produit un fichier nommé `social-card-march.png`.

## Questions fréquentes

**Que se passe-t-il si je ne définis pas de nom de fichier personnalisé ?**

PDFMonkey utilise un nom par défaut interne. Si vous avez besoin de noms de fichiers prévisibles pour l’archivage ou des systèmes en aval, définissez toujours `_filename`.

**Puis-je utiliser des données dynamiques dans le nom de fichier ?**

Pas directement dans la valeur `_filename`. Cependant, dans la plupart des plateformes d’intégration (Zapier, Make, n8n), vous pouvez utiliser des champs dynamiques ou des expressions pour construire la chaîne du nom de fichier avant de la transmettre à PDFMonkey.

**Y a-t-il une longueur maximale pour le nom de fichier ?**

Il n’y a pas de limite explicite imposée par PDFMonkey, mais gardez des noms de fichiers raisonnables (moins de 200 caractères) pour éviter les problèmes avec les systèmes de fichiers et les navigateurs.

## Pages associées

- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des paramètres `meta` et autres champs
- [Générer des PDF via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — workflow complet de génération
- [Générer des documents depuis le tableau de bord](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md) — utilisation de l’onglet Métadonnées
- [Formats de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) — génération d’images et clés meta comme `_type`
- [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — comment récupérer le fichier généré


## FAQ

**Comment définir un nom de fichier personnalisé pour un document PDFMonkey ?**

Passez une clé "_filename" dans le champ meta du document. Via l’API, incluez-la dans l’objet meta lors de la création ou de la mise à jour d’un document : "meta": { "_filename": "facture-2050.pdf" }. Dans le tableau de bord, saisissez-la dans l’onglet Métadonnées de l’éditeur de document.

**PDFMonkey ajoute-t-il l’extension de fichier automatiquement ?**

Oui. Si vous incluez la bonne extension (.pdf, .png, .webp, .jpg), PDFMonkey la retire et la ré-ajoute pour garder le nom propre. Si vous l’omettez, PDFMonkey l’ajoute automatiquement en fonction du format de sortie.

**Quels caractères sont autorisés dans le nom de fichier personnalisé ?**

PDFMonkey assainit le nom de fichier : les caractères accentués sont translittérés en ASCII, tout caractère qui n’est pas une lettre, un chiffre, un tiret, un underscore ou un espace est remplacé par un tiret, et les tirets consécutifs ou en début/fin de chaîne sont supprimés.


---

# Protéger les PDF générés par mot de passe

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/protection-par-mot-de-passe.md
Vous pouvez générer des PDF protégés par mot de passe en passant une clé `_password` dans les **métadonnées** du document. Le fichier généré est chiffré en AES-256 et nécessite le mot de passe pour être ouvert. Si vous omettez `_password`, les documents se génèrent sans chiffrement comme d'habitude.

## Définir le mot de passe via l'API

Incluez la clé `_password` dans l'objet `meta` lorsque vous [créez](https://pdfmonkey.io/fr/docs/api/documents.md#create-a-document) un document :

```bash
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H 'Authorization: Bearer YOUR_SECRET_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "document": {
      "document_template_id": "YOUR_TEMPLATE_ID",
      "status": "pending",
      "payload": { "name": "Jane Doe" },
      "meta": {
        "_password": "s3cur3-p@ss!"
      }
    }
  }'
```

Vous pouvez combiner `_password` avec d'autres clés meta comme [`_filename`](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) :

```json
{
  "meta": {
    "_filename": "contrat-jane-doe.pdf",
    "_password": "s3cur3-p@ss!"
  }
}
```

## Définir le mot de passe depuis le tableau de bord

1. Ouvrez un document dans l'éditeur de document.
2. Passez à l'onglet **Meta data**.
3. Saisissez la clé `_password` et le mot de passe souhaité :

```json
{
  "_password": "s3cur3-p@ss!"
}
```

4. Cliquez sur **Save**, puis sur **Generate**.

Pour un guide complet, consultez [Générer des documents depuis le tableau de bord](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md).

## Fonctionnement

Quand `_password` est présent dans le meta, PDFMonkey chiffre le PDF généré en **AES-256** après le rendu. Le destinataire a besoin du mot de passe exact pour ouvrir le document. Sans lui, le contenu reste inaccessible.

- **Tous les templates fonctionnent.** Éditeur Code, Builder, templates existants — la protection par mot de passe marche avec tout.
- **Aucune configuration nécessaire.** Pas besoin d'activer quoi que ce soit sur le template ou votre compte.
- **Compatible avec toutes les intégrations.** Zapier, Make, Workato, n8n, Bubble, Glide, API directe — partout où vous pouvez définir le champ `meta`.
- **Contrôle par document.** Un document peut être protégé pendant que le suivant ne l'est pas.
- **Disponible sur tous les plans.** Plan gratuit inclus.

## Questions fréquentes

**Que se passe-t-il si je ne définis pas de mot de passe ?**

Les documents se génèrent sans chiffrement, exactement comme avant. La protection par mot de passe est optionnelle.

**Puis-je utiliser des données dynamiques dans le mot de passe ?**

Pas directement dans la valeur `_password`. Cependant, dans la plupart des plateformes d'intégration (Zapier, Make, n8n), vous pouvez utiliser des champs dynamiques ou des expressions pour construire la chaîne du mot de passe avant de la transmettre à PDFMonkey.

**La protection par mot de passe fonctionne-t-elle avec les formats d'image ?**

Non. La protection par mot de passe s'applique uniquement à la sortie PDF. Les formats d'image (PNG, WebP, JPG) ne prennent pas en charge le chiffrement.

## Pages associées

- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) — une autre clé meta qui contrôle le comportement de la génération
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des paramètres `meta` et autres champs
- [Générer des PDF via l'API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — workflow complet de génération
- [Générer des documents depuis le tableau de bord](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md) — utilisation de l'onglet Métadonnées


## FAQ

**Comment protéger un PDF par mot de passe avec PDFMonkey ?**

Passez une clé "_password" dans le champ meta du document. Via l'API, incluez-la dans l'objet meta lors de la création d'un document : "meta": { "_password": "votre-mot-de-passe" }. Le PDF généré sera chiffré en AES-256 et nécessitera le mot de passe pour être ouvert.

**Quel chiffrement PDFMonkey utilise-t-il pour les PDF protégés ?**

PDFMonkey utilise le chiffrement AES-256. Le PDF est chiffré après la génération, et le destinataire a besoin du mot de passe exact que vous avez spécifié pour ouvrir le document.

**Est-ce que je peux générer des PDF sans mot de passe ?**

Oui. Si vous n'incluez pas le champ _password dans le meta, les PDF se génèrent exactement comme avant : pas de chiffrement, pas de mot de passe. La protection par mot de passe est entièrement optionnelle, document par document.


---

# Générer des images au lieu de PDF

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md
PDFMonkey génère des PDF par défaut, mais les modèles avec le type de sortie **Image** produisent des **images WebP, PNG ou JPG** à la place. Le flux API est identique ; seul le type de modèle et quelques options meta diffèrent.

## Créer un modèle image

Pour générer des images, vous avez besoin d’un modèle configuré pour la sortie image. Sélectionnez **Image** comme type de sortie lors de la création de votre modèle :

> [!TIP]
> **Astuce**
>
> Vous pouvez également dupliquer un modèle existant et changer son type de sortie en **Image**.


> [!NOTE]
> **Pourquoi des types de modèles distincts ?**
>
> Les PDF et les images ont des capacités fondamentalement différentes. Les documents PDF prennent en charge les en-têtes, pieds de page et différents formats de papier. Les modèles images prennent en charge les arrière-plans transparents et des dimensions en pixels à la place.


Une fois le modèle créé, ouvrez ses paramètres pour configurer :

- **Largeur et hauteur** : en pixels (500 x 500 par défaut)
- **Arrière-plan transparent** : pris en charge par WebP et PNG

## Générer une image via l’API

Générez une image de la même manière que vous générez un PDF : envoyez une requête `POST` à `/api/v1/documents` (ou `/api/v1/documents/sync` pour la [génération synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation)). Tant que le `document_template_id` pointe vers un modèle image, PDFMonkey produit une image au lieu d’un PDF.

```bash
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H 'Authorization: Bearer YOUR_SECRET_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "document": {
      "document_template_id": "YOUR_IMAGE_TEMPLATE_ID",
      "status": "pending",
      "payload": { "title": "Hello World" }
    }
  }'
```

Par défaut, une image **WebP** est créée. Le WebP offre une bonne qualité pour une taille de fichier raisonnable et prend en charge les arrière-plans transparents.

## Options meta à la génération

Vous pouvez remplacer les valeurs par défaut du modèle à la génération en passant des clés spéciales dans le champ `meta` du document. Ces options ne s’appliquent qu’aux modèles images ; elles sont ignorées pour les modèles PDF.

| Clé | Type | Description | Défaut |
|:---|:---|:---|:---|
| `_type` | string | Format d’image : `webp`, `png` ou `jpg` | `webp` |
| `_width` | integer | Largeur de l’image en pixels | Paramètre du modèle (500) |
| `_height` | integer | Hauteur de l’image en pixels | Paramètre du modèle (500) |
| `_quality` | integer | Qualité de compression de 1 à 100 (WebP uniquement) | `100` |

```json5 title="Corps de la requête avec options meta"
{
  "document": {
    "document_template_id": "YOUR_IMAGE_TEMPLATE_ID",
    "payload": { "title": "Hello World" },
    "status": "pending",
    "meta": {
      "_type": "png",
      "_width": 1200,
      "_height": 630
    }
  }
}
```

> [!WARNING]
> L’option `_quality` ne s’applique qu’aux images WebP. Le PNG est toujours sans perte, et le JPG utilise un réglage de qualité fixe.


> [!TIP]
> Pour les cartes de réseaux sociaux et les images Open Graph, `1200x630` est la taille la plus couramment recommandée. Passez `&#34;_type&#34;: &#34;png&#34;` pour une compatibilité maximale.


## Arrière-plans transparents

La transparence est contrôlée dans les **paramètres du modèle**, pas à la génération. Activez-la lorsque vous avez besoin d’images sans arrière-plan (utile pour les logos, filigranes et éléments superposés).

Les arrière-plans transparents sont pris en charge par **WebP** et **PNG**. Le JPG ne prend pas en charge la transparence : les zones transparentes sont rendues en blanc.

## Noms de fichiers personnalisés pour les images

La clé meta `_filename` fonctionne de la même manière pour les images que pour les PDF (voir [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md)). PDFMonkey ajoute automatiquement la bonne extension (`.webp`, `.png` ou `.jpg`) :

```json
{
  "meta": {
    "_filename": "social-card-march",
    "_type": "png"
  }
}
```

Cela produit un fichier nommé `social-card-march.png`.

## Questions fréquentes

**Que se passe-t-il si j’utilise les options meta image sur un modèle PDF ?**

Elles sont ignorées. Les clés meta `_type`, `_width`, `_height` et `_quality` n’affectent que les modèles images.

**Peut-on changer le format de sortie d’un modèle existant ?**

Oui. Ouvrez les paramètres du modèle dans le Dashboard et changez le type de sortie. Les documents existants générés à partir du modèle ne sont pas affectés ; seuls les nouveaux documents utilisent le paramètre mis à jour.

**Y a-t-il une taille d’image maximale ?**

Il n’y a pas de limite stricte en pixels, mais les images très grandes (au-delà de 4000 x 4000 px) augmentent le temps de génération et la consommation mémoire. Gardez des dimensions raisonnables pour votre cas d’usage.

**Les webhooks fonctionnent-ils avec la génération d’images ?**

Oui. Les [webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) se déclenchent sur `documents.generation.success` et `documents.generation.failure` quel que soit le type de sortie.

## Pages associées

- [Générer des PDF avec l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) : flux de génération de bout en bout
- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) : contrôler le nom du fichier généré
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) : documentation complète des paramètres `meta` et autres champs
- [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprendre le cycle de vie de la génération
- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) : comment récupérer le fichier généré


## FAQ

**PDFMonkey peut-il générer des images au lieu de PDF ?**

Oui. PDFMonkey prend en charge la génération d’images WebP, PNG et JPG en plus des PDF. Créez un modèle avec le type de sortie Image, puis utilisez les mêmes endpoints API pour générer des images.

**Quel est le format d’image par défaut dans PDFMonkey ?**

Le WebP est le format par défaut pour les modèles images. Il offre une bonne qualité pour une taille de fichier réduite et prend en charge les arrière-plans transparents. Vous pouvez le modifier en passant _type: png ou _type: jpg dans les métadonnées du document.

**Comment définir les dimensions d’une image générée ?**

Définissez les dimensions par défaut dans les paramètres du modèle (largeur et hauteur en pixels, 500x500 par défaut). Vous pouvez les modifier à la génération en passant _width et _height dans les métadonnées du document.


---

# Liens de partage permanents pour les documents générés

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md
Chaque document généré avec succès sur un plan **Pro+** ou **Premium** inclut un champ `public_share_link` : une URL publique permanente qui n’expire jamais et ne nécessite aucune authentification. Utilisez-la pour partager des fichiers générés par email, les intégrer dans des pages web ou les distribuer à des destinataires externes.

```json title="Réponse pour un document généré avec succès (extrait)"
{
  "document": {
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "status": "success",
    "download_url": "https://pdfmonkey-production.s3.eu-west-1.amazonaws.com/...",
    "public_share_link": "https://files.pdfmonkey.io/share/72BE2293-D130-4C19-9E11-C82B5CEA8C37/invoice-2050-03.pdf"
  }
}
```

> [!WARNING]
> **Plans Pro&#43; et Premium uniquement**
>
> Les liens de partage ne sont disponibles que sur les plans Pro&#43; et Premium. Sur les autres plans, `public_share_link` retourne `null`. Consultez [Nos plans](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) pour un comparatif des fonctionnalités.


## Quand le lien de partage apparaît

Le champ `public_share_link` est renseigné lorsque **les deux conditions** suivantes sont réunies :

1. Le [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) du document est `success`.
2. Le compte est sur un plan **Pro+** ou **Premium**.

Pour tout autre statut (`draft`, `pending`, `generating`, `failure`) ou sur un plan inférieur, le champ retourne `null`.

## Format de l’URL

Les liens de partage suivent ce schéma :

```
https://files.pdfmonkey.io/share/{share_token}/{filename}
```

- **`share_token`** est un UUID attribué à chaque document lors de sa création. Il ne change pas.
- **`filename`** est le nom du fichier du document, extension comprise (`.pdf`, `.png`, `.webp` ou `.jpg`). Si vous définissez un [nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md), il apparaît ici.

## Affichage en ligne ou téléchargement

Par défaut, un lien de partage déclenche un **téléchargement du fichier**. Pour afficher le fichier directement dans le navigateur, ajoutez le paramètre `disposition` :

```
https://files.pdfmonkey.io/share/{share_token}/{filename}?disposition=inline
```

| Valeur | Comportement |
|:-------|:-------------|
| `attachment` (par défaut) | Le navigateur télécharge le fichier |
| `inline` | Le navigateur affiche le fichier (les PDF s’ouvrent dans la visionneuse intégrée ; les images s’affichent directement) |

> [!TIP]
> Utilisez `?disposition=inline` lorsque vous intégrez des liens de partage dans des pages web et souhaitez que l’utilisateur visualise le document avant de le télécharger.


## Liens de partage vs URL de téléchargement

| | `public_share_link` | `download_url` |
|:---|:---|:---|
| **Expiration** | N’expire jamais | Expire après 1 heure |
| **Authentification** | Aucune requise | Aucune requise |
| **Disponibilité** | Plans Pro+ et Premium uniquement | Tous les plans |
| **Affichage en ligne** | Via `?disposition=inline` | Non (téléchargement systématique) |
| **Quand renseigné** | Statut `success` sur un plan éligible | Statut `success` |

Si vous avez besoin d’une URL valide indéfiniment, utilisez `public_share_link`. Si vous n’avez besoin que d’un lien de téléchargement éphémère (par exemple, pour enregistrer le fichier sur votre propre stockage juste après la génération), `download_url` suffit. Consultez [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour plus de détails.

## Changement de plan et liens de partage

Les liens de partage sont liés au plan de votre compte, pas aux documents individuels :

- **Passage à un plan Pro+ ou Premium :** tous les documents générés avec succès par le passé obtiennent rétroactivement un lien de partage fonctionnel. Aucune régénération n’est nécessaire.
- **Passage à un plan inférieur au Pro+ :** les liens de partage existants cessent de fonctionner immédiatement. Le champ `public_share_link` retourne `null` dans les réponses de l’API. De plus, les documents qui dépassent la [durée de rétention](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) du nouveau plan sont définitivement supprimés.
- **Remise à niveau ultérieure :** les liens de partage se réactivent automatiquement pour les documents encore existants. En revanche, les documents supprimés durant le passage à un plan inférieur en raison d’une rétention plus courte sont perdus définitivement et ne peuvent pas être récupérés.

Consultez [Changer de plan](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) pour plus de détails sur l’impact des changements de plan.

## Fonctionne aussi avec les images

Les liens de partage fonctionnent pour tous les [formats de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md), pas seulement les PDF. Si votre template produit une image WebP, PNG ou JPG, le lien de partage pointe vers le fichier image avec l’extension correspondante.

## Questions fréquentes

**Pourquoi `public_share_link` est-il `null` alors que mon document est en `success` ?**

Votre compte est probablement sur un plan qui n’inclut pas les liens de partage (Free, Starter ou Pro). Passez au plan Pro+ ou Premium pour activer cette fonctionnalité. Consultez [Nos plans](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md).

**Peut-on révoquer un lien de partage pour un document spécifique ?**

La suppression du document retire définitivement le lien de partage. Il n’existe pas de moyen de désactiver un lien de partage sans supprimer le document.

**Les liens de partage survivent-ils à la suppression du document ?**

Non. Une fois le document [supprimé](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) (manuellement ou via le TTL), le lien de partage retourne une erreur 404.

**Le lien de partage est-il inclus dans les payloads des webhooks ?**

Oui. Le champ `public_share_link` fait partie du payload du document envoyé à votre [endpoint de webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) lors d’une génération réussie.

## Pages liées

- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — liens temporaires signés et comparaison avec les liens de partage
- [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — quand `public_share_link` devient disponible
- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) — contrôler le nom de fichier dans le lien de partage
- [Suppression automatique (TTL)](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) — impact de la suppression sur les liens de partage
- [Nos plans](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) — quels plans incluent les liens de partage
- [Changer de plan](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) — que deviennent les liens de partage lors d’un changement de plan
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des champs, dont `public_share_link`


## FAQ

**Qu’est-ce qu’un lien de partage PDFMonkey ?**

Un lien de partage est une URL publique permanente pour un document généré. Il n’expire jamais, ne nécessite aucune authentification et peut être intégré dans des emails, des pages web ou partagé directement. Disponible sur les plans Pro+ et Premium.

**Quelle différence entre un lien de partage et une URL de téléchargement ?**

Les URL de téléchargement sont temporaires (1 heure) et déclenchent toujours un téléchargement. Les liens de partage sont permanents. Par défaut, ils déclenchent un téléchargement, mais vous pouvez ajouter ?disposition=inline pour afficher le fichier dans le navigateur.

**Les liens de partage fonctionnent-ils encore si je passe à un plan inférieur ?**

Non. Les liens de partage cessent de fonctionner lors d’un passage à un plan inférieur au Pro+. Les documents qui dépassent la durée de rétention du nouveau plan sont définitivement supprimés. Si vous repassez sur un plan éligible, les liens de partage se réactivent pour les documents encore existants.


---

# Rétention des documents et suppression automatique (TTL)

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md
Chaque document généré est stocké sur les serveurs de PDFMonkey jusqu’à son expiration ou sa suppression. Vous contrôlez la durée de vie des documents en définissant un **TTL (Time To Live)** sur chaque modèle. Lorsque le TTL d’un document expire, PDFMonkey le supprime automatiquement ainsi que son fichier généré.

## Fonctionnement du TTL

Le TTL est un paramètre par modèle exprimé en secondes. Lorsqu’un document termine sa génération avec succès, PDFMonkey calcule son heure d’expiration en ajoutant le TTL au timestamp de génération. Une tâche de fond s’exécute chaque minute pour supprimer tous les documents dont l’expiration est passée.

Le décompte commence lorsque le document atteint le [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) `success`, et non lorsqu’il est créé ou mis en file d’attente.

> [!NOTE]
> **La suppression peut prendre jusqu’à une minute**
>
> La tâche de suppression automatique s’exécute chaque minute. En pratique, un document peut persister jusqu’à une minute après son heure d’expiration.


## Configurer le TTL dans le tableau de bord

Ouvrez l’onglet **Settings** de votre modèle et repérez le menu déroulant **Deletion**. Sélectionnez la durée de rétention qui correspond à vos besoins :

![Le menu déroulant Deletion dans les paramètres du modèle, avec des options de 5 minutes à 1 semaine, plus Jamais](https://pdfmonkey.io/fr/docs/img/auto-deletion-settings.webp)

Les options disponibles dépendent de votre [forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md). Si vous sélectionnez une valeur non prise en charge par votre forfait, PDFMonkey la plafonne au maximum autorisé.

## Valeurs TTL disponibles par forfait

| Option TTL | Secondes | Free | Starter | Pro | Pro+ | Premium |
|:-----------|--------:|:----:|:-------:|:---:|:----:|:-------:|
| 5 minutes | 300 | Oui | Oui | Oui | Oui | Oui |
| 20 minutes | 1 200 | Oui | Oui | Oui | Oui | Oui |
| 1 heure | 3 600 | Oui | Oui | Oui | Oui | Oui |
| 1 jour | 86 400 | Oui | Oui | Oui | Oui | Oui |
| 1 semaine | 604 800 | Non | Non | Oui | Oui | Oui |
| 1 mois | 2 592 000 | Non | Non | Non | Oui | Oui |
| 1 an | 31 536 000 | Non | Non | Non | Oui | Oui |
| Jamais (illimité) | 0 | Non | Non | Non | Oui | Oui |

> [!WARNING]
> **Limites par forfait**
>
> Chaque forfait a un TTL maximum. Si vous définissez un TTL supérieur à ce que votre forfait autorise (par exemple, « 1 semaine » sur un forfait Starter), PDFMonkey utilise automatiquement la valeur la plus élevée disponible.


## Définir le TTL via l’API

Lors de la création ou de la mise à jour d’un modèle via l’[API Templates](https://pdfmonkey.io/fr/docs/api/templates.md), incluez le champ `ttl` avec une valeur en secondes :

```json title="Définir le TTL lors de la création d'un modèle"
{
  "document_template": {
    "identifier": "invoice-template",
    "ttl": 3600
  }
}
```

Le même plafonnement par forfait s’applique : si vous demandez un TTL qui dépasse le maximum de votre forfait, l’API utilise silencieusement la valeur la plus élevée autorisée au lieu de renvoyer une erreur.

## Ce qui est supprimé

Lorsqu’un document est supprimé (que ce soit par expiration du TTL, suppression manuelle dans le tableau de bord ou via un [appel API](https://pdfmonkey.io/fr/docs/api/documents.md#delete-a-document)), PDFMonkey supprime :

- **Le fichier généré** (PDF, PNG, WebP ou JPG) du stockage
- **Le payload** (les données dynamiques envoyées pour générer le document)
- **Les données meta** associées au document

Le document n’apparaît plus dans les réponses de l’API ni dans le tableau de bord. Tout [lien de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) pointant vers le document renvoie une erreur 404.

> [!CAUTION]
> **La suppression est définitive**
>
> Il n’existe aucun moyen de récupérer un document supprimé, son fichier généré ou son payload. Si vous devez conserver des fichiers à long terme, téléchargez-les vers votre propre stockage avant l’expiration du TTL. Consultez [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour plus de détails.


## Changements de forfait et rétention

Lorsque vous changez de forfait, PDFMonkey ajuste les paramètres TTL pour correspondre aux limites du nouveau forfait :

- **Passage à un forfait supérieur :** les modèles conservent leur TTL actuel. Si vous aviez défini un TTL inférieur en raison de restrictions de forfait, vous pouvez désormais l’augmenter jusqu’au maximum de votre nouveau forfait.
- **Passage à un forfait inférieur :** tout modèle dont le TTL dépasse le maximum du nouveau forfait est automatiquement plafonné. Les documents existants de ces modèles voient leurs dates d’expiration recalculées, ce qui peut entraîner une expiration plus rapide que prévu initialement.

Consultez [Changer de forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) pour un aperçu plus large de l’impact des changements de forfait sur votre compte.

## Suppression manuelle

Si vous préférez supprimer des documents selon votre propre calendrier plutôt que de compter sur le TTL, vous avez deux options :

1. **Tableau de bord :** ouvrez le document et cliquez sur le bouton de suppression.
2. **API :** envoyez une requête `DELETE` à `/api/v1/documents/:id`. Consultez la [référence API](https://pdfmonkey.io/fr/docs/api/documents.md#delete-a-document) pour plus de détails.

La suppression manuelle retire les mêmes données que la suppression automatique par TTL.

## Questions fréquentes

**Pourquoi mon document a-t-il été supprimé avant le TTL que j’avais défini ?**

Si vous avez récemment rétrogradé votre forfait, PDFMonkey a peut-être recalculé les dates d’expiration des documents existants. Un modèle configuré sur « 1 semaine » avec un forfait Pro rétrogradé en Starter (maximum 1 jour) voit le TTL de ses documents raccourci en conséquence.

**Puis-je définir des valeurs TTL différentes pour différents modèles ?**

Oui. Le TTL est un paramètre par modèle. Chaque modèle de votre compte peut avoir sa propre durée de rétention, dans les limites de votre forfait.

**Le TTL s’applique-t-il aux documents en échec ?**

Non. Seuls les documents avec un [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) `success` reçoivent une date d’expiration. Les documents en échec ne sont pas supprimés automatiquement par le système TTL.

**Existe-t-il une API pour vérifier quand un document expire ?**

L’objet document n’expose pas directement le champ `expires_at`. Cependant, vous pouvez le calculer à partir de la valeur `ttl` du modèle et du timestamp `updated_at` du document.

## Pages liées

- [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre quand les documents deviennent éligibles à la suppression automatique
- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — sauvegarder vos fichiers avant leur expiration
- [Liens de partage permanents](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) — impact de la suppression sur les liens de partage
- [Nos forfaits](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) — limites de rétention par forfait en un coup d’œil
- [Changer de forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) — impact des changements de forfait sur les paramètres TTL
- [Stockage des données et rétention](https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md) — aperçu général de ce que PDFMonkey stocke
- [API : Templates](https://pdfmonkey.io/fr/docs/api/templates.md) — définir le TTL lors de la création ou mise à jour d’un modèle
- [API : Documents](https://pdfmonkey.io/fr/docs/api/documents.md#delete-a-document) — supprimer des documents par programmation


## FAQ

**Combien de temps PDFMonkey conserve-t-il mes documents générés ?**

Cela dépend de votre forfait et du réglage TTL. Les forfaits Free et Starter conservent les documents jusqu’à 1 jour. Le forfait Pro permet jusqu’à 7 jours. Les forfaits Pro+ et Premium offrent une rétention illimitée. Dans ces limites, vous définissez le TTL exact par modèle.

**Quelles données sont supprimées à l’expiration d’un document ?**

Lorsqu’un document est supprimé (manuellement ou via TTL), PDFMonkey supprime le fichier généré du stockage et efface les données payload et meta. Le document n’apparaît plus dans l’API ni dans le tableau de bord.

**Puis-je supprimer des documents manuellement au lieu d’utiliser le TTL ?**

Oui. Vous pouvez supprimer des documents depuis le tableau de bord PDFMonkey ou en appelant l’endpoint DELETE /api/v1/documents/:id. La suppression manuelle retire les mêmes données que la suppression automatique par TTL.

**Que se passe-t-il pour mes paramètres TTL si je rétrograde mon forfait ?**

Lors d’une rétrogradation, tout modèle dont le TTL dépasse le maximum du nouveau forfait est automatiquement plafonné à ce maximum. Les dates d’expiration des documents existants de ces modèles sont recalculées en conséquence.


---

# Webhooks : notifications de génération de documents en temps réel

Source: https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md
Les webhooks vous permettent de recevoir une notification HTTP dès qu’un document est généré, pour réagir immédiatement sans interroger l’API en boucle. PDFMonkey utilise [Svix](https://www.svix.com/) pour envoyer les webhooks avec des tentatives automatiques et la vérification des signatures.

Cette page couvre les [types d’événements](#event-types), le [format du payload](#webhook-payload), la [configuration du routage](#set-up-a-workspace-wide-webhook) (par workspace, par modèle ou par channel personnalisé) et la [vérification des signatures](#verify-webhook-signatures).

## Types d’événements {#event-types}

PDFMonkey déclenche deux types d’événements webhook :

| Événement | Quand il se déclenche |
|:----------|:----------------------|
| `documents.generation.success` | Un document a été généré avec succès. Le champ `download_url` est disponible. |
| `documents.generation.failure` | La génération d’un document a échoué. Le champ `failure_cause` décrit l’erreur. |

Abonnez-vous à l’un ou aux deux selon vos besoins. La plupart des intégrations s’abonnent au minimum à `documents.generation.success`.

## Payload du webhook {#webhook-payload}

Chaque webhook envoie un objet [DocumentCard](https://pdfmonkey.io/fr/docs/api/documents.md#the-documentcard-object) encapsulé dans une clé `document` :

```json title="Payload du webhook"
{
  "document": {
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
    "created_at": "2050-03-13T12:34:56.181+02:00",
    "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
    "document_template_identifier": "My Invoice Template",
    "download_url": "https://pdfmonkey.s3.eu-west-1.amazonaws.com/...",
    "failure_cause": null,
    "filename": "2050-03-14 Peter Parker.pdf",
    "meta": {
      "_filename": "2050-03-14 Peter Parker.pdf",
      "clientRef": "spidey-616"
    },
    "output_type": "pdf",
    "preview_url": "https://preview.pdfmonkey.io/...",
    "public_share_link": null,
    "status": "success",
    "updated_at": "2050-03-13T12:34:59.412+02:00"
  }
}
```

> [!NOTE]
> **DocumentCard, pas Document**
>
> Le payload du webhook est un **DocumentCard**, pas un Document complet. Il ne contient pas les champs `payload` (données dynamiques), `generation_logs` ni `checksum`. Si vous devez transmettre des données à votre gestionnaire de webhooks, utilisez le champ `meta` lors de la création du document. Consultez [l’objet DocumentCard](https://pdfmonkey.io/fr/docs/api/documents.md#the-documentcard-object) pour la référence complète des attributs.


## Définir un webhook pour tout le workspace {#set-up-a-workspace-wide-webhook}

Pour recevoir des notifications pour chaque document généré dans un workspace :

1. Cliquez sur le lien **Webhooks** dans la navigation principale.
2. Cliquez sur le bouton **+ Add Endpoint**.
3. Saisissez l’URL de votre endpoint.
4. Sélectionnez le(s) type(s) d’événement souhaité(s) (`documents.generation.success`, `documents.generation.failure` ou les deux).

Votre endpoint est désormais appelé chaque fois qu’un document du workspace est généré.

## Définir un webhook spécifique à un modèle {#set-up-a-template-specific-webhook}

Dans de nombreux cas (notamment avec les plateformes no-code comme [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [Make](https://pdfmonkey.io/fr/docs/integrations/make.md) ou [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md)), vous aurez besoin d’un webhook qui ne se déclenche que pour un modèle précis.

1. Copiez l’**identifiant** du modèle que vous souhaitez cibler.
2. Cliquez sur le lien **Webhooks** dans la navigation principale.
3. Cliquez sur le bouton **+ Add Endpoint**.
4. Saisissez l’URL de votre endpoint et sélectionnez le(s) type(s) d’événement.
5. Dans le champ **channels**, ajoutez `template-VOTRE_ID_DE_MODELE`.

``` title="Exemple de channel"
template-07C63E0B-620F-44A9-AF9F-4CA0DA025A0A
```

Votre endpoint est désormais appelé uniquement lorsqu’un document est généré à partir de ce modèle.

> [!WARNING]
> **Les channels sont sensibles à la casse**
>
> Lorsque vous ajoutez un identifiant de modèle ou de dossier dans la liste des channels, collez-le toujours en **majuscules**. Un identifiant en minuscules ne sera pas reconnu et votre endpoint ne sera jamais appelé.


### Cibler plusieurs modèles ou un dossier

Si vous avez besoin du même endpoint webhook pour plusieurs modèles (mais pas tous), vous pouvez ajouter jusqu’à **3 channels** à un seul endpoint.

Si 3 channels ne suffisent pas, regroupez les modèles dans un dossier et utilisez l’identifiant du dossier comme channel. Ainsi, tout modèle de ce dossier déclenchera le webhook.

Suivez les mêmes étapes que ci-dessus, mais ajoutez `folder-VOTRE_ID_DE_DOSSIER` dans la liste des channels :

``` title="Exemple de channel"
folder-440DA20B-C5A0-A0A9-C62F-4070FAF963EA
```

### Channels personnalisés via meta

Vous pouvez router les webhooks dynamiquement pour chaque document en définissant la clé `_webhook_channel` dans le champ `meta` du document. Cela ajoute un channel supplémentaire à la notification webhook de ce document.

```json title="Définir un channel webhook personnalisé via l'API"
{
  "document": {
    "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
    "payload": "{}",
    "status": "pending",
    "meta": "{\"_webhook_channel\": \"order-42\"}"
  }
}
```

Configurez ensuite un endpoint webhook avec `order-42` comme channel. Seuls les documents incluant cette valeur dans leur `meta` déclencheront cet endpoint.

> [!TIP]
> **Combinaison avec les channels de modèle**
>
> La notification webhook d’un document inclut toujours le channel de son modèle (et celui du dossier, le cas échéant) en plus de tout channel personnalisé défini dans `meta`. Un même événement webhook peut donc correspondre à plusieurs endpoints.


## Vérifier les signatures des webhooks {#verify-webhook-signatures}

Les webhooks étant des requêtes HTTP envoyées à une URL publique, un attaquant pourrait usurper l’identité de PDFMonkey en envoyant une fausse requête à votre endpoint. Pour éviter cela, Svix signe chaque webhook avec une clé secrète unique par endpoint.

Vous devez vérifier la signature de chaque webhook entrant avant de le traiter. Svix propose des bibliothèques pour les langages courants qui gèrent la vérification en quelques lignes de code.

Découvrez comment vérifier les signatures dans la [documentation de vérification de Svix](https://docs.svix.com/receiving/verifying-payloads/how).

> [!CAUTION]
> **Vérifiez toujours en production**
>
> Ignorer la vérification des signatures expose votre endpoint à des requêtes falsifiées. Vérifiez toujours la signature du webhook avant d’agir sur les données reçues.


## Questions fréquentes

**Les webhooks fonctionnent-ils avec la génération d’images ?**

Oui. Les webhooks se déclenchent pour tous les [formats de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) (PDF, PNG, JPG, WebP). Les types d’événements sont identiques quel que soit le format.

**Le `download_url` du payload est-il permanent ?**

Non. Le `download_url` est un lien signé temporaire valable 1 heure. Téléchargez le fichier dès réception du webhook, ou récupérez une URL fraîche ultérieurement via l’API. Consultez [l’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour plus de détails.

**Le webhook contient-il les données dynamiques (payload) d’origine ?**

Non. Le webhook envoie un [DocumentCard](https://pdfmonkey.io/fr/docs/api/documents.md#the-documentcard-object) qui ne contient pas le champ `payload`. Stockez les données nécessaires dans le champ `meta` lors de la création du document ; `meta` est inclus dans le webhook.

**Que se passe-t-il si mon endpoint est indisponible ?**

Svix retente automatiquement les envois échoués avec un backoff exponentiel sur plusieurs heures. Vous pouvez surveiller les tentatives et rejouer manuellement les messages échoués depuis la section **Webhooks** du tableau de bord PDFMonkey.

**Comment tester les webhooks en développement ?**

Utilisez un service de tunnel comme [ngrok](https://ngrok.com/) ou [localtunnel](https://theboringtech.io/localtunnel/) pour exposer votre serveur local sur Internet. Pointez votre endpoint webhook vers l’URL du tunnel, puis générez un document de test depuis le [tableau de bord](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md).

**Puis-je utiliser l’endpoint synchrone à la place des webhooks ?**

Oui. L’endpoint `/api/v1/documents/sync` attend la fin de la génération et retourne le résultat en une seule requête. C’est pratique pour le prototypage mais limité à 6 minutes. Pour la production, les webhooks sont plus fiables et scalables. Voir [Génération synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation).

## Pages associées

- [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprendre quand les webhooks se déclenchent dans le cycle de vie d’un document
- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) : fonctionnement des liens temporaires et comment les rafraîchir
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) : documentation complète des endpoints et des champs
- [L’objet DocumentCard](https://pdfmonkey.io/fr/docs/api/documents.md#the-documentcard-object) : référence complète des attributs du payload webhook
- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) : utiliser le champ `meta` pour définir des noms de fichiers et transmettre des données aux webhooks
- [Générer des documents via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) : workflow complet de génération asynchrone
- [Générer des documents via une intégration](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-une-integration.md) : utiliser les webhooks avec Zapier, Make ou n8n


## FAQ

**Quelles données PDFMonkey envoie-t-il dans un webhook ?**

PDFMonkey envoie un objet DocumentCard encapsulé dans une clé "document". Il contient l’identifiant du document, son statut, l’URL de téléchargement, le nom de fichier, les métadonnées (meta), le type de sortie, l’identifiant du modèle, etc. Le payload d’origine n’est pas inclus : utilisez le champ meta pour transmettre les données dont vous avez besoin.

**Comment vérifier qu’un webhook provient bien de PDFMonkey ?**

PDFMonkey utilise Svix pour envoyer les webhooks. Chaque webhook est signé avec une clé unique par endpoint. Vous pouvez vérifier la signature avec les bibliothèques officielles Svix pour Node.js, Python, Ruby, Go et d’autres langages.

**Peut-on recevoir des webhooks uniquement pour certains modèles ?**

Oui. Lors de la création d’un endpoint webhook, ajoutez un channel au format template-VOTRE_ID_DE_MODELE pour filtrer les notifications. Vous pouvez aussi utiliser folder-VOTRE_ID_DE_DOSSIER pour recevoir les webhooks de tous les modèles d’un dossier.

**PDFMonkey envoie-t-il des webhooks pour les documents en échec ?**

Oui. PDFMonkey déclenche deux types d’événements : documents.generation.success lorsqu’un document est généré avec succès, et documents.generation.failure en cas d’échec. Abonnez-vous aux deux pour gérer les erreurs dans votre intégration.

**Que se passe-t-il si mon endpoint webhook est indisponible ?**

Svix retente automatiquement les envois échoués avec un backoff exponentiel sur plusieurs heures. Vous pouvez surveiller les tentatives et rejouer manuellement les messages échoués depuis la section Webhooks du tableau de bord PDFMonkey.



---

# Authentification API

Source: https://pdfmonkey.io/fr/docs/api/authentication.mdChaque requête envoyée à l’API PDFMonkey doit inclure votre clé API secrète. Cette page explique comment trouver votre clé, l’envoyer avec vos requêtes et vérifier que l’authentification fonctionne.

## Trouver votre clé API secrète

Votre clé API secrète est disponible sur la page dédiée Clé API du Dashboard PDFMonkey, accessible directement depuis la barre latérale.

> [!WARNING]
> **Gardez votre clé secrète**
>
> Votre clé API secrète dispose des mêmes privilèges que votre compte. Ne la partagez pas publiquement et ne la versionnez pas dans votre dépôt de code. Si vous pensez que votre clé a été compromise, régénérez-la depuis la page Clé API.


## Envoyer votre clé avec les requêtes

Transmettez votre clé dans l’en-tête HTTP `Authorization`, préfixée par `Bearer` :

```http
Authorization: Bearer VOTRE_CLE_SECRETE
```

## Effectuer un appel API de test

Pour vérifier que l’authentification fonctionne, appelez l’endpoint `current_user` :

```http
GET https://api.pdfmonkey.io/api/v1/current_user
Authorization: Bearer VOTRE_CLE_SECRETE
```

Avec curl, la requête ressemble à ceci :

```bash
curl https://api.pdfmonkey.io/api/v1/current_user \
  -H "Authorization: Bearer VOTRE_CLE_SECRETE"
```

Une réponse réussie renvoie les informations de votre compte :

```json
{
  "current_user": {
    "id": "12345678-90ab-cdef-1234-567890abcdef",
    "auth_token": "1234567890ABCDEF1234",
    "available_documents": 300,
    "created_at": "2022-01-01T12:34:56.123+00:00",
    "current_plan": "free",
    "current_plan_interval": "month",
    "desired_name": "Marie Dupont",
    "email": "marie.dupont@example.com",
    "lang": "fr",
    "paying_customer": false,
    "trial_ends_on": "2022-01-15",
    "updated_at": "2022-01-01T12:34:56.123+00:00",
    "block_resources": true,
    "share_links": false
  }
}
```

### Erreurs d’authentification

Si la clé est manquante ou invalide, l’API renvoie une réponse `401 Unauthorized` :

```json
{
  "errors": [
    {
      "status": "401",
      "title": "Unauthorized",
      "detail": "We were unable to authenticate you based on the provided API key. Please verify that you provided the intended key."
    }
  ]
}
```

## Étapes suivantes

Maintenant que vous pouvez vous authentifier, vous pouvez :

- [Générer votre premier document](https://pdfmonkey.io/fr/docs/api/documents.md#create-a-document) avec l’API Documents
- [Générer un PDF via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) avec des exemples pas à pas dans plusieurs langages
- [Configurer les webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour être notifié lorsque vos documents sont prêts


## FAQ

**Comment s’authentifier avec l’API PDFMonkey ?**

Passez votre clé API secrète dans l’en-tête HTTP Authorization sous forme de token Bearer. Le format est : Authorization: Bearer VOTRE_CLÉ_SECRÈTE. Chaque requête à l’API PDFMonkey nécessite cet en-tête.

**Où trouver ma clé API PDFMonkey ?**

Votre clé API secrète est disponible sur la page Clé API du tableau de bord PDFMonkey, accessible directement depuis la barre latérale.

**Que faire si ma clé API PDFMonkey est compromise ?**

Régénérez-la immédiatement depuis la page Clé API du Dashboard. L’ancienne clé cessera de fonctionner et une nouvelle sera émise.


---

# API Documents : créer, lister et gérer les documents générés

Source: https://pdfmonkey.io/fr/docs/api/documents.mdRéférence complète de l’API pour créer, récupérer, mettre à jour et supprimer des documents dans PDFMonkey.

## Démarrage rapide {#quick-start}

La génération est asynchrone : vous créez un document, puis vous vérifiez son statut jusqu’à ce qu’il soit prêt.

```bash
# 1. Créer un document et le mettre en file d’attente pour génération
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H 'Authorization: Bearer YOUR_SECRET_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "document": {
      "document_template_id": "YOUR_TEMPLATE_ID",
      "status": "pending",
      "payload": { "name": "Jane Doe" }
    }
  }'
# Retourne un document avec "status": "pending" et "download_url": null

# 2. Vérifier le statut du document jusqu’à ce qu’il atteigne "success"
curl -H 'Authorization: Bearer YOUR_SECRET_KEY' \
  https://api.pdfmonkey.io/api/v1/document_cards/DOCUMENT_ID
# Lorsque le statut est "success", lire la download_url dans la réponse
```

Passer `"status": "pending"` met le document en file d’attente pour une génération immédiate. Le fichier n’est pas encore prêt à ce stade — vous devez interroger le document ou configurer un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour savoir quand il est terminé. Lorsque le statut atteint `success`, le champ `download_url` contient un lien signé vers le fichier généré.

Lisez la suite pour tous les détails, y compris l’[endpoint synchrone](#synchronous-generation) qui attend le résultat en une seule requête.

## Authentification {#authentication}

Toutes les requêtes nécessitent un token Bearer dans l’en-tête `Authorization` :

```
Authorization: Bearer YOUR_SECRET_KEY
```

Consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md) pour savoir comment trouver votre clé API et gérer vos tokens d’accès.

## Créer un document {#create-a-document}

**`POST /api/v1/documents`**

Crée un nouveau document. Passez `status` à `"pending"` pour lancer la génération immédiatement, ou omettez-le (valeur par défaut : `"draft"`) pour générer plus tard.

### Paramètres {#parameters}

Tous les paramètres sont imbriqués sous une clé `document`.

| Nom | Type | Requis | Description |
|:--- |:--- |:--- |:--- |
| `document_template_id` | String (UUID) | **Oui** | ID du modèle à utiliser pour la génération. |
| `payload` | Object ou String | Non | Les [données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) utilisées pour construire le document. Doit être un objet JSON (pas un tableau). Peut être transmis en tant qu’objet JSON ou chaîne JSON. |
| `meta` | Object ou String | Non | Métadonnées à attacher au document. Supporte des [clés spéciales](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) comme `_filename`. Doit être un objet JSON. 200 Ko maximum. |
| `status` | String | Non | `"draft"` (par défaut) ou `"pending"`. Passez à `"pending"` pour déclencher la génération à la création. |

> [!TIP]
> Passez `&#34;status&#34;: &#34;pending&#34;` dans votre requête de création pour générer le document en une seule étape. Sans cela, le document est créé en brouillon et vous devrez le [mettre à jour ultérieurement](#update-a-document) pour déclencher la génération.


### Requête {#request}








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/documents \
  -X POST \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  -H &#39;Content-Type: application/json&#39; \
  -d &#39;{
    &#34;document&#34;: {
      &#34;document_template_id&#34;: &#34;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#34;,
      &#34;status&#34;: &#34;pending&#34;,
      &#34;payload&#34;: {
        &#34;clientName&#34;: &#34;Peter Parker&#34;,
        &#34;orderDate&#34;: &#34;2050-03-14&#34;,
        &#34;products&#34;: [
          { &#34;name&#34;: &#34;Spider silk&#34;, &#34;quantity&#34;: 12, &#34;unitPrice&#34;: 123.50 },
          { &#34;name&#34;: &#34;Spandex fabric&#34;, &#34;quantity&#34;: 2, &#34;unitPrice&#34;: 28.90 }
        ]
      },
      &#34;meta&#34;: {
        &#34;_filename&#34;: &#34;2050-03-14 Peter Parker.pdf&#34;,
        &#34;clientRef&#34;: &#34;spidey-616&#34;
      }
    }
  }&#39;
```

**Ruby**

```ruby
document = Pdfmonkey::Document.generate(
  document_template_id: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
  payload: {
    clientName: &#39;Peter Parker&#39;,
    orderDate: &#39;2050-03-14&#39;,
    products: [
      { name: &#39;Spider silk&#39;, quantity: 12, unitPrice: 123.50 },
      { name: &#39;Spandex fabric&#39;, quantity: 2, unitPrice: 28.90 }
    ]
  },
  meta: {
    _filename: &#39;2050-03-14 Peter Parker.pdf&#39;,
    clientRef: &#39;spidey-616&#39;
  }
)

document.status # =&gt; &#39;pending&#39;
```

**Node.js**

```javascript
const response = await fetch(&#39;https://api.pdfmonkey.io/api/v1/documents&#39;, {
  method: &#39;POST&#39;,
  headers: {
    &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    &#39;Content-Type&#39;: &#39;application/json&#39;,
  },
  body: JSON.stringify({
    document: {
      document_template_id: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
      status: &#39;pending&#39;,
      payload: {
        clientName: &#39;Peter Parker&#39;,
        orderDate: &#39;2050-03-14&#39;,
        products: [
          { name: &#39;Spider silk&#39;, quantity: 12, unitPrice: 123.50 },
          { name: &#39;Spandex fabric&#39;, quantity: 2, unitPrice: 28.90 },
        ],
      },
      meta: {
        _filename: &#39;2050-03-14 Peter Parker.pdf&#39;,
        clientRef: &#39;spidey-616&#39;,
      },
    },
  }),
});

const data = await response.json();
console.log(data);
```

**Python**

```python
import requests

response = requests.post(
    &#39;https://api.pdfmonkey.io/api/v1/documents&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    json={
        &#39;document&#39;: {
            &#39;document_template_id&#39;: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
            &#39;status&#39;: &#39;pending&#39;,
            &#39;payload&#39;: {
                &#39;clientName&#39;: &#39;Peter Parker&#39;,
                &#39;orderDate&#39;: &#39;2050-03-14&#39;,
                &#39;products&#39;: [
                    {&#39;name&#39;: &#39;Spider silk&#39;, &#39;quantity&#39;: 12, &#39;unitPrice&#39;: 123.50},
                    {&#39;name&#39;: &#39;Spandex fabric&#39;, &#39;quantity&#39;: 2, &#39;unitPrice&#39;: 28.90},
                ],
            },
            &#39;meta&#39;: {
                &#39;_filename&#39;: &#39;2050-03-14 Peter Parker.pdf&#39;,
                &#39;clientRef&#39;: &#39;spidey-616&#39;,
            },
        },
    },
)

print(response.json())
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/documents&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_POST =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
        &#39;Content-Type: application/json&#39;,
    ],
    CURLOPT_POSTFIELDS =&gt; json_encode([
        &#39;document&#39; =&gt; [
            &#39;document_template_id&#39; =&gt; &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
            &#39;status&#39; =&gt; &#39;pending&#39;,
            &#39;payload&#39; =&gt; [
                &#39;clientName&#39; =&gt; &#39;Peter Parker&#39;,
                &#39;orderDate&#39; =&gt; &#39;2050-03-14&#39;,
                &#39;products&#39; =&gt; [
                    [&#39;name&#39; =&gt; &#39;Spider silk&#39;, &#39;quantity&#39; =&gt; 12, &#39;unitPrice&#39; =&gt; 123.50],
                    [&#39;name&#39; =&gt; &#39;Spandex fabric&#39;, &#39;quantity&#39; =&gt; 2, &#39;unitPrice&#39; =&gt; 28.90],
                ],
            ],
            &#39;meta&#39; =&gt; [
                &#39;_filename&#39; =&gt; &#39;2050-03-14 Peter Parker.pdf&#39;,
                &#39;clientRef&#39; =&gt; &#39;spidey-616&#39;,
            ],
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
```



### Réponse {#response}

```json title="201 Created"
{
  "document": {
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
    "checksum": "c230530f6f0aa32900af0924cf228e5c",
    "created_at": "2050-03-13T12:34:56.181+02:00",
    "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
    "download_url": null,
    "failure_cause": null,
    "filename": null,
    "generation_logs": [],
    "meta": {
      "_filename": "2050-03-14 Peter Parker.pdf",
      "clientRef": "spidey-616"
    },
    "output_type": "pdf",
    "payload": {
      "clientName": "Peter Parker",
      "orderDate": "2050-03-14",
      "products": [
        { "name": "Spider silk", "quantity": 12, "unitPrice": 123.50 },
        { "name": "Spandex fabric", "quantity": 2, "unitPrice": 28.90 }
      ]
    },
    "preview_url": "https://preview.pdfmonkey.io/pdf/web/viewer.html?file=...",
    "public_share_link": null,
    "status": "pending",
    "updated_at": "2050-03-13T12:34:56.181+02:00"
  }
}
```

### Erreurs de validation {#validation-errors}

Si des champs requis sont manquants ou invalides, l’API retourne une erreur `422 Unprocessable Entity` :

```json title="422 Unprocessable Entity"
{
  "errors": {
    "document_template_id": ["can’t be blank"]
  }
}
```

## Génération synchrone {#synchronous-generation}

**`POST /api/v1/documents/sync`**

Un raccourci qui crée un document et attend la fin de la génération côté serveur, pour obtenir le résultat en une seule requête. La réponse est un [DocumentCard](#the-documentcard-object) (pas un Document). Pour un guide pas-à-pas, consultez [Générer des documents avec l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md).

Cet endpoint accepte les mêmes paramètres que [Créer un document](#create-a-document). Vous devez passer `"status": "pending"` pour que la génération démarre.

### Quand utiliser sync vs async {#when-to-use-sync-vs-async}

| | Async | Sync |
|:--- |:--- |:--- |
| **Réponse** | Retourne immédiatement | Attend la fin de la génération |
| **Obtenir le résultat** | Polling ou [webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) | Inclus dans la réponse |
| **Objet retourné** | [Document](#the-document-object) | [DocumentCard](#the-documentcard-object) |
| **Adapté au volume** | Oui | Non — une requête ouverte par document |
| **Timeout** | Aucun | 6 minutes |
| **Idéal pour** | Pipelines de production, génération par lots | Faible volume ou cas d’usage interactifs |

> [!WARNING]
> L’endpoint sync attend jusqu’à 6 minutes la fin de la génération. Pour les pipelines de production ou la génération par lots, préférez la génération asynchrone avec les [webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md).


### Requête {#request-1}








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/documents/sync \
  -X POST \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  -H &#39;Content-Type: application/json&#39; \
  -d &#39;{
    &#34;document&#34;: {
      &#34;document_template_id&#34;: &#34;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#34;,
      &#34;status&#34;: &#34;pending&#34;,
      &#34;payload&#34;: {
        &#34;clientName&#34;: &#34;Peter Parker&#34;,
        &#34;orderDate&#34;: &#34;2050-03-14&#34;,
        &#34;products&#34;: [
          { &#34;name&#34;: &#34;Spider silk&#34;, &#34;quantity&#34;: 12, &#34;unitPrice&#34;: 123.50 },
          { &#34;name&#34;: &#34;Spandex fabric&#34;, &#34;quantity&#34;: 2, &#34;unitPrice&#34;: 28.90 }
        ]
      },
      &#34;meta&#34;: {
        &#34;_filename&#34;: &#34;2050-03-14 Peter Parker.pdf&#34;,
        &#34;clientRef&#34;: &#34;spidey-616&#34;
      }
    }
  }&#39;
```

**Ruby**

```ruby
document = Pdfmonkey::Document.generate!(
  document_template_id: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
  payload: {
    clientName: &#39;Peter Parker&#39;,
    orderDate: &#39;2050-03-14&#39;,
    products: [
      { name: &#39;Spider silk&#39;, quantity: 12, unitPrice: 123.50 },
      { name: &#39;Spandex fabric&#39;, quantity: 2, unitPrice: 28.90 }
    ]
  },
  meta: {
    _filename: &#39;2050-03-14 Peter Parker.pdf&#39;,
    clientRef: &#39;spidey-616&#39;
  }
)

document.status       # =&gt; &#39;success&#39;
document.download_url # =&gt; &#39;https://…&#39;
```

**Node.js**

```javascript
const response = await fetch(&#39;https://api.pdfmonkey.io/api/v1/documents/sync&#39;, {
  method: &#39;POST&#39;,
  headers: {
    &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    &#39;Content-Type&#39;: &#39;application/json&#39;,
  },
  body: JSON.stringify({
    document: {
      document_template_id: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
      status: &#39;pending&#39;,
      payload: {
        clientName: &#39;Peter Parker&#39;,
        orderDate: &#39;2050-03-14&#39;,
        products: [
          { name: &#39;Spider silk&#39;, quantity: 12, unitPrice: 123.50 },
          { name: &#39;Spandex fabric&#39;, quantity: 2, unitPrice: 28.90 },
        ],
      },
      meta: {
        _filename: &#39;2050-03-14 Peter Parker.pdf&#39;,
        clientRef: &#39;spidey-616&#39;,
      },
    },
  }),
});

const data = await response.json();
console.log(data.document_card.download_url);
```

**Python**

```python
import requests

response = requests.post(
    &#39;https://api.pdfmonkey.io/api/v1/documents/sync&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    json={
        &#39;document&#39;: {
            &#39;document_template_id&#39;: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
            &#39;status&#39;: &#39;pending&#39;,
            &#39;payload&#39;: {
                &#39;clientName&#39;: &#39;Peter Parker&#39;,
                &#39;orderDate&#39;: &#39;2050-03-14&#39;,
                &#39;products&#39;: [
                    {&#39;name&#39;: &#39;Spider silk&#39;, &#39;quantity&#39;: 12, &#39;unitPrice&#39;: 123.50},
                    {&#39;name&#39;: &#39;Spandex fabric&#39;, &#39;quantity&#39;: 2, &#39;unitPrice&#39;: 28.90},
                ],
            },
            &#39;meta&#39;: {
                &#39;_filename&#39;: &#39;2050-03-14 Peter Parker.pdf&#39;,
                &#39;clientRef&#39;: &#39;spidey-616&#39;,
            },
        },
    },
    timeout=400,
)

data = response.json()
print(data[&#39;document_card&#39;][&#39;download_url&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/documents/sync&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_POST =&gt; true,
    CURLOPT_TIMEOUT =&gt; 400,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
        &#39;Content-Type: application/json&#39;,
    ],
    CURLOPT_POSTFIELDS =&gt; json_encode([
        &#39;document&#39; =&gt; [
            &#39;document_template_id&#39; =&gt; &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
            &#39;status&#39; =&gt; &#39;pending&#39;,
            &#39;payload&#39; =&gt; [
                &#39;clientName&#39; =&gt; &#39;Peter Parker&#39;,
                &#39;orderDate&#39; =&gt; &#39;2050-03-14&#39;,
                &#39;products&#39; =&gt; [
                    [&#39;name&#39; =&gt; &#39;Spider silk&#39;, &#39;quantity&#39; =&gt; 12, &#39;unitPrice&#39; =&gt; 123.50],
                    [&#39;name&#39; =&gt; &#39;Spandex fabric&#39;, &#39;quantity&#39; =&gt; 2, &#39;unitPrice&#39; =&gt; 28.90],
                ],
            ],
            &#39;meta&#39; =&gt; [
                &#39;_filename&#39; =&gt; &#39;2050-03-14 Peter Parker.pdf&#39;,
                &#39;clientRef&#39; =&gt; &#39;spidey-616&#39;,
            ],
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
echo $data[&#39;document_card&#39;][&#39;download_url&#39;];
```



### Réponse {#response-1}

> [!NOTE]
> L’endpoint sync retourne un **DocumentCard**, pas un Document. Le résultat est imbriqué sous `document_card` et n’inclut ni `payload` ni `generation_logs`.


```json title="200 OK"
{
  "document_card": {
    "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
    "created_at": "2050-03-13T12:34:56.181+02:00",
    "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
    "document_template_identifier": "My Invoice Template",
    "download_url": "https://pdfmonkey.s3.eu-west-1.amazonaws.com/production/backend/document/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c/2050-03-14-peter-parker.pdf?X-Amz-Algorithm=AWS4-HMAC-SHA256&...",
    "failure_cause": null,
    "filename": "2050-03-14 Peter Parker.pdf",
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "meta": {
      "_filename": "2050-03-14 Peter Parker.pdf",
      "clientRef": "spidey-616"
    },
    "output_type": "pdf",
    "preview_url": "https://preview.pdfmonkey.io/pdf/web/viewer.html?file=...",
    "public_share_link": null,
    "status": "success",
    "updated_at": "2050-03-13T12:34:59.412+02:00"
  }
}
```

## L’objet Document {#the-document-object}

L’objet Document est la représentation complète d’un document généré, incluant son payload et ses logs de génération.

```json title="Document"
{
  "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
  "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
  "checksum": "c230530f6f0aa32900af0924cf228e5c",
  "created_at": "2050-03-13T12:34:56.181+02:00",
  "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
  "download_url": "https://pdfmonkey.s3.eu-west-1.amazonaws.com/production/backend/document/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c/2050-03-14-peter-parker.pdf?X-Amz-Algorithm=AWS4-HMAC-SHA256&...",
  "failure_cause": null,
  "filename": "2050-03-14 Peter Parker.pdf",
  "generation_logs": [
    {
      "type": "info",
      "message": "Starting PDF generation.",
      "timestamp": "Thu, 13 Mar 2050 10:34:57 GMT"
    },
    {
      "type": "info",
      "message": "Generation took 1617ms to load and render.",
      "timestamp": "Thu, 13 Mar 2050 10:34:58 GMT"
    },
    {
      "type": "info",
      "message": "Content size is 96302.",
      "timestamp": "Thu, 13 Mar 2050 10:34:59 GMT"
    }
  ],
  "meta": {
    "_filename": "2050-03-14 Peter Parker.pdf",
    "clientRef": "spidey-616"
  },
  "output_type": "pdf",
  "payload": {
    "clientName": "Peter Parker",
    "orderDate": "2050-03-14",
    "products": [
      { "name": "Spider silk", "quantity": 12, "unitPrice": 123.50 },
      { "name": "Spandex fabric", "quantity": 2, "unitPrice": 28.90 }
    ]
  },
  "preview_url": "https://preview.pdfmonkey.io/pdf/web/viewer.html?file=...",
  "public_share_link": "https://files.pdfmonkey.io/share/72BE2293-D130-4C19-9E11-C82B5CEA8C37/2050-03-14-peter-parker.pdf",
  "status": "success",
  "updated_at": "2050-03-13T12:34:59.412+02:00"
}
```

### Attributs {#attributes}

| Nom | Type | Description |
|:--- |:--- |:--- |
| `id` | String (UUID) | Identifiant unique du document. |
| `app_id` | String (UUID) | Identifiant unique du workspace du document. |
| `checksum` | String | Checksum interne utilisé pour le rendu de l’aperçu. |
| `created_at` | String (ISO 8601) | Date de création du document. |
| `document_template_id` | String (UUID) | ID du modèle utilisé pour générer ce document. |
| `download_url` | String (URL) ou `null` | URL signée temporaire pour télécharger le fichier généré. `null` tant que la génération n’a pas réussi. Valide pendant **1 heure** (voir [URLs de téléchargement](#download-urls)). |
| `failure_cause` | String ou `null` | Raison de l’échec de la génération. `null` sauf si le statut est `failure`. |
| `filename` | String ou `null` | Nom du fichier généré. `null` tant que la génération n’a pas réussi. Configurable via la clé meta `_filename`. |
| `generation_logs` | Array | Logs collectés pendant la génération. Chaque entrée contient `type` (`"info"` ou `"error"`), `message` et `timestamp`. Tableau vide avant le début de la génération. |
| `meta` | Object ou `null` | Métadonnées arbitraires attachées au document. Supporte des [clés spéciales](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) comme `_filename`. Également accessible dans les intégrations no-code (Zapier, Make) où `payload` n’est pas disponible. |
| `output_type` | String | Format de sortie : `"pdf"` ou `"image"`. Hérité du modèle. |
| `payload` | Object ou `null` | Les [données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) utilisées pour générer le document. |
| `preview_url` | String (URL) | URL pour intégrer un aperçu visuel du document. Destinée à être utilisée dans une `<iframe>`, **pas** pour le téléchargement. |
| `public_share_link` | String (URL) ou `null` | Lien public permanent vers le fichier généré. Disponible uniquement lorsque la fonctionnalité [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) est activée (offres Pro+). |
| `status` | String | Statut actuel du document : `draft`, `pending`, `generating`, `success` ou `failure`. Voir [Statuts des documents et cycle de vie](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md). |
| `updated_at` | String (ISO 8601) | Date de dernière mise à jour du document. |

## L’objet DocumentCard {#the-documentcard-object}

Le DocumentCard est une version allégée du Document. Il contient les mêmes champs **sauf** `payload`, `generation_logs` et `checksum`. Il ajoute également `document_template_identifier`.

Utilisez les DocumentCards lorsque vous n’avez pas besoin du payload complet ; ils sont plus rapides et plus légers. Ce sont les objets retournés par les endpoints de liste, l’endpoint sync, les webhooks et les intégrations no-code.

> [!TIP]
> **Préférez DocumentCard à Document.**
>
> Stockez les données dont vous aurez besoin plus tard dans `meta` plutôt que (ou en plus de) `payload`. Ainsi, vous n’aurez jamais besoin de récupérer l’objet Document complet.


```json title="DocumentCard"
{
  "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
  "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
  "created_at": "2050-03-13T12:34:56.181+02:00",
  "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
  "document_template_identifier": "My Invoice Template",
  "download_url": "https://pdfmonkey.s3.eu-west-1.amazonaws.com/production/backend/document/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c/2050-03-14-peter-parker.pdf?X-Amz-Algorithm=AWS4-HMAC-SHA256&...",
  "failure_cause": null,
  "filename": "2050-03-14 Peter Parker.pdf",
  "meta": {
    "_filename": "2050-03-14 Peter Parker.pdf",
    "clientRef": "spidey-616"
  },
  "output_type": "pdf",
  "preview_url": "https://preview.pdfmonkey.io/pdf/web/viewer.html?file=...",
  "public_share_link": "https://files.pdfmonkey.io/share/72BE2293-D130-4C19-9E11-C82B5CEA8C37/2050-03-14-peter-parker.pdf",
  "status": "success",
  "updated_at": "2050-03-13T12:34:59.412+02:00"
}
```

### Attributs {#attributes-1}

| Nom | Type | Description |
|:--- |:--- |:--- |
| `id` | String (UUID) | Identifiant unique du document. |
| `app_id` | String (UUID) | Identifiant unique du workspace du document. |
| `created_at` | String (ISO 8601) | Date de création du document. |
| `document_template_id` | String (UUID) | ID du modèle utilisé pour générer ce document. |
| `document_template_identifier` | String | Le nom du modèle tel qu’affiché dans le tableau de bord. |
| `download_url` | String (URL) ou `null` | URL signée temporaire pour télécharger le fichier généré. `null` tant que la génération n’a pas réussi. Valide pendant **1 heure**. |
| `failure_cause` | String ou `null` | Raison de l’échec de la génération. `null` sauf si le statut est `failure`. |
| `filename` | String ou `null` | Nom du fichier généré. `null` tant que la génération n’a pas réussi. |
| `meta` | Object ou `null` | Métadonnées arbitraires attachées au document. |
| `output_type` | String | Format de sortie : `"pdf"` ou `"image"`. Hérité du modèle. |
| `preview_url` | String (URL) | URL pour intégrer un aperçu visuel. Pas pour le téléchargement. |
| `public_share_link` | String (URL) ou `null` | Lien public permanent. Nécessite l’activation des [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) (offres Pro+). |
| `status` | String | Statut actuel : `draft`, `pending`, `generating`, `success` ou `failure`. |
| `updated_at` | String (ISO 8601) | Date de dernière mise à jour du document. |

### Comparaison : Document vs DocumentCard {#comparison-document-vs-documentcard}

| Champ | Document | DocumentCard |
|:--- |:--- |:--- |
| `payload` | Inclus | **Non inclus** |
| `generation_logs` | Inclus | **Non inclus** |
| `checksum` | Inclus | **Non inclus** |
| `document_template_identifier` | **Non inclus** | Inclus |

## Récupérer un document {#get-a-document}

### Récupérer un DocumentCard (recommandé) {#get-a-documentcard-recommended}

**`GET /api/v1/document_cards/{id}`**

Retourne un [DocumentCard](#the-documentcard-object) pour le document donné. C’est la méthode recommandée pour vérifier le statut de génération et récupérer l’URL de téléchargement.








**curl**

```bash
curl -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  https://api.pdfmonkey.io/api/v1/document_cards/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c
```

**Ruby**

```ruby
card = Pdfmonkey::Document.fetch_card(&#39;a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;)

card.status       # =&gt; &#39;success&#39;
card.download_url # =&gt; &#39;https://…&#39;
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/document_cards/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
  {
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

const data = await response.json();
console.log(data.document_card);
```

**Python**

```python
import requests

response = requests.get(
    &#39;https://api.pdfmonkey.io/api/v1/document_cards/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
)

data = response.json()
print(data[&#39;document_card&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_cards/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document_card&#39;]);
```



**Réponse :** `200 OK` avec un objet `document_card`.

### Récupérer un Document complet {#get-a-full-document}

**`GET /api/v1/documents/{id}`**

Retourne le [Document](#the-document-object) complet, incluant `payload` et `generation_logs`. Utilisez cet endpoint uniquement lorsque vous avez besoin de ces champs.








**curl**

```bash
curl -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c
```

**Ruby**

```ruby
document = Pdfmonkey::Document.fetch(&#39;a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;)

document.status   # =&gt; &#39;success&#39;
document.payload  # =&gt; &#39;{&#34;clientName&#34;:&#34;Peter Parker&#34;,…}&#39;
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
  {
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

const data = await response.json();
console.log(data.document);
```

**Python**

```python
import requests

response = requests.get(
    &#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
)

data = response.json()
print(data[&#39;document&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document&#39;]);
```



**Réponse :** `200 OK` avec un objet `document`.

## Lister les documents {#list-documents}

**`GET /api/v1/document_cards`**

Retourne une liste paginée de [DocumentCards](#the-documentcard-object). Les résultats sont limités à 24 éléments par page.

### Paramètres de requête {#query-parameters}

| Nom | Type | Description |
|:--- |:--- |:--- |
| `page[number]` | Integer | Numéro de page (par défaut : `1`). |
| `q[document_template_id]` | String (UUID) ou Array | Filtrer par un ou plusieurs IDs de modèle. Accepte un UUID unique ou une liste séparée par des virgules. |
| `q[status]` | String | Filtrer par statut : `draft`, `pending`, `generating`, `success` ou `failure`. Voir [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md). |
| `q[workspace_id]` | String (UUID) | Filtrer par ID de workspace. |
| `q[updated_since]` | Timestamp | Retourner uniquement les documents mis à jour après ce moment. Accepte un timestamp Unix (ex. `1640995200` pour le 2022-01-01 00:00:00 UTC) ou une chaîne ISO 8601. |
| `q[search]` | String | Rechercher par ID de document ou nom de fichier. Si la valeur est un UUID, recherche par ID exact ; sinon effectue une correspondance partielle sur le nom de fichier. |








**curl**

```bash
curl -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  &#39;https://api.pdfmonkey.io/api/v1/document_cards?q[document_template_id]=2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&amp;q[status]=success&amp;page[number]=1&#39;
```

**Ruby**

```ruby
cards = Pdfmonkey::Document.list_cards(
  page: 1,
  document_template_id: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
  status: &#39;success&#39;
)

cards.each { |card| puts card.download_url }

cards.current_page # =&gt; 1
cards.total_pages  # =&gt; 1
```

**Node.js**

```javascript
const params = new URLSearchParams({
  &#39;q[document_template_id]&#39;: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
  &#39;q[status]&#39;: &#39;success&#39;,
  &#39;page[number]&#39;: &#39;1&#39;,
});

const response = await fetch(
  `https://api.pdfmonkey.io/api/v1/document_cards?${params}`,
  {
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

const data = await response.json();
console.log(data.document_cards);
console.log(data.meta); // Informations de pagination
```

**Python**

```python
import requests

response = requests.get(
    &#39;https://api.pdfmonkey.io/api/v1/document_cards&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    params={
        &#39;q[document_template_id]&#39;: &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
        &#39;q[status]&#39;: &#39;success&#39;,
        &#39;page[number]&#39;: 1,
    },
)

data = response.json()
print(data[&#39;document_cards&#39;])
print(data[&#39;meta&#39;])  # Informations de pagination
```

**PHP**

```php
&lt;?php
$query = http_build_query([
    &#39;q&#39; =&gt; [
        &#39;document_template_id&#39; =&gt; &#39;2903f5b4-623b-4e10-b2e3-dc7e2e67ea39&#39;,
        &#39;status&#39; =&gt; &#39;success&#39;,
    ],
    &#39;page&#39; =&gt; [&#39;number&#39; =&gt; 1],
]);

$ch = curl_init(&#34;https://api.pdfmonkey.io/api/v1/document_cards?{$query}&#34;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document_cards&#39;]);
print_r($data[&#39;meta&#39;]); // Informations de pagination
```



### Réponse {#response-2}

```json title="200 OK"
{
  "document_cards": [
    {
      "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
      "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
      "created_at": "2050-03-13T12:34:56.181+02:00",
      "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
      "document_template_identifier": "My Invoice Template",
      "download_url": "https://pdfmonkey.s3.eu-west-1.amazonaws.com/...",
      "failure_cause": null,
      "filename": "2050-03-14 Peter Parker.pdf",
      "meta": {
        "_filename": "2050-03-14 Peter Parker.pdf",
        "clientRef": "spidey-616"
      },
      "output_type": "pdf",
      "preview_url": "https://preview.pdfmonkey.io/pdf/web/viewer.html?file=...",
      "public_share_link": null,
      "status": "success",
      "updated_at": "2050-03-13T12:34:59.412+02:00"
    }
  ],
  "meta": {
    "current_page": 1,
    "next_page": null,
    "prev_page": null,
    "total_pages": 1
  }
}
```

L’objet `meta` contient les informations de pagination :

| Champ | Type | Description |
|:--- |:--- |:--- |
| `current_page` | Integer | Le numéro de la page courante. |
| `next_page` | Integer ou `null` | Le numéro de la page suivante, ou `null` si c’est la dernière page. |
| `prev_page` | Integer ou `null` | Le numéro de la page précédente, ou `null` si c’est la première page. |
| `total_pages` | Integer | Le nombre total de pages disponibles. |

## Mettre à jour un document {#update-a-document}

**`PUT /api/v1/documents/{id}`**

Met à jour un document existant. Vous pouvez modifier son payload, ses métadonnées, ou déclencher la génération en passant `status` à `"pending"`.

### Paramètres {#parameters-1}

Tous les paramètres sont imbriqués sous une clé `document`.

| Nom | Type | Requis | Description |
|:--- |:--- |:--- |:--- |
| `document_template_id` | String (UUID) | Non | Changer le modèle. |
| `payload` | Object ou String | Non | Remplacer les données dynamiques. |
| `meta` | Object ou String | Non | Remplacer les métadonnées. |
| `status` | String | Non | Passer à `"pending"` pour déclencher la génération. |








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c \
  -X PUT \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  -H &#39;Content-Type: application/json&#39; \
  -d &#39;{
    &#34;document&#34;: {
      &#34;status&#34;: &#34;pending&#34;,
      &#34;payload&#34;: { &#34;name&#34;: &#34;Mary Jane Watson&#34; }
    }
  }&#39;
```

**Ruby**

```ruby
document = Pdfmonkey::Document.fetch(&#39;a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;)

document.update!(
  status: &#39;pending&#39;,
  payload: { name: &#39;Mary Jane Watson&#39; }
)
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
  {
    method: &#39;PUT&#39;,
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
      &#39;Content-Type&#39;: &#39;application/json&#39;,
    },
    body: JSON.stringify({
      document: {
        status: &#39;pending&#39;,
        payload: { name: &#39;Mary Jane Watson&#39; },
      },
    }),
  }
);

const data = await response.json();
console.log(data.document);
```

**Python**

```python
import requests

response = requests.put(
    &#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    json={
        &#39;document&#39;: {
            &#39;status&#39;: &#39;pending&#39;,
            &#39;payload&#39;: {&#39;name&#39;: &#39;Mary Jane Watson&#39;},
        },
    },
)

print(response.json())
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_CUSTOMREQUEST =&gt; &#39;PUT&#39;,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
        &#39;Content-Type: application/json&#39;,
    ],
    CURLOPT_POSTFIELDS =&gt; json_encode([
        &#39;document&#39; =&gt; [
            &#39;status&#39; =&gt; &#39;pending&#39;,
            &#39;payload&#39; =&gt; [&#39;name&#39; =&gt; &#39;Mary Jane Watson&#39;],
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
```



**Réponse :** `200 OK` avec l’objet `document` mis à jour.

## Supprimer un document {#delete-a-document}

**`DELETE /api/v1/documents/{id}`**

Supprime définitivement un document et son fichier généré.








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c \
  -X DELETE \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;
```

**Ruby**

```ruby
Pdfmonkey::Document.delete(&#39;a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;)
# =&gt; true
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
  {
    method: &#39;DELETE&#39;,
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

console.log(response.status); // 204
```

**Python**

```python
import requests

response = requests.delete(
    &#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
)

print(response.status_code)  # 204
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/documents/a5e86d72-f5b7-43d4-a04e-8b7e08e6741c&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_CUSTOMREQUEST =&gt; &#39;DELETE&#39;,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

curl_exec($ch);
echo curl_getinfo($ch, CURLINFO_HTTP_CODE); // 204
curl_close($ch);
```



**Réponse :** `204 No Content` avec un corps vide.

## URLs de téléchargement {#download-urls}

Les URLs de téléchargement sont des liens S3 signés temporaires, valides pendant **1 heure**. Pour obtenir une URL fraîche après expiration, récupérez simplement le document à nouveau ; il n’est pas nécessaire de le regénérer. Pour des liens permanents, activez les [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) (offres Pro+).

Consultez [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour les détails sur l’expiration, les bonnes pratiques et le dépannage.

## Pages associées {#related-pages}

- **[Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md)** — Trouvez votre clé API et authentifiez vos requêtes.
- **[API Templates](https://pdfmonkey.io/fr/docs/api/templates.md)** — Listez et récupérez vos modèles pour trouver le `document_template_id` dont vous avez besoin.
- **[Générer des documents avec l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md)** — Guide pas-à-pas pour générer votre premier document.
- **[Statuts des documents et cycle de vie](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md)** — Comprenez le cycle `draft` / `pending` / `generating` / `success` / `failure`.
- **[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md)** — Comportement des URLs de téléchargement, expiration et bonnes pratiques.
- **[Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md)** — Recevez des notifications en temps réel lorsque la génération est terminée.
- **[Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md)** — Contrôlez le nom de fichier des documents générés via la clé meta `_filename`.
- **[Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md)** — URLs publiques permanentes pour les documents générés (offres Pro+).
- **[Intégrer un aperçu](https://pdfmonkey.io/fr/docs/generation-de-documents/integrer-un-apercu.md)** — Intégrez un aperçu visuel de votre document dans une page web.


## FAQ

**Comment générer un document avec l’API PDFMonkey ?**

Envoyez une requête POST à /api/v1/documents avec l’ID du modèle et les données dynamiques. Définissez le statut sur "pending" pour lancer la génération immédiatement. Interrogez ensuite le statut du document ou utilisez les webhooks.

**Quelle différence entre Document et DocumentCard dans PDFMonkey ?**

Un Document est l’objet complet incluant payload, generation_logs et checksum. Un DocumentCard est une version allégée sans ces champs mais avec document_template_identifier en plus.

**PDFMonkey prend-il en charge la génération synchrone ?**

Oui. Envoyez un POST à /api/v1/documents/sync pour créer un document et attendre le résultat en une seule requête. L’endpoint a un timeout de 6 minutes et renvoie un DocumentCard.

**Combien de temps une URL de téléchargement PDFMonkey est-elle valide ?**

Les URL de téléchargement sont des liens S3 signés temporaires valides 1 heure. Après expiration, récupérez le document à nouveau pour obtenir une URL fraîche.


---

# API Templates : lister, récupérer, créer, modifier et supprimer des modèles

Source: https://pdfmonkey.io/fr/docs/api/templates.mdRéférence complète de l’API pour lister, récupérer, créer, modifier et supprimer des modèles dans PDFMonkey.

> [!TIP]
> **La plupart des utilisateurs n’ont pas besoin de l’API Modèles**
>
> Les modèles sont généralement conçus dans le [Dashboard](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md) ou le [Builder visuel](https://pdfmonkey.io/fr/docs/modeles-builder/_index.md). L’API Modèles est utile lorsque vous gérez des modèles par programmation (par exemple, synchronisation depuis un pipeline CI ou construction d’un éditeur personnalisé). Pour générer des documents à partir d’un modèle existant, consultez l’[API Documents](https://pdfmonkey.io/fr/docs/api/documents.md).


## Authentification

Toutes les requêtes nécessitent un token Bearer dans l’en-tête `Authorization` :

```
Authorization: Bearer YOUR_SECRET_KEY
```

Consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md) pour savoir comment trouver votre clé API.

## L’objet DocumentTemplate

Un DocumentTemplate est le design réutilisable qui définit la mise en page d’un document. Il contient :

- **HTML + Liquid** pour le contenu dynamique
- **CSS / SCSS** pour le style
- **Données de test** pour l’aperçu dans le Dashboard
- **Paramètres** pour le format du papier, les marges, les en-têtes et les pieds de page

### Propriétés brouillon et publiées {#draft-vs-published-properties}

Chaque modèle maintient deux ensembles de propriétés :

- Les propriétés **brouillon** (`body_draft`, `scss_style_draft`, `settings_draft`, `sample_data_draft`, `pdf_engine_draft_id`) pour le contenu en cours d’édition dans le Dashboard mais pas encore publié.
- Les propriétés **publiées** (`body`, `scss_style`, `settings`, `sample_data`, `pdf_engine_id`) utilisées lors de la génération des documents.

Lorsque vous publiez un modèle dans le Dashboard, les valeurs brouillon sont copiées vers leurs équivalents publiés.

### Attributs {#attributes}

```json5 title="Objet DocumentTemplate"
{
  "id": "8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9",
  "app_id": "3161c5e5-9966-4630-9b07-63f718092784",
  "identifier": "Mon Super Modèle",
  "edition_mode": "code",
  "output_type": "pdf",
  "body": "<p>Bonjour {{name}}</p>",
  "body_draft": "<p>Bonjour, <strong>{{name}} !</strong></p>",
  "scss_style": "p { color: green; }",
  "scss_style_draft": "p { color: purple; }",
  "sample_data": "{ \"name\": \"Pierre Dupont\" }",
  "sample_data_draft": "{ \"name\": \"Spider-Man\" }",
  "settings": {
    "footer": {
      "center": null,
      "content": null,
      "left": null,
      "right": "page [page]/[topage]"
    },
    "header": {
      "center": null,
      "content": null,
      "left": null,
      "right": null
    },
    "inject_javascript": false,
    "margin": {
      "bottom": 0,
      "left": 0,
      "right": 0,
      "top": 0
    },
    "orientation": "portrait",
    "paper_format": "a4",
    "paper_height": 297,
    "paper_width": 210,
    "transparent_background": false,
    "use_emojis": false,
    "use_paged": false
  },
  "settings_draft": { /* même structure que settings */ },
  "pdf_engine_id": "5c709522-90db-4aea-b49f-15aeaa7180c7",
  "pdf_engine_draft_id": "5c709522-90db-4aea-b49f-15aeaa7180c7",
  "template_folder_id": null,
  "ttl": 86400,
  "created_at": "2050-01-02T03:04:05.678+02:00",
  "updated_at": "2050-01-02T03:04:05.678+02:00",
  "auth_token": "ZCsspcSZieyfdCUHYjKW1B9D8mnrz2ck",
  "checksum": "kfYsx6xzMx3JkYxLd4LW6YeU5rkcuTxQ",
  "preview_url": "https://preview.pdfmonkey.io/pdf/..."
}
```

| Attribut | Type | Description |
|:--- |:--- |:--- |
| `id` | UUID | Identifiant unique. |
| `app_id` | UUID | Identifiant unique de l’[espace de travail](https://pdfmonkey.io/fr/docs/premiers-pas/_index.md) du modèle. |
| `identifier` | String | Nom lisible (1 à 100 caractères). |
| `edition_mode` | String | `code`, `visual` (obsolète) ou `builder`. |
| `output_type` | String | `pdf` ou `image`. Détermine le format des documents générés. |
| `body` | String | Contenu HTML + Liquid publié, utilisé pour générer les documents. |
| `body_draft` | String | Contenu HTML + Liquid non publié, pas encore utilisé pour la génération. |
| `scss_style` | String | Styles CSS ou SCSS publiés, appliqués au contenu. Ne s’applique pas aux en-têtes ni aux pieds de page. |
| `scss_style_draft` | String | Styles CSS ou SCSS non publiés. |
| `sample_data` | String | Données de test publiées. Non utilisées pour la génération ; servent de point de restauration pour les modifications brouillon. |
| `sample_data_draft` | String | Données JSON brouillon utilisées pour prévisualiser le modèle. Non utilisées pour la génération. |
| `settings` | Object | Paramètres d’impression publiés. Voir [Paramètres](#settings) ci-dessous. |
| `settings_draft` | Object | Paramètres d’impression non publiés. Voir [Paramètres](#settings) ci-dessous. |
| `pdf_engine_id` | UUID | ID du moteur PDF utilisé lors de la génération des documents. Voir [Moteurs PDF](#pdf-engines) ci-dessous. |
| `pdf_engine_draft_id` | UUID | ID du moteur PDF utilisé pour prévisualiser le contenu brouillon. Utile pour tester un nouveau moteur avant de basculer. Voir [Moteurs PDF](#pdf-engines) ci-dessous. |
| `template_folder_id` | UUID ou `null` | ID d’un dossier pour regrouper le modèle. |
| `ttl` | Number | Durée de vie en secondes. Les documents générés depuis ce modèle sont automatiquement supprimés après ce délai. Voir [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md). |
| `created_at` | String (ISO 8601) | Date de création du modèle. |
| `updated_at` | String (ISO 8601) | Date de dernière modification du modèle. |
| `auth_token` | String | *Interne. Non utilisé.* |
| `checksum` | String | Interne. Utilisé pour l’invalidation du cache d’aperçu. |
| `preview_url` | String (URL) | URL pour prévisualiser le modèle avec les propriétés brouillon. À intégrer dans un `<iframe>` ou à ouvrir directement. |

### Paramètres {#settings}

L’attribut `settings` (et son équivalent brouillon `settings_draft`) contrôle la mise en page, le formatage et le comportement des documents générés.

Tous les paramètres ne s’appliquent pas à chaque configuration de modèle. La colonne **S’applique à** indique les modes d’édition et types de sortie concernés par chaque paramètre.

| Attribut | Type | S’applique à | Description |
|:--- |:--- |:--- |:--- |
| `footer` | Object | PDF (code, builder) | Configure le pied de page. |
| `footer.left` / `footer.center` / `footer.right` | String | PDF (code, builder) | Contenu pour les parties gauche, centre ou droite du pied de page. Les tokens magiques `[page]` et `[topage]` insèrent le numéro de page courant et le nombre total de pages. HTML + Liquid non pris en charge. |
| `footer.content` | String | PDF (code, builder) | Contenu pleine largeur pour le pied de page. Remplace `left`, `center` et `right` lorsqu’il est défini. |
| `header` | Object | PDF (code, builder) | Configure l’en-tête. |
| `header.left` / `header.center` / `header.right` | String | PDF (code, builder) | Contenu pour les parties gauche, centre ou droite de l’en-tête. Les tokens magiques `[page]` et `[topage]` peuvent être utilisés. HTML + Liquid non pris en charge. |
| `header.content` | String | PDF (code, builder) | Contenu pleine largeur pour l’en-tête. Remplace `left`, `center` et `right` lorsqu’il est défini. |
| `inject_javascript` | Boolean | Tous | Lorsque `true`, le payload du document (ou les données de test) est accessible en JavaScript via la variable `$docPayload`. Peut impacter les performances avec de gros payloads. **Toujours activé pour les modèles builder.** |
| `margin` | Object | PDF (code, builder) | Définit les marges du document. |
| `margin.bottom` / `margin.left` / `margin.right` / `margin.top` | Number | PDF (code, builder) | Marge en millimètres. Valeur par défaut : `10` si défini à `null` ou omis. |
| `orientation` | String | PDF (code, builder) | Orientation de la page : `portrait` ou `landscape`. |
| `paper_format` | String | PDF (code, builder) | Format du papier : `a0`, `a1`, `a2`, `a3`, `a4`, `a5`, `a6`, `letter` ou `custom`. |
| `paper_height` | Number | PDF (code, builder) | Hauteur du papier en millimètres. Utilisé uniquement lorsque `paper_format` est `custom` ; sinon dérivé du format. |
| `paper_width` | Number | Largeur du papier en millimètres. Utilisé uniquement lorsque `paper_format` est `custom` ; sinon dérivé du format. |
| `transparent_background` | Boolean | Image | Lorsque `true`, l’image générée a un fond transparent au lieu de blanc. |
| `use_emojis` | Boolean | Tous | Lorsque `true`, active le rendu des emojis (via [Noto Color Emoji](https://fonts.google.com/noto/specimen/Noto+Color+Emoji)) dans le document généré. |
| `use_paged` | Boolean | PDF (code, builder) | Spécifique au [moteur PDF v3](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md). Lorsque `true`, le moteur attend que le rendu Paged.js soit terminé avant de générer le PDF. Les autres moteurs ignorent ce paramètre. |

### Moteurs PDF {#pdf-engines}

PDFMonkey propose plusieurs moteurs PDF, chacun avec des capacités différentes. **Nous recommandons fortement d’utiliser le v4**, le plus récent et le plus puissant. Consultez [Nos moteurs](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md) pour une comparaison détaillée.

Pour récupérer la liste des moteurs disponibles :

```bash title="Requête"
curl https://api.pdfmonkey.io/api/v1/engines \
  -H "Authorization: Bearer VOTRE_CLE_SECRETE"
```

```json5 title="Réponse"
{
  "pdf_engines": [
    { "id": "5c709522-90db-4aea-b49f-15aeaa7180c7", "name": "v4", "deprecated_on": null },
    { "id": "61749ef7-6aca-4edb-84ca-685adb638c34", "name": "v3", "deprecated_on": null },
    { "id": "1f8da2ab-29c4-455c-a5fb-8771e44148c3", "name": "v2", "deprecated_on": null }
  ],
  "meta": {
    "current_page": 1,
    "next_page": null,
    "prev_page": null,
    "total_pages": 1
  }
}
```

## Lister les modèles {#list-templates}

**`GET /api/v1/document_template_cards`**

Renvoie une liste paginée de fiches modèle. Les fiches modèle sont des objets légers qui omettent le corps, les styles et les données de test du modèle.

### Paramètres de requête {#query-parameters}

| Nom | Type | Requis | Description |
|:--- |:--- |:--- |:--- |
| `q[workspace_id]` | String (UUID) | **Oui** | L’espace de travail dont lister les modèles. Accepte aussi `q[workspaceId]`, `q[app_id]` ou `q[appId]`. |
| `q[folders]` | String | Non | Liste d’IDs de dossiers séparés par des virgules. Utilisez `"none"` pour les modèles hors dossier, ou `"all"` (par défaut) pour tous les modèles. |
| `page` | Integer | Non | Numéro de page pour la pagination. |
| `sort` | String | Non | Attribut de tri. |

### Requête {#list-request}








**curl**

```bash
curl -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  &#39;https://api.pdfmonkey.io/api/v1/document_template_cards?q[workspace_id]=3161c5e5-9966-4630-9b07-63f718092784&#39;
```

**Ruby**

```ruby
cards = Pdfmonkey::Template.list_cards(
  workspace_id: &#39;3161c5e5-9966-4630-9b07-63f718092784&#39;
)

cards.each { |card| puts card.identifier }
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/document_template_cards?q[workspace_id]=3161c5e5-9966-4630-9b07-63f718092784&#39;,
  {
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

const data = await response.json();
console.log(data.document_template_cards);
```

**Python**

```python
import requests

response = requests.get(
    &#39;https://api.pdfmonkey.io/api/v1/document_template_cards&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    params={
        &#39;q[workspace_id]&#39;: &#39;3161c5e5-9966-4630-9b07-63f718092784&#39;,
    },
)

data = response.json()
print(data[&#39;document_template_cards&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_template_cards?q[workspace_id]=3161c5e5-9966-4630-9b07-63f718092784&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document_template_cards&#39;]);
```



### Réponse {#list-response}

```json title="200 OK"
{
  "document_template_cards": [
    {
      "id": "8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9",
      "app_id": "3161c5e5-9966-4630-9b07-63f718092784",
      "auth_token": "ZCsspcSZieyfdCUHYjKW1B9D8mnrz2ck",
      "created_at": "2050-01-02T03:04:05.678+02:00",
      "edition_mode": "code",
      "identifier": "Mon Super Modèle",
      "is_draft": true,
      "output_type": "pdf",
      "pdf_engine_deprecated_on": null,
      "pdf_engine_name": "v4",
      "template_folder_id": null,
      "template_folder_identifier": null,
      "updated_at": "2050-01-02T03:04:05.678+02:00"
    }
  ],
  "meta": {
    "current_page": 1,
    "next_page": null,
    "prev_page": null,
    "total_pages": 1
  }
}
```

> [!NOTE]
> **Fiches modèle et modèles complets**
>
> Les fiches modèle sont légères : elles incluent les métadonnées comme `identifier`, `edition_mode` et `is_draft`, mais **pas** le corps du modèle, les styles ni les données de test. Pour obtenir le contenu complet d’un modèle, utilisez [Récupérer un modèle](#get-a-template).


## Récupérer un modèle {#get-a-template}

**`GET /api/v1/document_templates/{id}`**

Renvoie l’[objet DocumentTemplate](#lobjet-documenttemplate) complet incluant le corps, les styles, les données de test et les paramètres.

### Requête {#get-request}








**curl**

```bash
curl -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9
```

**Ruby**

```ruby
template = Pdfmonkey::Template.fetch(&#39;8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;)

puts template.identifier
puts template.body
puts template.settings
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;,
  {
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

const data = await response.json();
console.log(data.document_template);
```

**Python**

```python
import requests

response = requests.get(
    &#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
)

data = response.json()
print(data[&#39;document_template&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document_template&#39;]);
```



### Réponse {#get-response}

Renvoie `200 OK` avec un objet `document_template` :

```json title="200 OK"
{
  "document_template": {
    "id": "8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9",
    "app_id": "3161c5e5-9966-4630-9b07-63f718092784",
    "identifier": "Mon Super Modèle",
    "edition_mode": "code",
    "output_type": "pdf",
    "body": "<p>Bonjour {{name}}</p>",
    "body_draft": "<p>Bonjour, <strong>{{name}} !</strong></p>",
    "scss_style": "p { color: green; }",
    "scss_style_draft": "p { color: purple; }",
    "sample_data": "{ \"name\": \"Pierre Dupont\" }",
    "sample_data_draft": "{ \"name\": \"Spider-Man\" }",
    "settings": { "...": "..." },
    "settings_draft": { "...": "..." },
    "pdf_engine_id": "5c709522-90db-4aea-b49f-15aeaa7180c7",
    "pdf_engine_draft_id": "5c709522-90db-4aea-b49f-15aeaa7180c7",
    "template_folder_id": null,
    "ttl": 86400,
    "created_at": "2050-01-02T03:04:05.678+02:00",
    "updated_at": "2050-01-02T03:04:05.678+02:00",
    "auth_token": "ZCsspcSZieyfdCUHYjKW1B9D8mnrz2ck",
    "checksum": "kfYsx6xzMx3JkYxLd4LW6YeU5rkcuTxQ",
    "preview_url": "https://preview.pdfmonkey.io/pdf/..."
  }
}
```

## Créer un modèle {#create-a-template}

**`POST /api/v1/document_templates`**

Crée un nouveau modèle. Dans la plupart des cas, il est préférable de créer les modèles via le [Dashboard](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md), mais l’API est disponible pour les workflows programmatiques.

### Paramètres {#create-parameters}

Tous les paramètres sont imbriqués sous une clé `document_template`.

| Nom | Type | Requis | Description |
|:--- |:--- |:--- |:--- |
| `app_id` | String (UUID) | **Oui** | L’espace de travail dans lequel créer le modèle. |
| `identifier` | String | **Oui** | Nom lisible (1 à 100 caractères). |
| `body` | String | Non | Contenu HTML + Liquid publié. |
| `body_draft` | String | Non | Contenu HTML + Liquid brouillon. |
| `scss_style` | String | Non | Styles CSS/SCSS publiés. |
| `scss_style_draft` | String | Non | Styles CSS/SCSS brouillon. |
| `sample_data` | String | Non | Données de test publiées (chaîne JSON). |
| `sample_data_draft` | String | Non | Données de test brouillon (chaîne JSON). |
| `settings` | Object ou String | Non | Paramètres d’impression publiés. Voir [Paramètres](#settings). |
| `settings_draft` | Object ou String | Non | Paramètres d’impression brouillon. |
| `pdf_engine_id` | String (UUID) | Non | Moteur PDF pour la génération. Par défaut, le dernier moteur. Voir [Moteurs PDF](#pdf-engines). |
| `pdf_engine_draft_id` | String (UUID) | Non | Moteur PDF pour l’aperçu. Par défaut, le dernier moteur. |
| `template_folder_id` | String (UUID) | Non | Dossier dans lequel placer le modèle. |
| `ttl` | Integer | Non | Durée de vie en secondes des documents générés. Les valeurs autorisées dépendent de votre plan. Voir [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md). |
| `edition_mode` | String | Non | `code` (par défaut) ou `builder`. |
| `output_type` | String | Non | `pdf` (par défaut) ou `image`. Voir [Format de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md). |

### Requête {#create-request}








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/document_templates \
  -X POST \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  -H &#39;Content-Type: application/json&#39; \
  -d &#39;{
    &#34;document_template&#34;: {
      &#34;app_id&#34;: &#34;3161c5e5-9966-4630-9b07-63f718092784&#34;,
      &#34;identifier&#34;: &#34;Invoice Template&#34;,
      &#34;body_draft&#34;: &#34;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#34;,
      &#34;scss_style_draft&#34;: &#34;h1 { color: #333; }&#34;,
      &#34;sample_data_draft&#34;: &#34;{ \&#34;number\&#34;: \&#34;INV-001\&#34;, \&#34;total\&#34;: \&#34;$123.50\&#34; }&#34;,
      &#34;settings_draft&#34;: {
        &#34;paper_format&#34;: &#34;a4&#34;,
        &#34;orientation&#34;: &#34;portrait&#34;,
        &#34;margin&#34;: { &#34;top&#34;: 20, &#34;bottom&#34;: 20, &#34;left&#34;: 15, &#34;right&#34;: 15 }
      }
    }
  }&#39;
```

**Ruby**

```ruby
template = Pdfmonkey::Template.create(
  workspace_id: &#39;3161c5e5-9966-4630-9b07-63f718092784&#39;,
  identifier: &#39;Invoice Template&#39;,
  body: &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
  scss_style: &#39;h1 { color: #333; }&#39;,
  sample_data: &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
  settings: {
    paper_format: &#39;a4&#39;,
    orientation: &#39;portrait&#39;,
    margin: { top: 20, bottom: 20, left: 15, right: 15 },
  },
)

puts template.id
```

**Node.js**

```javascript
const response = await fetch(&#39;https://api.pdfmonkey.io/api/v1/document_templates&#39;, {
  method: &#39;POST&#39;,
  headers: {
    &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    &#39;Content-Type&#39;: &#39;application/json&#39;,
  },
  body: JSON.stringify({
    document_template: {
      app_id: &#39;3161c5e5-9966-4630-9b07-63f718092784&#39;,
      identifier: &#39;Invoice Template&#39;,
      body_draft: &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
      scss_style_draft: &#39;h1 { color: #333; }&#39;,
      sample_data_draft: &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
      settings_draft: {
        paper_format: &#39;a4&#39;,
        orientation: &#39;portrait&#39;,
        margin: { top: 20, bottom: 20, left: 15, right: 15 },
      },
    },
  }),
});

const data = await response.json();
console.log(data.document_template);
```

**Python**

```python
import requests

response = requests.post(
    &#39;https://api.pdfmonkey.io/api/v1/document_templates&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    json={
        &#39;document_template&#39;: {
            &#39;app_id&#39;: &#39;3161c5e5-9966-4630-9b07-63f718092784&#39;,
            &#39;identifier&#39;: &#39;Invoice Template&#39;,
            &#39;body_draft&#39;: &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
            &#39;scss_style_draft&#39;: &#39;h1 { color: #333; }&#39;,
            &#39;sample_data_draft&#39;: &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
            &#39;settings_draft&#39;: {
                &#39;paper_format&#39;: &#39;a4&#39;,
                &#39;orientation&#39;: &#39;portrait&#39;,
                &#39;margin&#39;: {&#39;top&#39;: 20, &#39;bottom&#39;: 20, &#39;left&#39;: 15, &#39;right&#39;: 15},
            },
        },
    },
)

data = response.json()
print(data[&#39;document_template&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_templates&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_POST =&gt; true,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
        &#39;Content-Type: application/json&#39;,
    ],
    CURLOPT_POSTFIELDS =&gt; json_encode([
        &#39;document_template&#39; =&gt; [
            &#39;app_id&#39; =&gt; &#39;3161c5e5-9966-4630-9b07-63f718092784&#39;,
            &#39;identifier&#39; =&gt; &#39;Invoice Template&#39;,
            &#39;body_draft&#39; =&gt; &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
            &#39;scss_style_draft&#39; =&gt; &#39;h1 { color: #333; }&#39;,
            &#39;sample_data_draft&#39; =&gt; &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
            &#39;settings_draft&#39; =&gt; [
                &#39;paper_format&#39; =&gt; &#39;a4&#39;,
                &#39;orientation&#39; =&gt; &#39;portrait&#39;,
                &#39;margin&#39; =&gt; [&#39;top&#39; =&gt; 20, &#39;bottom&#39; =&gt; 20, &#39;left&#39; =&gt; 15, &#39;right&#39; =&gt; 15],
            ],
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document_template&#39;]);
```



### Réponse {#create-response}

Renvoie `201 Created` avec l’objet `document_template` complet.

### Erreurs de validation {#validation-errors}

Si des champs requis sont manquants ou invalides, l’API renvoie `422 Unprocessable Entity` :

```json title="422 Unprocessable Entity"
{
  "errors": {
    "identifier": ["can't be blank"]
  }
}
```

## Modifier un modèle {#update-a-template}

**`PUT /api/v1/document_templates/{id}`**

Met à jour un modèle existant. Seuls les champs inclus dans le corps de la requête sont modifiés.

### Paramètres {#update-parameters}

Tous les paramètres sont imbriqués sous une clé `document_template`. Les mêmes champs que [Créer un modèle](#create-a-template) sont acceptés.

### Requête {#update-request}








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9 \
  -X PUT \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39; \
  -H &#39;Content-Type: application/json&#39; \
  -d &#39;{
    &#34;document_template&#34;: {
      &#34;body_draft&#34;: &#34;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Due: {{due_date}}&lt;/p&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#34;,
      &#34;sample_data_draft&#34;: &#34;{ \&#34;number\&#34;: \&#34;INV-001\&#34;, \&#34;due_date\&#34;: \&#34;2050-04-01\&#34;, \&#34;total\&#34;: \&#34;$123.50\&#34; }&#34;
    }
  }&#39;
```

**Ruby**

```ruby
template = Pdfmonkey::Template.fetch(&#39;8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;)

template.update!(
  body: &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Due: {{due_date}}&lt;/p&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
  sample_data: &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;due_date&#34;: &#34;2050-04-01&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
)
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;,
  {
    method: &#39;PUT&#39;,
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
      &#39;Content-Type&#39;: &#39;application/json&#39;,
    },
    body: JSON.stringify({
      document_template: {
        body_draft: &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Due: {{due_date}}&lt;/p&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
        sample_data_draft: &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;due_date&#34;: &#34;2050-04-01&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
      },
    }),
  }
);

const data = await response.json();
console.log(data.document_template);
```

**Python**

```python
import requests

response = requests.put(
    &#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
    json={
        &#39;document_template&#39;: {
            &#39;body_draft&#39;: &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Due: {{due_date}}&lt;/p&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
            &#39;sample_data_draft&#39;: &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;due_date&#34;: &#34;2050-04-01&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
        },
    },
)

data = response.json()
print(data[&#39;document_template&#39;])
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_CUSTOMREQUEST =&gt; &#39;PUT&#39;,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
        &#39;Content-Type: application/json&#39;,
    ],
    CURLOPT_POSTFIELDS =&gt; json_encode([
        &#39;document_template&#39; =&gt; [
            &#39;body_draft&#39; =&gt; &#39;&lt;h1&gt;Invoice #{{number}}&lt;/h1&gt;&lt;p&gt;Due: {{due_date}}&lt;/p&gt;&lt;p&gt;Total: {{total}}&lt;/p&gt;&#39;,
            &#39;sample_data_draft&#39; =&gt; &#39;{ &#34;number&#34;: &#34;INV-001&#34;, &#34;due_date&#34;: &#34;2050-04-01&#34;, &#34;total&#34;: &#34;$123.50&#34; }&#39;,
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data[&#39;document_template&#39;]);
```



### Réponse {#update-response}

Renvoie `200 OK` avec l’objet `document_template` mis à jour.

## Supprimer un modèle {#delete-a-template}

**`DELETE /api/v1/document_templates/{id}`**

Supprime définitivement un modèle.

> [!CAUTION]
> La suppression d’un modèle est irréversible. Tous les documents liés à ce modèle perdront leur référence de modèle.


### Requête {#delete-request}








**curl**

```bash
curl https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9 \
  -X DELETE \
  -H &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;
```

**Ruby**

```ruby
Pdfmonkey::Template.delete(&#39;8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;)
```

**Node.js**

```javascript
const response = await fetch(
  &#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;,
  {
    method: &#39;DELETE&#39;,
    headers: {
      &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
  }
);

console.log(response.status); // =&gt; 204
```

**Python**

```python
import requests

response = requests.delete(
    &#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;,
    headers={
        &#39;Authorization&#39;: &#39;Bearer YOUR_SECRET_KEY&#39;,
    },
)

print(response.status_code)  # =&gt; 204
```

**PHP**

```php
&lt;?php
$ch = curl_init(&#39;https://api.pdfmonkey.io/api/v1/document_templates/8ac0d8f7-dbd3-46dd-b2d3-af036a2776d9&#39;);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER =&gt; true,
    CURLOPT_CUSTOMREQUEST =&gt; &#39;DELETE&#39;,
    CURLOPT_HTTPHEADER =&gt; [
        &#39;Authorization: Bearer YOUR_SECRET_KEY&#39;,
    ],
]);

curl_exec($ch);
echo curl_getinfo($ch, CURLINFO_HTTP_CODE); // =&gt; 204
curl_close($ch);
```



### Réponse {#delete-response}

Renvoie `204 No Content` avec un corps vide.

## Pages associées {#related-pages}

- **[Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md)** — Trouvez votre clé API et authentifiez vos requêtes.
- **[API Documents](https://pdfmonkey.io/fr/docs/api/documents.md)** — Créez, listez et gérez les documents générés.
- **[Générer des documents via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md)** — Guide pas à pas avec des exemples dans plusieurs langages.
- **[Nos moteurs](https://pdfmonkey.io/fr/docs/modeles-code/nos-moteurs.md)** — Comparaison détaillée des versions de moteurs PDF.
- **[Format de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md)** — Choisir entre le format PDF et image.
- **[Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md)** — Comprendre les valeurs TTL et le nettoyage automatique des documents.
- **[Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md)** — Recevez des notifications lorsque la génération des documents est terminée.


## FAQ

**Qu’est-ce qu’un DocumentTemplate dans PDFMonkey ?**

Un DocumentTemplate est le design réutilisable qui définit la mise en page d’un document. Il contient du HTML + Liquid pour le contenu dynamique, du CSS/SCSS pour le style, des données de test pour la prévisualisation et des paramètres de format papier, marges, en-têtes et pieds de page.

**Comment lister tous les modèles avec l’API PDFMonkey ?**

Envoyez une requête GET à /api/v1/document_template_cards avec un paramètre q[workspace_id]. La réponse renvoie une liste paginée d’objets template card légers.

**Peut-on créer et modifier des modèles via l’API ?**

Oui. Envoyez un POST à /api/v1/document_templates pour créer un modèle et un PUT à /api/v1/document_templates/{id} pour le modifier. La plupart des utilisateurs conçoivent les modèles dans le Dashboard.



---

# Intégration Zapier : automatiser la génération de documents

Source: https://pdfmonkey.io/fr/docs/integrations/zapier.md
L’intégration PDFMonkey pour Zapier vous permet de générer, récupérer et gérer des documents directement depuis vos Zaps. Si vous découvrez l’intégration, commencez par la section [Premiers pas](#getting-started) ci-dessous pour un tutoriel complet de bout en bout.

## Premiers pas {#getting-started}

<iframe width="100%" height="400" src="https://www.youtube.com/embed/yLMBYxehDMg" title="YouTube video player" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

Avant de commencer, assurez-vous d’avoir un compte PDFMonkey et un modèle publié. Consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) pour les instructions de configuration.

### Écrire votre premier modèle

Dans l’onglet **HTML** de votre modèle, insérez le code suivant :

```liquid title="HTML"
<p class="greeting">Hello {{name}}!</p>
<p>Your favorite number is {{favoriteNumber}}.</p>
```

Dans l’onglet **CSS**, insérez le code suivant :

```css
.greeting {
  color: #6D28D9;
  font-size: 24px;
}
```

Et enfin dans l’onglet **Test data**, insérez ceci :

```json
{
  "name": "Peter Parker",
  "favoriteNumber": 8
}
```

Cliquez sur **Save** pour voir l’aperçu se mettre à jour, puis cliquez sur **Publish** pour rendre le modèle disponible pour la génération.

> [!WARNING]
> **Publiez toujours votre modèle !**
>
> Oublier de publier votre modèle est une erreur fréquente, surtout lorsque vous alternez entre Zapier et PDFMonkey. Si les documents générés ne correspondent pas à votre modèle, vérifiez toujours que vous l’avez bien publié.


### Générer votre premier document

Maintenant que votre modèle est terminé, rendez-vous sur Zapier.

Pour ce guide, nous allons définir un Zap déclenché par la soumission d’un formulaire [Tally](https://tally.so/), générer un document avec PDFMonkey puis l’envoyer par email.

#### Le formulaire Tally

Nous utiliserons le formulaire Tally suivant comme source d’information dans notre Zap :

![Formulaire Tally utilisé comme trigger du Zap](https://pdfmonkey.io/fr/docs/img/zapier-guide-select-pdfmonkey.webp)

#### Configurer votre Zap

Commencez par créer un nouveau Zap. Comme trigger, nous utiliserons l’événement **New Response** de Tally :

![Création d’un nouveau Zap avec un trigger Tally](https://pdfmonkey.io/fr/docs/img/zapier-guide-create-document.webp)

Nous procédons ensuite au remplissage du formulaire et vérifions qu’il est correctement connecté dans Zapier :

![Sélection du modèle PDFMonkey](https://pdfmonkey.io/fr/docs/img/zapier-guide-select-template.webp)

![Connexion de votre compte PDFMonkey](https://pdfmonkey.io/fr/docs/img/zapier-guide-connect-account.webp)

#### Appeler PDFMonkey

Maintenant que nous avons des données avec lesquelles travailler, nous allons configurer notre action PDFMonkey.

Sélectionnez l’application PDFMonkey et choisissez l’action **Generate Document**.

![Mapping des champs dans l’action PDFMonkey](https://pdfmonkey.io/fr/docs/img/zapier-guide-map-fields.webp)

Vous pouvez ensuite associer les données du formulaire aux variables de votre document. Assurez-vous d’utiliser les mêmes noms que ceux utilisés lors de l’écriture du modèle.

![Test de l’action PDFMonkey](https://pdfmonkey.io/fr/docs/img/zapier-guide-test-action.webp)

> [!NOTE]
> **Nommage des variables**
>
> Si vous vous demandez comment écrire des noms corrects pour qu’ils fonctionnent dans PDFMonkey, nous fournissons [une liste de formats de noms de variables corrects/incorrects](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables).


Nous sommes maintenant prêts à tester la génération du document.

![Document créé avec succès](https://pdfmonkey.io/fr/docs/img/zapier-guide-document-created.webp)

![Téléchargement du document généré](https://pdfmonkey.io/fr/docs/img/zapier-guide-download-pdf.webp)

#### Envoyer le document par email

Maintenant que notre document est généré, envoyons-le par email.

Ajoutez une nouvelle action et sélectionnez l’application Email by Zapier, puis choisissez l’action **Send Outbound Email**.

![Configuration de l’action d’envoi d’email](https://pdfmonkey.io/fr/docs/img/zapier-guide-send-email.webp)

Nous pouvons maintenant utiliser l’**URL de téléchargement** de notre document comme pièce jointe de l’email. Zapier télécharge automatiquement le fichier et le joint.

![Le Zap complet du trigger à l’email](https://pdfmonkey.io/fr/docs/img/zapier-guide-final-zap.webp)

Vous pouvez maintenant tester cette dernière action et vous devriez recevoir un email avec le document en pièce jointe.

Félicitations ! Vous avez généré votre tout premier document PDFMonkey avec Zapier !

## Générer un document {#generate-a-document}

L’action **Generate Document** crée un document à partir de l’un de vos modèles PDFMonkey. Vous sélectionnez un modèle, associez vos champs de données, et PDFMonkey génère le document. L’action renvoie une [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) utilisable dans les étapes suivantes du Zap.

Pour un guide pas à pas de votre premier Zap, consultez la section [Premiers pas](#getting-started) ci-dessus.

### Payload JSON avancé {#advanced-json}

> [!WARNING]
> **Attention !**
>
> Un grand pouvoir implique parfois de grands problèmes. Ne passez au JSON avancé que si vous savez ce que vous faites et savez comment échapper correctement vos données.
&gt; 
&gt; Consultez la section [Résolution de problèmes](#troubleshooting) pour plus d’informations.


Par défaut, l’intégration fournit un champ de mapping simple pour définir ce qui est envoyé à PDFMonkey. Dans la plupart des cas, le mapping simple est suffisant, mais il existe des situations où vous devez structurer vos données différemment. L’option **Use a custom JSON structure** bascule du mapping simple vers une zone de texte où vous pouvez insérer votre propre JSON avec des propriétés imbriquées :

![Option de payload JSON personnalisé dans l’action PDFMonkey Zapier](https://pdfmonkey.io/fr/docs/img/zapier-custom-json-payload.webp)

### Nom de fichier personnalisé {#custom-filename}

Vous pouvez spécifier un nom personnalisé pour le fichier généré. Cela est utile si vous prévoyez de stocker le document dans un service comme Drive ou Dropbox.

Vous pouvez utiliser des parties dynamiques pour construire le nom de fichier, mais gardez ces restrictions à l’esprit :

- Le nom de fichier ne doit contenir aucun slash `/` ni backslash `\`
- Les caractères non latins doivent être évités car ils peuvent être corrompus lors de l’enregistrement du fichier

Les noms courts basés sur des dates ou des identifiants fonctionnent généralement le mieux.

> [!TIP]
> Pour plus de détails sur les options de nom de fichier (y compris la définition via l’API), consultez [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md).


### Métadonnées {#metadata}

Lorsque vous générez un document, vous pouvez y joindre des métadonnées. Les métadonnées ne sont pas disponibles dans le modèle et ne peuvent pas influencer le contenu du document ; elles y sont simplement attachées.

Un cas d’utilisation courant est la réception du document via un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) et l’utilisation de ses métadonnées pour le router ou le traiter différemment.

![Champs de métadonnées dans l’action PDFMonkey Zapier](https://pdfmonkey.io/fr/docs/img/zapier-metadata-fields.webp)

### Lignes de détail {#line-items}

Si vous générez une facture ou un devis, vous devrez probablement gérer des lignes de détail. Zapier offre un moyen d’accéder à ces éléments si le trigger que vous utilisez les prend en charge.

Prenons l’exemple d’une facture Stripe. Les éléments de la facture sont disponibles via une collection Line Items. Pour envoyer ces éléments de manière compréhensible pour PDFMonkey, définissez **Add Line Items** sur **Yes**.

Cela ouvre une section où vous spécifiez à quoi ressemble un **seul élément**. Par exemple, considérons une facture Stripe avec ces éléments :

```
Délicieuse gaufre          3.50€      x12      = 42.00€
Donut parfaitement rond    4.99€      x5       = 24.95€
TOTAL                                            66.95€
```

Le `TOTAL` doit être envoyé comme donnée de base du document, tandis que le nom, le prix unitaire, la quantité et le montant total de chaque élément doivent être envoyés comme lignes de détail depuis Zapier :

![Mapping des lignes de détail dans l’action PDFMonkey Zapier](https://pdfmonkey.io/fr/docs/img/zapier-line-items-mapping.webp)

> [!TIP]
> **Mapping ou JSON**
>
> Le champ pour définir les données d’une ligne de détail utilise le même formulaire que les données principales. Si vous utilisez le [JSON avancé](#advanced-json) pour les données principales, le payload de la ligne de détail est également défini en JSON avancé.


#### Utiliser les lignes de détail dans votre modèle

Lorsque Zapier envoie les lignes de détail à PDFMonkey, elles sont accessibles via une variable spéciale `lineItems`. Dans l’exemple ci-dessus, le payload ressemblerait à ceci :

```json title="JSON"
{
  "lineItems": [
    {
      "product": "Delicious waffle",
      "quantity": "12",
      "unitPrice": "3.50",
      "totalAmount": "42.00"
    },
    {
      "product": "Perfectly round donut",
      "quantity": "5",
      "unitPrice": "4.99",
      "totalAmount": "24.95"
    }
  ]
}
```

> [!NOTE]
> **Uniquement des chaînes de caractères**
>
> Si vous observez attentivement le payload ci-dessus, seules des chaînes de caractères sont envoyées. Zapier ne différencie pas le texte et les nombres.
&gt; 
&gt; Heureusement, Liquid (le langage de template que nous utilisons) est suffisamment intelligent pour convertir ces valeurs en nombres lorsque vous effectuez des calculs. Gardez simplement cela à l’esprit si vous rencontrez des problèmes avec les nombres. Consultez [Comment faire des calculs](https://pdfmonkey.io/fr/docs/modeles-code/comment-faire-des-calculs.md) pour des astuces arithmétiques.


Vous pouvez parcourir le tableau `lineItems` pour afficher le contenu de chaque élément individuellement :

```liquid title="HTML"
{% for item in lineItems %}
  <p>{{item.product}} at {{item.unitPrice}}€ x{{item.quantity}} = {{item.totalAmount}}€</p>
{% endfor %}
```

Ce qui produit le HTML suivant :

```html title="HTML"
<p>Delicious waffle at 3.50€ x12 = 42.00€</p>
<p>Perfectly round donut at 4.99€ x5 = 24.95€</p>
```

Vous voudrez probablement construire une ligne de tableau pour chaque élément, mais cela vous donne une bonne idée de la marche à suivre. Consultez [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-code/conditions-et-boucles.md) pour d’autres techniques de boucles Liquid.

## Trigger Document Generated {#document-generated-trigger}

Le trigger **Document Generated** déclenche votre Zap chaque fois qu’un document termine sa génération (atteint le [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) `success`). Cela est utile pour automatiser les tâches post-génération comme le stockage du fichier dans Dropbox, l’envoi par email ou l’enregistrement dans une feuille de calcul.

![Sélection de l’événement Document Generated dans Zapier](https://pdfmonkey.io/fr/docs/img/zapier-trigger-select-event.webp)

Vous pouvez choisir de déclencher votre Zap pour :

- N’importe quel modèle de votre workspace
- Un seul modèle
- Plusieurs modèles spécifiques

![Connexion de votre compte PDFMonkey dans le trigger](https://pdfmonkey.io/fr/docs/img/zapier-trigger-connect-account.webp)

Assurez-vous d’avoir au moins un document généré avant de tester votre trigger dans Zapier.

![Sélection du modèle sur lequel déclencher](https://pdfmonkey.io/fr/docs/img/zapier-trigger-select-template.webp)

Vous pouvez ensuite utiliser le fichier généré pour le stocker, l’envoyer par email ou être notifié d’une manière ou d’une autre.

> [!NOTE]
> **Exploiter les métadonnées**
>
> Le document exposé par le trigger ne contient pas votre payload. Si vous avez besoin d’informations dans les actions suivantes, nous recommandons de [joindre des métadonnées](#metadata) au document.
&gt; 
&gt; C’est ce que nous avons fait avec les informations Tally dans cet exemple.


![Résultat du test montrant la sortie du trigger](https://pdfmonkey.io/fr/docs/img/zapier-trigger-test-result.webp)

## Récupérer et supprimer des documents {#retrieve-and-delete}

### Récupérer un document

L’action **Retrieve Document** récupère un document précédemment généré par son identifiant. Utilisez-la lorsque vous devez accéder aux détails d’un document ou à son [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) dans une étape ultérieure de votre Zap ; par exemple, après un délai ou dans un workflow séparé de celui qui l’a généré.

### Supprimer un document

L’action **Delete Document** supprime un seul document de PDFMonkey. Utilisez-la pour nettoyer les documents après les avoir traités ; par exemple, après avoir téléchargé et stocké le fichier ailleurs. Consultez [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) pour en savoir plus sur la gestion du cycle de vie des documents.

## Résolution de problèmes {#troubleshooting}

### URL de téléchargement expirée {#download-url-expired}

Si vous obtenez une erreur d’URL de téléchargement expirée lors de la construction de votre Zap, rechargez l’enregistrement d’exemple dans votre trigger.

L’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) n’est valide que pendant 1 heure. Vous devez actualiser les documents dans Zapier pour obtenir une nouvelle URL. Cliquez sur le bouton **Load More** dans la section Test de votre trigger :

![Actualisation des champs du trigger pour obtenir une nouvelle URL de téléchargement](https://pdfmonkey.io/fr/docs/img/zapier-refresh-trigger-fields.webp)

> [!NOTE]
> **Sortie de génération**
>
> Cette astuce ne s’applique qu’au trigger. Pour la sortie d’une action Generate Document, vous devez générer un nouveau document pour obtenir des données fraîches et une URL de téléchargement valide.


> [!TIP]
> Si vos Zaps échouent parce que l’URL a expiré avant qu’une étape ultérieure ne s’exécute, consultez [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md) pour des solutions.


### Réponses 422 {#422-responses}

Cette erreur survient généralement lorsque vous utilisez l’option JSON personnalisé et que des valeurs nécessitent un échappement avant d’être envoyées à PDFMonkey.

#### Valeurs contenant des guillemets doubles

Considérons le JSON personnalisé suivant :

```json5 title="Custom JSON"
{
  "user": {
    "name": "(Dynamic Field From Zapier)"
  }
}
```

Si la valeur dans `Dynamic Field From Zapier` contient des guillemets, le JSON résultant est cassé. Prenons `Peter "Spiderman" Parker` comme exemple :

```json title="JSON invalide"
{
  "user": {
    "name": "Peter "Spiderman" Parker"
  }
}
```

Ce n’est pas du JSON valide. Ce dont vous avez besoin, c’est d’_échapper_ les guillemets doubles :

```json title="JSON valide"
{
  "user": {
    "name": "Peter \"Spiderman\" Parker"
  }
}
```

> [!NOTE]
> **Attributs HTML**
>
> Si vous envoyez du HTML, cela arrive fréquemment car les attributs utilisent presque toujours des guillemets doubles (par ex., `&lt;div class=&#34;test&#34;&gt;`).


#### Valeurs contenant des sauts de ligne

Le JSON ne prend pas en charge les valeurs contenant des sauts de ligne bruts :

```json title="JSON invalide"
{
  "userBio": "Once upon a time,
They lived happily ever after."
}
```

Échappez les sauts de ligne en les remplaçant par une balise `<br />` ou en utilisant la représentation textuelle `\n` :

```json title="JSON valide"
{
  "userBio": "Once upon a time,\nThey lived happily ever after."
}
```

#### Solution {#escaping-solution}

> [!NOTE]
> **Avez-vous vraiment besoin du JSON personnalisé ?**
>
> La première question à vous poser est de savoir si vous avez vraiment besoin du JSON personnalisé. Dans la plupart des cas, l’approche par mapping simple est suffisante et gère l’échappement automatiquement.


Si vous ne pouvez pas échapper les valeurs avant qu’elles n’arrivent dans Zapier, ajoutez une action **Code by Zapier** avant d’appeler PDFMonkey.

Supposons que vos données contiennent à la fois des sauts de ligne et des guillemets doubles :

| Élément                        | Valeur                                                                                                                                                                               |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Trigger App User Bio**       | <p>This is the bio of the user.</p><p>It’s a free form text that the user can edit so it can contain line breaks.</p><p><br />It could even be split in a few paragraphs... why not?</p> |
| **Trigger App User Name**      | Peter Parker                                                                                                                                                                         |
| **Trigger App User Full Name** | Peter "Spiderman" Parker                                                                                                                                                             |

Vous devez échapper les valeurs pour `Trigger App User Bio` et `Trigger App User Full Name`. Commencez par ajouter une action **Code by Zapier** à votre Zap et sélectionnez **Run Javascript** :

![Ajout d’une action Code by Zapier avec les données brutes en entrée](https://pdfmonkey.io/fr/docs/img/zapier-error-422-raw-body.webp)

Donnez à vos champs des noms qui permettent de les identifier facilement dans les étapes suivantes :

![Nommage des champs d’entrée dans Code by Zapier](https://pdfmonkey.io/fr/docs/img/zapier-error-422-json-format.webp)

Ajoutez maintenant le code qui échappe les valeurs :

```javascript title="Code by Zapier"
let data = Object.assign({}, inputData);

for (let key in data) {
  if (typeof(data[key]) === "string" && data[key].length > 0) {
    data[key] = data[key].replace(/\r?\n/g, '<br>').replace(/\t/g, " ").replace(/"/g, '\\\"');
  }
}

output = [data];
```

Cela vous donne les mêmes champs en sortie mais avec leurs valeurs correctement échappées :

![La sortie échappée de Code by Zapier](https://pdfmonkey.io/fr/docs/img/zapier-error-422-custom-request.webp)

Vous pouvez maintenant utiliser ces valeurs lors de la construction de votre payload PDFMonkey :

![Utilisation des valeurs échappées dans l’action PDFMonkey](https://pdfmonkey.io/fr/docs/img/zapier-error-422-fixed-payload.webp)

Notez que nous avons utilisé les champs de l’étape Code by Zapier, et non ceux du trigger directement.

## Étapes suivantes {#next-steps}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : créer votre compte PDFMonkey et votre premier modèle
- [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) : structurer le payload JSON pour vos modèles
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprendre le cycle de vie d’un document généré
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : recevoir des notifications en temps réel à la fin de la génération
- Découvrir d’autres intégrations : [Make](https://pdfmonkey.io/fr/docs/integrations/make.md), [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md), [Workato](https://pdfmonkey.io/fr/docs/integrations/workato.md)


---

# Intégration Make : automatiser la génération de documents

Source: https://pdfmonkey.io/fr/docs/integrations/make.md
Le module PDFMonkey pour [Make](https://www.make.com/) vous permet de générer des documents dans le cadre de vos scénarios automatisés. Combinez-le avec des déclencheurs provenant de constructeurs de formulaires, de CRM ou de bases de données pour produire et envoyer des fichiers sans écrire de code.

## Configuration {#setup}

Avant de commencer, assurez-vous de disposer des éléments suivants :

- Un compte PDFMonkey ([inscription ici](https://dashboard.pdfmonkey.io/register))
- Un compte [Make](https://www.make.com/)
- Un modèle publié dans PDFMonkey

Pour la création de compte et la configuration d’un modèle, consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

Pour connecter PDFMonkey à Make, ajoutez le module PDFMonkey à votre scénario et cliquez sur **Create a connection**. Saisissez votre clé secrète API depuis la page [Mon compte](https://dashboard.pdfmonkey.io/account).

## Générer un document {#generate-a-document}

Ajoutez le module PDFMonkey **Generate a Document** à votre scénario. Sélectionnez votre Workspace et votre Template, puis associez les champs des modules précédents aux variables définies dans votre modèle.

![Mapping des champs PDFMonkey dans Make](https://pdfmonkey.io/fr/docs/img/make-pdfmonkey-field-mapping.webp)

> [!NOTE]
> **Nommage des variables**
>
> Les noms de variables dans votre modèle doivent suivre des règles de formatage spécifiques. Consultez la référence sur le [nommage des variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour les formats corrects et incorrects.


Après l’exécution du module, celui-ci retourne les données du document généré, incluant l’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) et le nom du fichier.

![Résultat de la génération de document dans Make](https://pdfmonkey.io/fr/docs/img/make-document-generated.webp)

## Utiliser le fichier généré {#working-with-the-generated-file}

### Télécharger le fichier {#downloading-the-file}

Pour utiliser le fichier généré dans les modules suivants, téléchargez-le d’abord. Ajoutez le module HTTP **Get a File** et passez-lui l’**URL de téléchargement** retournée par le module PDFMonkey.

![Configuration du module HTTP Get a File](https://pdfmonkey.io/fr/docs/img/make-http-get-file.webp)

> [!TIP]
> L’URL de téléchargement expire après 1 heure. Si vous prévoyez de l’utiliser plus tard, téléchargez le fichier immédiatement ou envoyez-le vers un stockage permanent. Consultez [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour plus de détails.


### Envoyer par e-mail {#sending-by-email}

Ajoutez le module de votre fournisseur d’e-mail (ou le module intégré **Send an email** de Make) et joignez le fichier téléchargé. Personnalisez le champ **File name** pour éviter le nom par défaut `file.pdf` ; le module PDFMonkey retourne un nom de fichier que vous pouvez utiliser directement.

![Configuration de la pièce jointe e-mail avec nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/img/make-email-attachment.webp)

> [!TIP]
> Vous pouvez aussi définir un [nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) dans PDFMonkey pour qu’il arrive avec un nom pertinent dans chaque scénario.


## Exemple : formulaire Tally vers document {#example-tally-form}

Cet exemple montre un scénario complet qui reçoit une soumission de formulaire [Tally](https://tally.so/), génère un document et l’envoie par e-mail.

### Le formulaire Tally {#the-tally-form}

Le scénario utilise un formulaire Tally comme source de données :

![Formulaire Tally utilisé comme trigger du scénario](https://pdfmonkey.io/fr/docs/img/make-tally-form.webp)

### Configuration du trigger {#setting-up-the-trigger}

Créez un nouveau scénario avec le trigger **Watch New Responses** de Tally. Make crée une URL de webhook et l’associe automatiquement à votre formulaire Tally.

![Configuration du webhook Tally dans Make](https://pdfmonkey.io/fr/docs/img/make-tally-webhook-setup.webp)

Envoyez une réponse de test et cliquez sur **Run once** pour vérifier la connexion :

![Bouton Run once dans le scénario Make](https://pdfmonkey.io/fr/docs/img/make-run-once-trigger.webp)

![Données du trigger reçues depuis Tally](https://pdfmonkey.io/fr/docs/img/make-trigger-data-received.webp)

### Association des champs et génération {#mapping-fields-and-generating}

Avec les données du trigger disponibles, configurez le module PDFMonkey pour associer les champs Tally aux variables de votre modèle, puis ajoutez les modules HTTP et e-mail comme décrit dans [Utiliser le fichier généré](#working-with-the-generated-file).

> [!WARNING]
> **Publiez toujours votre modèle**
>
> Si les documents générés ne correspondent pas à votre modèle, vérifiez que vous l’avez bien publié. Oublier de publier après des modifications est une erreur courante, surtout lorsque vous alternez entre Make et PDFMonkey.


## Résolution de problèmes {#troubleshooting}

### Échappement JSON {#json-escaping}

Le module Make envoie les données au format JSON. Si vos données contiennent des guillemets doubles ou des sauts de ligne, le JSON devient invalide. Par exemple, un nom comme `Peter "Spider-Man" Parker` casse la structure JSON.

Remplacez `"` par `\"` dans les valeurs pour échapper les guillemets doubles :

![Configuration de l’échappement JSON dans Make](https://pdfmonkey.io/fr/docs/img/make-json-escaping.webp)

Les sauts de ligne (`\n`) nécessitent le même traitement : remplacez `\n` par `\\n` pour garder le JSON valide.

### Modèle non publié {#template-not-published}

Si les documents générés ne reflètent pas vos dernières modifications du modèle, la cause la plus probable est un modèle non publié. Ouvrez votre modèle dans PDFMonkey et cliquez sur **Publish** avant de relancer le scénario.

### URL de téléchargement expirée {#download-url-expired}

L’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) est valide pendant 1 heure. Si un module situé plus loin dans votre scénario échoue parce que l’URL a expiré, rapprochez l’étape HTTP **Get a File** du module PDFMonkey pour que le téléchargement se fasse immédiatement.

Pour plus de détails, consultez [L’URL de téléchargement retourne une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md).

## Prochaines étapes {#next-steps}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : créez votre compte PDFMonkey et votre premier modèle
- [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) : apprenez à structurer le payload JSON de vos modèles
- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) : contrôlez le nom des fichiers générés
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprenez le cycle de vie d’un document généré
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : recevez des notifications en temps réel lorsque des documents sont générés
- Explorez d’autres intégrations : [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md), [Workato](https://pdfmonkey.io/fr/docs/integrations/workato.md)


---

# Intégration n8n : automatiser la génération de documents

Source: https://pdfmonkey.io/fr/docs/integrations/n8n.md
Le nœud PDFMonkey pour n8n vous permet de générer, récupérer, télécharger et supprimer des documents directement depuis vos workflows n8n. Si vous configurez PDFMonkey avec n8n pour la première fois, commencez par la section [Premiers pas](#getting-started) ci-dessous.

## Premiers pas {#getting-started}

n8n est une plateforme d’automatisation de workflows qui connecte différentes applications et services entre eux. C’est une alternative open-source à des outils comme [Zapier](zapier.md) et [Make](make.md), proposant des options cloud et auto-hébergées.

Avant de commencer, assurez-vous d’avoir :

- Un compte PDFMonkey ([inscrivez-vous ici](https://dashboard.pdfmonkey.io/register))
- Un compte ou une instance n8n ([inscrivez-vous sur n8n.io](https://n8n.io) ou [auto-hébergez](https://docs.n8n.io/hosting/))
- Votre clé API PDFMonkey
- Un modèle publié dans PDFMonkey

Pour le guide complet de création de compte et de configuration d’un modèle, consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

### Configuration des identifiants {#setting-up-credentials}

Avant d’utiliser le nœud PDFMonkey, vous devez configurer vos identifiants API :

1. Dans votre workflow n8n, ajoutez un nœud PDFMonkey
2. Cliquez sur **Create New Credentials**
3. Saisissez votre clé API PDFMonkey (disponible dans [votre tableau de bord PDFMonkey](https://dashboard.pdfmonkey.io/account))
4. Cliquez sur **Save**

> [!TIP]
> **Où trouver votre clé API**
>
> Votre clé API est disponible dans votre tableau de bord PDFMonkey sous **Account** puis **API**. Consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md) pour plus de détails.


### Votre premier workflow {#your-first-workflow}

Créons un workflow simple qui génère un document lorsqu’il est déclenché manuellement. Utilisez le modèle que vous avez créé dans [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md), ou créez un modèle simple avec une variable de salutation.

#### Étape 1 : ajouter un Manual Trigger

1. Créez un nouveau workflow dans n8n
2. Le nœud **Manual Trigger** devrait déjà être présent
3. Cela vous permettra de tester votre workflow manuellement

#### Étape 2 : ajouter le nœud PDFMonkey

1. Cliquez sur le bouton **+** pour ajouter un nouveau nœud
2. Recherchez **PDFMonkey**
3. Sélectionnez le nœud **PDFMonkey**
4. Choisissez **Generate Document** comme opération

#### Étape 3 : configurer l’opération Generate Document

Dans la configuration du nœud PDFMonkey :

1. Sélectionnez vos identifiants PDFMonkey (ou créez-les si ce n’est pas déjà fait)
2. Définissez l’identifiant de votre modèle PDFMonkey
3. Réglez la **Payload Input Method** sur **Key-Value Pairs**
4. Ajoutez les champs suivants :
   - Key : `name` → Value : `Peter Parker`
   - Key : `favoriteNumber` → Value : `8`

> [!NOTE]
> **Méthodes de payload**
>
> Vous pouvez choisir entre **Key-Value Pairs** (simple) ou **JSON** (pour les structures de données complexes). La méthode JSON est détaillée dans la section [Générer un document](#generate-a-document) ci-dessous.


> [!NOTE]
> **Nommage des variables**
>
> Les noms de variables dans votre modèle doivent respecter des règles de formatage spécifiques. Consultez la référence sur le [nommage des variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour les formats corrects et incorrects.


#### Étape 4 : tester votre workflow

1. Cliquez sur **Execute Workflow** (le bouton play en bas)
2. Attendez quelques secondes que le document se génère
3. Vous devriez voir les détails du document dans la sortie
4. Le fichier est maintenant disponible à l’adresse `download_url` fournie

#### Étape 5 : télécharger le fichier (optionnel)

Si vous souhaitez télécharger le fichier généré en tant que données binaires dans n8n :

1. Activez **Download File** dans les options du nœud PDFMonkey
2. Le fichier sera disponible en tant que données binaires dans les nœuds suivants

### Exemple : webhook vers document puis email {#example-webhook-to-document-to-email}

Créons un workflow plus pratique qui :
1. Reçoit des données depuis un webhook
2. Génère un document avec PDFMonkey
3. Envoie le document par email

#### Structure du workflow

1. Nœud **Webhook** : reçoit les données du formulaire
2. Nœud **PDFMonkey** : génère le document
3. Nœud **Send Email** : envoie le fichier en pièce jointe

#### Configuration

**Nœud Webhook :**
- Méthode : POST
- Chemin : `/generate-document`

**Nœud PDFMonkey :**
- Opération : Generate Document
- Sélectionnez votre modèle
- Associez les données du webhook aux variables du modèle :
  - `name` → `{{ $json.name }}`
  - `favoriteNumber` → `{{ $json.favoriteNumber }}`
- Activez l’option **Download File**

**Nœud Send Email :**
- Utilisez Gmail, SendGrid ou tout service SMTP
- Dans les pièces jointes, référencez les données binaires PDFMonkey :
  - Property Name : `data`
  - File Name : `document.pdf`

> [!TIP]
> **Tester les webhooks**
>
> Utilisez l’**URL de test** fournie par n8n pour envoyer des requêtes POST avec des données JSON comme :
&gt; ```json
&gt; {
&gt;   &#34;name&#34;: &#34;John Doe&#34;,
&gt;   &#34;favoriteNumber&#34;: 42
&gt; }
&gt; ```


Vous avez configuré avec succès votre premier workflow PDFMonkey dans n8n.

## Générer un document {#generate-a-document}

L’opération Generate Document crée un document à partir de l’un de vos modèles PDFMonkey. Vous fournissez un modèle et un [payload de données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md), et PDFMonkey génère le fichier.

### Méthodes d’entrée du payload {#payload-input-methods}

Le nœud PDFMonkey propose deux façons d’envoyer des données à votre modèle.

**Key-Value Pairs (mode simple)** est la méthode la plus facile pour envoyer des structures de données simples. Vous ajoutez les champs un par un, chacun avec une clé (le nom de la variable dans votre modèle) et une valeur (statique ou dynamique provenant des nœuds précédents).

**JSON Format (mode avancé)** gère les structures de données complexes, les objets imbriqués ou les tableaux. Utilisez le JSON lorsque votre modèle attend des données structurées :

```json title="Payload JSON"
{
  "customer": {
    "name": "Acme Inc.",
    "email": "contact@acme.com",
    "address": {
      "street": "123 Main St",
      "city": "New York",
      "zip": "10001"
    }
  },
  "items": [
    {
      "product": "Widget",
      "quantity": 5,
      "price": 10.99
    },
    {
      "product": "Gadget",
      "quantity": 2,
      "price": 24.99
    }
  ],
  "total": 104.93
}
```

Dans votre modèle, accédez aux données imbriquées avec la notation par points :

```liquid title="HTML"
<h2>Invoice for {{customer.name}}</h2>
<p>{{customer.address.street}}, {{customer.address.city}}</p>

{% for item in items %}
  <p>{{item.product}} x{{item.quantity}} = {{item.price}}</p>
{% endfor %}
```

Pour en savoir plus sur la structuration de vos données dynamiques, consultez [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md).

### Utilisation des expressions {#using-expressions}

Les expressions n8n vous permettent de référencer dynamiquement les données des nœuds précédents :

```javascript
{{ $json.customerName }}              // Champ simple
{{ $node["Webhook"].json["email"] }}  // Depuis un nœud spécifique
{{ $json.items.length }}              // Longueur du tableau
{{ new Date().toISOString() }}        // Date actuelle
```

Vous pouvez utiliser les expressions dans les valeurs des paires Key-Value, les payloads JSON (comme valeurs de chaîne), le champ de nom de fichier personnalisé et les champs de métadonnées.

### Nom de fichier personnalisé {#custom-filename}

Vous pouvez spécifier un nom personnalisé pour le fichier généré. Cela est utile lorsque vous stockez des fichiers dans Google Drive, Dropbox ou d’autres services de stockage.

Dans les options du nœud PDFMonkey :

1. Développez **Additional Options**
2. Définissez **Custom Filename**
3. Utilisez un nom statique ou des expressions n8n :

```
Invoice-{{ $json.invoiceNumber }}.pdf
Report-{{ $now.format('YYYY-MM-DD') }}.pdf
{{ $json.customerName }}-Contract.pdf
```

> [!WARNING]
> **Restrictions sur le nom de fichier**
>
> - N’utilisez pas de slashs `/` ni de backslashs `\`
&gt; - Évitez les caractères spéciaux qui pourraient causer des problèmes sur différents systèmes d’exploitation
&gt; - Les caractères non latins peuvent être échappés ou remplacés


Pour plus de détails sur les options de nom de fichier, consultez [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md).

### Métadonnées {#metadata}

Les métadonnées sont des informations supplémentaires attachées à un document qui n’apparaissent pas dans le fichier généré. Elles sont utiles pour suivre l’origine du document, stocker des identifiants de référence et filtrer dans les [webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md).

Pour ajouter des métadonnées :

1. Développez **Additional Options** dans le nœud PDFMonkey
2. Réglez **Metadata** sur **Key-Value Pairs** ou **JSON**
3. Ajoutez vos champs de métadonnées :

```json
{
  "orderId": "ORD-12345",
  "customerEmail": "john@example.com",
  "environment": "production"
}
```

Vous pouvez récupérer les métadonnées ultérieurement en utilisant l’opération Get Document ou dans les [triggers par webhook](#pdfmonkey-trigger).

> [!NOTE]
> **Métadonnées vs Payload**
>
> - **Payload (données dynamiques) :** Données utilisées pour générer le contenu du document
&gt; - **Metadata :** Informations attachées au document mais non visibles dans la sortie ; incluses dans les notifications webhook


### Attendre le document {#wait-for-document}

Par défaut, l’opération Generate Document attend que le document soit entièrement généré avant de continuer.

> [!NOTE]
> **Temps de génération du document**
>
> La plupart des documents se génèrent en quelques secondes. Les documents complexes avec de nombreuses pages, images ou du JavaScript peuvent prendre plus de temps. Consultez [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) pour le cycle de vie complet de la génération.


Si vous devez désactiver l’attente et gérer la complétion de manière asynchrone, vous pouvez utiliser le [trigger PDFMonkey](#pdfmonkey-trigger) ou le [polling](#polling-for-completion) à la place.

### Tableaux et données complexes {#arrays-and-complex-data}

n8n facilite le travail avec les tableaux provenant des nœuds précédents. Voici un exemple utilisant des données Google Sheets.

**Sortie du nœud Google Sheets :**

```json
[
  { "product": "Widget", "qty": 5, "price": 10 },
  { "product": "Gadget", "qty": 2, "price": 25 }
]
```

**Dans le nœud PDFMonkey (mode JSON) :**

```json
{
  "customerName": "{{ $json.customerName }}",
  "items": {{ $node["Google Sheets"].json }}
}
```

Le tableau est transmis directement à votre modèle où vous pouvez le parcourir :

```liquid
{% for item in items %}
  <tr>
    <td>{{item.product}}</td>
    <td>{{item.qty}}</td>
    <td>{{item.price}}</td>
  </tr>
{% endfor %}
```

Pour en savoir plus sur les boucles et le rendu conditionnel, consultez [Conditions et boucles](https://pdfmonkey.io/fr/docs/modeles-code/conditions-et-boucles.md).

### Traitement d’éléments multiples {#handling-multiple-items}

Si votre workflow traite plusieurs éléments (comme plusieurs clients ou commandes), utilisez le nœud **Split In Batches** de n8n :

```
1. Get Data (retourne 100 éléments)
2. Split In Batches (taille du lot : 1)
3. PDFMonkey - Generate Document (s’exécute 100 fois)
4. Stocker les fichiers
```

Ou utilisez le nœud **Loop Over Items** pour plus de contrôle.

> [!WARNING]
> **Limites de débit**
>
> Soyez attentif aux limites de votre plan PDFMonkey lorsque vous générez plusieurs documents. Envisagez d’ajouter des nœuds **Wait** entre les lots si vous générez de nombreux documents. Consultez [Limitation de débit](#rate-limiting) pour plus de détails, et [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) pour les informations de quota.


### Gestion des erreurs {#error-handling}

Utilisez les fonctionnalités de gestion d’erreurs de n8n pour gérer les échecs :

1. Cliquez sur le nœud PDFMonkey
2. Allez dans l’onglet **Settings**
3. Configurez **On Error** :
   - **Stop Workflow** (par défaut)
   - **Continue With Last Successful Item**
   - **Continue Execution**

Pour une gestion d’erreurs plus robuste, ajoutez un nœud **IF** après PDFMonkey pour vérifier le [statut du document](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) :

```
IF: {{ $json.status }} equals "success"
  -> TRUE : Continuer avec le fichier
  -> FALSE : Envoyer une notification d’erreur
```

## Trigger PDFMonkey {#pdfmonkey-trigger}

Le trigger PDFMonkey est un trigger basé sur les webhooks qui écoute les événements de génération de documents. Lorsqu’un document est terminé, PDFMonkey envoie une notification à votre workflow n8n. Cela est utile pour automatiser les actions post-génération comme le stockage de fichiers, l’envoi de notifications ou la mise à jour de bases de données.

Pour des informations de fond sur le fonctionnement des webhooks PDFMonkey (types d’événements, format du payload et vérification des signatures), consultez [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md).

### Configuration {#trigger-setup}

1. Dans votre workflow n8n, cliquez sur **+** pour ajouter un nouveau nœud
2. Recherchez **PDFMonkey Trigger** et sélectionnez-le comme point de départ de votre workflow
3. Sélectionnez vos identifiants API PDFMonkey
4. Choisissez les modèles à écouter :
   - **Any Template :** déclencher pour tous les documents de votre workspace
   - **Specific Template :** déclencher pour un seul modèle
   - **Multiple Templates :** déclencher pour plusieurs modèles sélectionnés
5. Copiez l’**URL de webhook** affichée par le nœud trigger
6. Dans votre [tableau de bord PDFMonkey](https://dashboard.pdfmonkey.io), allez dans la section **Webhooks**
7. Créez un nouvel endpoint avec l’URL de webhook n8n
8. Cochez les événements de succès et d’échec, puis cliquez sur **Create**
9. De retour dans n8n, activez le toggle **Activate** pour activer votre workflow

> [!NOTE]
> **Webhooks de production vs de test**
>
> n8n fournit deux URLs :
&gt; - **URL de test :** Pour tester dans l’éditeur n8n
&gt; - **URL de production :** Pour les workflows activés/publiés
&gt; 
&gt; Assurez-vous de mettre à jour l’URL de webhook dans PDFMonkey lors de l’activation de votre workflow.


### Données du trigger {#trigger-data}

Lorsqu’un document est terminé, le trigger reçoit un objet [DocumentCard](https://pdfmonkey.io/fr/docs/api/documents.md#the-documentcard-object). Celui-ci inclut les métadonnées du document, le statut et l’URL de téléchargement, mais n’inclut pas les données dynamiques originales que vous avez envoyées :

```json
{
  "document": {
    "id": "a5e86d72-f5b7-43d4-a04e-8b7e08e6741c",
    "app_id": "d6b4e8f2-7a3c-4d1e-9f5b-2c8a1d3e6f90",
    "created_at": "2050-03-13T12:34:56.181+02:00",
    "document_template_id": "2903f5b4-623b-4e10-b2e3-dc7e2e67ea39",
    "document_template_identifier": "My Invoice Template",
    "download_url": "https://pdfmonkey.s3.eu-west-1.amazonaws.com/...",
    "failure_cause": null,
    "filename": "2050-03-14 Peter Parker.pdf",
    "meta": {
      "_filename": "2050-03-14 Peter Parker.pdf",
      "clientRef": "spidey-616"
    },
    "output_type": "pdf",
    "preview_url": "https://preview.pdfmonkey.io/...",
    "public_share_link": null,
    "status": "success",
    "updated_at": "2050-03-13T12:34:59.412+02:00"
  }
}
```

> [!WARNING]
> **Les données dynamiques ne sont pas incluses**
>
> Le payload du webhook n’inclut pas les données dynamiques (payload) originales que vous avez envoyées pour générer le document. Si vous avez besoin de ces informations dans votre workflow, stockez-les dans le champ [métadonnées](#metadata) lors de la génération du document. Les métadonnées sont incluses dans chaque notification webhook.


### Téléchargement automatique {#auto-download}

Le trigger PDFMonkey dispose d’une option **Download File** qui télécharge automatiquement le fichier généré lorsque le trigger se déclenche.

Lorsqu’elle est activée :
- Le fichier est téléchargé en tant que données binaires
- Il est disponible immédiatement dans les nœuds suivants
- Pas besoin d’une opération Download File séparée

Pour l’activer :
1. Ouvrez les paramètres du nœud trigger
2. Développez **Additional Options**
3. Basculez **Download File** sur ON

Les données binaires sont disponibles avec la clé `data`.

### Cas d’utilisation {#trigger-use-cases}

**Stocker des fichiers dans Google Drive :**

```
1. PDFMonkey Trigger (Download File : activé)
2. Google Drive - Upload File
   - File : {{ $binary.data }}
   - Folder : /Invoices/
   - Filename : {{ $json.filename }}
```

**Envoyer une notification sur Slack :**

```
1. PDFMonkey Trigger
2. Slack - Send Message
   - Channel : #notifications
   - Message : "New document generated: {{ $json.filename }}"
   - Attachment : {{ $json.download_url }}
```

**Mettre à jour un enregistrement en base de données :**

```
1. PDFMonkey Trigger
2. Postgres - Update
   - Table : orders
   - Where : id = {{ $json.metadata.orderId }}
   - Set : pdf_url = {{ $json.download_url }}, status = 'completed'
```

**Envoyer le document par email au client :**

```
1. PDFMonkey Trigger (Download File : activé)
2. Gmail - Send Email
   - To : {{ $json.metadata.customerEmail }}
   - Subject : Your invoice is ready
   - Attachments : {{ $binary.data }}
```

### Métadonnées pour le routage {#metadata-for-routing}

Les métadonnées permettent des workflows conditionnels. Lors de la génération d’un document, attachez des informations de routage :

```json
{
  "metadata": {
    "documentType": "invoice",
    "customerId": "12345",
    "sendEmail": true
  }
}
```

Puis dans votre workflow déclenché, utilisez un nœud **IF** ou **Switch** pour router en fonction des métadonnées :

```
1. PDFMonkey Trigger
2. Nœud Switch
   - Case 1 : {{ $json.metadata.documentType }} = "invoice" -> Stocker en comptabilité
   - Case 2 : {{ $json.metadata.documentType }} = "report" -> Partager sur Slack
   - Case 3 : {{ $json.metadata.documentType }} = "contract" -> Stocker dans DocuSign
```

### Test {#trigger-testing}

**Méthode 1 : Générer un document de test.** Utilisez un autre workflow ou l’API pour générer un document, attendez que le webhook se déclenche, et vérifiez l’exécution du nœud trigger dans n8n.

**Méthode 2 : Utiliser le webhook de test.**

1. Cliquez sur **Listen for event** dans le nœud trigger
2. Générez un document depuis votre modèle PDFMonkey
3. Le trigger capture l’événement et affiche les données
4. Cliquez sur **Use test event** pour utiliser ces données lors de la construction de votre workflow

> [!TIP]
> **Déclencher depuis le tableau de bord**
>
> Vous pouvez déclencher manuellement une génération de test depuis l’éditeur de modèle PDFMonkey en cliquant sur le bouton **Generate**. Cela déclenche le webhook immédiatement.


Vous pouvez également avoir plusieurs workflows n8n à l’écoute du même modèle. Chaque webhook reçoit la notification indépendamment, ce qui est utile pour séparer les environnements ou avoir différents workflows pour différents types de documents.

### Garanties de livraison {#delivery-guarantees}

PDFMonkey utilise [Svix](https://www.svix.com/) pour livrer les webhooks. Les livraisons suivent ces garanties :

- **Livraison au moins une fois :** vous pourriez recevoir le même événement plusieurs fois
- **Ordre au mieux :** les événements sont généralement dans l’ordre mais ce n’est pas garanti
- **Réessais automatiques :** les livraisons échouées sont réessayées avec un backoff exponentiel
- **Vérification de signature :** chaque webhook est signé pour que vous puissiez vérifier son authenticité

> [!NOTE]
> **Rendez votre workflow idempotent**
>
> Comme les webhooks peuvent être livrés plusieurs fois, concevez votre workflow pour gérer les événements dupliqués correctement. Utilisez les identifiants de documents pour vérifier si vous avez déjà traité un événement.


Pour tous les détails sur la configuration des webhooks (routage par canal et vérification de signature), consultez [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md).

## Autres opérations {#other-operations}

Au-delà de la génération de documents et de la réaction aux triggers, le nœud PDFMonkey prend en charge plusieurs opérations de gestion de documents.

### Récupérer un document {#get-document}

L’opération Get Document récupère les informations d’un document précédemment généré. Utilisez-la pour vérifier le [statut d’un document](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md), récupérer son [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md), accéder aux métadonnées attachées ou vérifier qu’un document existe avant traitement.

**Champ requis :** Document ID

```
Document ID : {{ $json.documentId }}
```

L’opération retourne les informations complètes du document incluant le statut, l’URL de téléchargement, l’URL de prévisualisation, les métadonnées et les horodatages.

**Valeurs de statut du document :**
- `draft` — le document est créé mais pas encore en file d’attente pour la génération
- `pending` — le document est en file d’attente pour la génération
- `generating` — le document est en cours de rendu
- `success` — le document a été généré avec succès
- `failure` — la génération a échoué (vérifiez `failure_cause` pour les détails)

Pour le cycle de vie complet des statuts, consultez [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md).

### Télécharger un fichier {#download-file}

L’opération Download File télécharge un fichier généré en tant que données binaires. Utilisez-la pour télécharger un fichier généré précédemment, obtenir des données binaires séparément de la génération ou re-télécharger un document pour traitement.

**Champ requis :** Document ID

**Champ optionnel :** Binary Property Name (par défaut : `data`)

```
Document ID : {{ $json.documentId }}
Binary Property Name : pdfFile
```

Le fichier est stocké en tant que données binaires et peut être utilisé dans les pièces jointes d’email, les nœuds de stockage de fichiers (Google Drive, Dropbox, etc.), les uploads FTP ou d’autres nœuds de traitement.

> [!NOTE]
> **Generate Document inclut le téléchargement**
>
> Si vous générez et téléchargez immédiatement, utilisez l’option **Download File** dans l’opération Generate Document plutôt qu’un nœud Download File séparé.


### Supprimer un document {#delete-document}

L’opération Delete Document supprime définitivement un document de PDFMonkey. Utilisez-la pour nettoyer après l’envoi d’un document, supprimer des documents contenant des données sensibles, gérer les quotas de stockage ou implémenter des politiques de rétention de documents.

**Champ requis :** Document ID

```
Document ID : {{ $json.documentId }}
```

> [!WARNING]
> **La suppression est définitive**
>
> Une fois supprimés, les documents ne peuvent pas être récupérés. L’URL de téléchargement ne fonctionnera plus. Assurez-vous d’avoir sauvegardé le fichier ailleurs si vous en avez besoin.


> [!NOTE]
> **Le TTL comme alternative**
>
> Envisagez d’utiliser la [suppression automatique (TTL)](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) plutôt que de supprimer manuellement les documents. Vous pouvez configurer la suppression automatique des documents après une période configurable lors de la génération.


### Polling de complétion {#polling-for-completion}

Si vous avez généré un document avec **Wait for Document** désactivé, vous pouvez utiliser le polling pour vérifier sa complétion au lieu d’un trigger webhook :

```
1. PDFMonkey - Generate Document (Wait : désactivé)
2. Wait (10 secondes)
3. PDFMonkey - Get Document
   - Document ID : {{ $node["PDFMonkey"].json.id }}
4. Nœud IF
   - {{ $json.status }} = "success"
   - TRUE : Continuer avec le fichier
   - FALSE : Retourner à l’étape 2
```

> [!NOTE]
> **Meilleure approche : utiliser le trigger**
>
> Au lieu du polling, envisagez d’utiliser le [trigger PDFMonkey](#pdfmonkey-trigger) pour être notifié lorsque les documents sont prêts. Les triggers sont plus efficaces et répondent plus rapidement.


### Combiner les opérations {#combining-operations}

**Générer, stocker et nettoyer :**

```
1. Manual Trigger
2. PDFMonkey - Generate Document (Download : activé)
3. Google Drive - Upload File
   - File : {{ $binary.data }}
   - Folder : /Invoices/
4. Postgres - Insert
   - Table : documents
   - Data : {
       drive_url : {{ $node["Google Drive"].json.webViewLink }},
       pdfmonkey_id : {{ $node["PDFMonkey"].json.id }}
     }
5. PDFMonkey - Delete Document
   - Document ID : {{ $node["PDFMonkey"].json.id }}
```

**Téléchargement conditionnel basé sur le statut :**

```
1. Webhook (reçoit l’identifiant du document)
2. PDFMonkey - Get Document
   - Document ID : {{ $json.documentId }}
3. Nœud IF
   - Condition : {{ $json.status }} = "success"
   - TRUE :
     4a. PDFMonkey - Download File
     5a. Envoyer au client
   - FALSE :
     4b. Envoyer une notification d’erreur
     5b. PDFMonkey - Delete Document (nettoyage de la tentative échouée)
```

**Re-générer et remplacer :**

```
1. Webhook (reçoit la mise à jour de commande)
2. PDFMonkey - Delete Document
   - Document ID : {{ $json.oldDocumentId }}
3. PDFMonkey - Generate Document
   - Template : Invoice
   - Payload : {{ $json.updatedData }}
4. Mettre à jour la base de données avec le nouvel identifiant de document
```

## Résolution de problèmes {#troubleshooting}

### Erreurs d’authentification {#authentication-errors}

**Clé API invalide :**

```
401 Unauthorized - Invalid API key
```

1. Allez dans votre [tableau de bord PDFMonkey](https://dashboard.pdfmonkey.io/account)
2. Naviguez vers **Account** puis **API**
3. Copiez votre clé API
4. Dans n8n, mettez à jour vos identifiants PDFMonkey avec la bonne clé
5. Testez la connexion

Pour en savoir plus sur l’authentification API, consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md).

> [!NOTE]
> **Workspaces multiples**
>
> Si vous avez plusieurs workspaces PDFMonkey, assurez-vous d’utiliser la clé API du bon workspace.


Si vos identifiants cessent soudainement de fonctionner, supprimez les anciens identifiants dans n8n, créez-en de nouveaux avec une clé API fraîche, et mettez à jour tous les nœuds utilisant ces identifiants.

### Modèle introuvable {#template-not-found}

```
404 Not Found - Template does not exist
```

**Causes :** le modèle a été supprimé, le mauvais workspace ou la mauvaise clé API est utilisé, ou l’identifiant du modèle est incorrect.

**Solution :** Vérifiez que le modèle existe dans votre tableau de bord PDFMonkey, vérifiez que vous utilisez la bonne clé API, et re-sélectionnez le modèle depuis le menu déroulant dans n8n.

**Modèle non publié :**

```
422 Unprocessable Entity - Template is not published
```

Allez dans votre modèle dans PDFMonkey et assurez-vous qu’il est publié en cliquant sur le bouton **Publish**, puis réessayez la génération.

> [!WARNING]
> **Erreur courante**
>
> C’est l’une des erreurs les plus fréquentes. Pensez toujours à publier votre modèle après avoir effectué des modifications.


### Payload invalide {#invalid-payload}

```
422 Unprocessable Entity - Invalid payload
```

**Causes :** syntaxe JSON invalide (en mode JSON), mauvais types de données ou champs requis manquants.

Problèmes courants de syntaxe JSON :

**Guillemets manquants :**
```json
// Incorrect
{ name: "John" }

// Correct
{ "name": "John" }
```

**Virgules en fin de ligne :**
```json
// Incorrect
{
  "name": "John",
  "age": 30,
}

// Correct
{
  "name": "John",
  "age": 30
}
```

**Guillemets doubles non échappés dans les valeurs :**
```json
// Incorrect - les guillemets imbriqués cassent le JSON
{ "name": "Peter "Spider-Man" Parker" }

// Correct - échapper les guillemets internes avec un backslash
{ "name": "Peter \"Spider-Man\" Parker" }
```

**Utilisation des expressions n8n dans le JSON :**

Lorsque vous utilisez des expressions, assurez-vous de sérialiser les objets :

```json
// Incorrect - Créera un JSON invalide
{
  "items": {{ $json.items }}
}

// Correct - Sérialiser correctement
{
  "items": {{ JSON.stringify($json.items) }}
}
```

> [!TIP]
> **Utilisez le mode Key-Value Pairs**
>
> Si vous avez des difficultés avec la syntaxe JSON, passez en mode **Key-Value Pairs**. n8n gère automatiquement tout l’échappement et le formatage.


### Erreurs de téléchargement {#download-errors}

**URL de téléchargement expirée :**

```
403 Forbidden - Download URL has expired
```

Les [URLs de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) expirent après 1 heure pour des raisons de sécurité.

**Option 1 :** Utilisez Get Document pour obtenir une URL fraîche, puis téléchargez depuis la nouvelle URL avec un nœud HTTP Request.

**Option 2 :** Activez l’option **Download File** dans le nœud Generate Document pour télécharger immédiatement après la génération.

**Option 3 :** Stockez les données binaires dans un service de stockage (Google Drive, S3, etc.) plutôt que de dépendre des URLs PDFMonkey.

Pour plus de détails, consultez [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md).

**Données binaires non disponibles :**

Si aucune donnée binaire n’est disponible pour la pièce jointe ou le stockage, assurez-vous que **Download File** est activé :
- Dans l’opération **Generate Document** : Additional Options puis Download File
- Dans le **PDFMonkey Trigger** : Additional Options puis Download File
- Ou utilisez explicitement une opération **Download File**

### Problèmes de webhook {#webhook-issues}

**Le webhook ne reçoit pas d’événements :**

1. Le workflow est **activé** (pas seulement sauvegardé)
2. L’URL du webhook est correcte dans PDFMonkey
3. Utilisation de l’**URL de production** et non l’URL de test
4. Le modèle est publié
5. Le pare-feu ne bloque pas les requêtes

**Pour déboguer :** vérifiez l’onglet **Executions** dans n8n pour les erreurs, allez dans les paramètres du modèle dans le tableau de bord PDFMonkey et vérifiez les journaux de livraison des webhooks, et essayez de générer manuellement un document de test. Consultez [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour les détails de configuration des webhooks.

**Réception d’événements webhook en double :** c’est un comportement attendu. Les webhooks PDFMonkey utilisent une livraison au moins une fois. Rendez votre workflow idempotent en vérifiant si vous avez déjà traité un document :

```
1. PDFMonkey Trigger
2. Postgres - Vérifier si l’identifiant du document existe
3. Nœud IF
   - Déjà traité : Arrêter
   - Nouveau document : Continuer le traitement
```

**Mauvaise URL de webhook :** Après l’activation de votre workflow, l’URL du webhook passe de Test à Production. Copiez l’**URL de production** depuis le nœud trigger et mettez à jour l’URL du webhook dans vos paramètres PDFMonkey.

### Erreurs d’expression {#expression-errors}

**Cannot read property of undefined :**

```
Cannot read property 'field' of undefined
```

Cela se produit lorsque vous essayez d’accéder à des données qui n’existent pas depuis un nœud précédent.

**Vérifiez le nom du nœud :**
```javascript
// Mauvais nom de nœud
{{ $node["PDFmonkey"].json.id }}

// Bon nom de nœud (M majuscule)
{{ $node["PDFMonkey"].json.id }}
```

**Vérifiez que les données existent :**
```javascript
// Suppose que le champ existe
{{ $json.customer.email }}

// Utilisez le chaînage optionnel (n8n 1.0+)
{{ $json.customer?.email }}

// Ou fournissez une valeur par défaut
{{ $json.customer?.email || 'no-email@example.com' }}
```

Utilisez l’éditeur d’expressions dans n8n (cliquez sur le bouton **Expression**) et utilisez l’autocomplétion pour vous assurer de référencer les bons champs.

### Timeout du workflow {#workflow-timeout}

```
Workflow execution timed out
```

**Causes :** document prenant trop de temps à se générer, problèmes réseau ou téléchargement de fichiers volumineux.

**Option 1 :** Augmentez le timeout dans les paramètres du workflow (Execution Timeout).

**Option 2 :** Désactivez « Wait for Document » et utilisez un [trigger webhook](#pdfmonkey-trigger) dans un workflow séparé.

**Option 3 :** Découpez en plusieurs workflows et utilisez des webhooks pour les chaîner.

### Erreurs de mémoire {#memory-errors}

```
JavaScript heap out of memory
```

Cela se produit lors du traitement de fichiers ou de données très volumineux dans n8n.

**Solutions :**
1. Traitez les éléments par lots plus petits (utilisez le nœud Split In Batches)
2. Utilisez le streaming lorsque c’est possible
3. Augmentez l’allocation mémoire de n8n (auto-hébergé uniquement)
4. Stockez les fichiers volumineux en externe plutôt que de les faire transiter par le workflow

### Limitation de débit {#rate-limiting}

```
429 Too Many Requests - Rate limit exceeded
```

Ajoutez des nœuds **Wait** entre les opérations lors du traitement de plusieurs documents :

```
1. Récupérer les éléments à traiter
2. Split In Batches (taille : 10)
3. Wait (5 secondes)
4. PDFMonkey - Generate Document
5. Boucle
```

Ou utilisez le nœud **Code** pour ajouter des délais :

```javascript
// Attendre 1 seconde par élément
await new Promise(resolve => setTimeout(resolve, 1000));
return items;
```

### Formatage JSON {#json-formatting}

**Sauts de ligne dans le JSON :** le JSON ne prend pas en charge les sauts de ligne bruts dans les chaînes :

```json
// Incorrect
{
  "description": "Line 1
Line 2"
}

// Correct
{
  "description": "Line 1\nLine 2"
}
```

Ou utilisez un nœud **Code** pour échapper :

```javascript
items[0].json.description = items[0].json.description.replace(/\n/g, '\\n');
return items;
```

**Caractères spéciaux :** échappez les guillemets doubles dans les valeurs de chaîne :

```json
// Incorrect - les guillemets non échappés cassent le JSON
{ "html": "<div class="test">Hello</div>" }

// Correct - guillemets internes échappés
{ "html": "<div class=\"test\">Hello</div>" }
```

Ou utilisez le mode **Key-Value Pairs** qui gère l’échappement automatiquement.

## Prochaines étapes {#next-steps}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : configurez votre compte PDFMonkey et créez votre premier modèle
- [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) : apprenez à structurer le payload JSON pour vos modèles
- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) : contrôlez le nom des fichiers générés
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprenez le cycle de vie d’un document généré
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : recevez des notifications en temps réel lorsque les documents sont générés
- [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) : fonctionnement des liens de téléchargement temporaires et leur actualisation
- [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : configurez le nettoyage automatique des documents avec le TTL
- Explorez d’autres intégrations : [Zapier](zapier.md), [Make](make.md), [Workato](workato.md)

## Besoin d’aide supplémentaire ? {#need-more-help}

Si vous rencontrez toujours des problèmes :

1. **Documentation n8n :** [docs.n8n.io](https://docs.n8n.io)
2. **Statut PDFMonkey :** [status.pdfmonkey.io](https://status.pdfmonkey.io)
3. **Communauté n8n :** [community.n8n.io](https://community.n8n.io)
4. **Support PDFMonkey :** support@pdfmonkey.io

> [!NOTE]
> **Incluez les détails dans vos demandes de support**
>
> Lorsque vous demandez de l’aide, incluez le message d’erreur complet, votre version de n8n, une capture d’écran du workflow et les étapes pour reproduire le problème.



---

# Intégration Workato : automatiser la génération de documents

Source: https://pdfmonkey.io/fr/docs/integrations/workato.md

Le connecteur PDFMonkey pour [Workato](https://www.workato.com/) vous permet de générer, surveiller et nettoyer des documents dans le cadre de vos recettes automatisées. Combinez-le avec des déclencheurs provenant de CRM, de constructeurs de formulaires ou de bases de données pour produire et envoyer des fichiers sans écrire de code.

## Configuration {#setup}

Avant de commencer, assurez-vous de disposer des éléments suivants :

- Un compte PDFMonkey ([inscription ici](https://dashboard.pdfmonkey.io/register))
- Un compte [Workato](https://www.workato.com/)
- Un modèle publié dans PDFMonkey

Pour la création de compte et la configuration d’un modèle, consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

Pour connecter PDFMonkey à Workato :

1. Ajoutez le connecteur **PDFMonkey** à votre recette.
2. Créez une nouvelle connexion et saisissez votre clé secrète API, disponible sur la page [Mon compte](https://dashboard.pdfmonkey.io/account).

Une fois connecté, les actions et triggers PDFMonkey sont disponibles dans les étapes de votre recette.

## Générer un document {#generate-a-document}

Utilisez l’action **Generate Document** pour créer un document à partir de l’un de vos modèles.

1. Sélectionnez le modèle à utiliser pour la génération.
2. Fournissez les [données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) sous forme de payload JSON. Ces données alimentent les variables définies dans votre modèle.
3. Vous pouvez optionnellement joindre des [métadonnées](#metadata) (comme un nom de fichier personnalisé ou un identifiant de référence pour le traitement en aval).

> [!NOTE]
> **Nommage des variables**
>
> Les noms de variables dans votre modèle doivent suivre des règles de formatage spécifiques. Consultez la référence sur le [nommage des variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour les formats corrects et incorrects.


La génération de document est asynchrone : l’action envoie la demande de génération et retourne immédiatement. Utilisez le [trigger Document Generated](#document-generated-trigger) ci-dessous pour réagir lorsque le fichier est prêt.

### Nom de fichier personnalisé {#custom-filename}

Vous pouvez spécifier un nom personnalisé pour le fichier généré. C’est utile lorsque vous stockez des documents dans des services comme Google Drive, Dropbox ou une autre plateforme de stockage cloud.

Gardez ces restrictions à l’esprit :

- Le nom de fichier ne doit contenir ni barre oblique `/` ni barre oblique inversée `\`
- Les caractères non latins sont à éviter car ils peuvent être corrompus lors de l’enregistrement du fichier

Les noms courts basés sur des dates ou des identifiants fonctionnent généralement le mieux.

> [!TIP]
> Pour plus de détails sur les options de nommage (y compris la définition du nom de fichier via l’API), consultez [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md).


### Métadonnées {#metadata}

Lorsque vous générez un document, vous pouvez y attacher des métadonnées. Les métadonnées ne sont pas disponibles dans le modèle et n’influencent pas le contenu du document ; elles sont simplement attachées au document pour une utilisation ultérieure.

Un cas d’usage courant consiste à recevoir le document via un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) et à utiliser ses métadonnées pour le router ou le traiter différemment dans votre automatisation.

## Trigger Document Generated {#document-generated-trigger}

Utilisez le trigger **Document Generated** pour démarrer une recette lorsqu’un document termine sa génération. C’est la méthode recommandée pour gérer le flux de génération asynchrone.

Le trigger fournit les données du document terminé, notamment :

- **Download URL :** un lien temporaire vers le fichier généré (valide pendant 1 heure). Consultez [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour plus de détails.
- **Filename :** le nom du fichier généré
- **Metadata :** les métadonnées jointes lors de la génération
- **Status :** le résultat de la génération (`success` ou `failure`). Consultez [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) pour le cycle de vie complet.

Vous pouvez filtrer par modèle pour vous assurer que la recette ne s’exécute que pour les documents d’un modèle spécifique.

> [!WARNING]
> **Les données dynamiques ne sont pas incluses**
>
> Le trigger n’inclut pas les données dynamiques (payload) d’origine envoyées pour générer le document. Si vous avez besoin de ces informations dans les étapes suivantes de la recette, stockez-les dans le champ [métadonnées](#metadata) lors de la génération du document.


## Supprimer un document {#delete-a-document}

Utilisez l’action **Delete Document** pour supprimer un document précédemment généré de votre compte PDFMonkey. Cela est utile pour nettoyer les documents après qu’ils ont été téléchargés, envoyés par e-mail ou stockés ailleurs dans votre flux.

> [!TIP]
> **Nettoyage automatique**
>
> Plutôt que de supprimer manuellement les documents, envisagez d’utiliser la [suppression automatique (TTL)](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) pour que les documents soient nettoyés après une période configurable.


## Exemples de recettes {#example-recipes}

### Soumission de formulaire vers document puis e-mail {#form-to-email}

1. Déclenchez sur une soumission de formulaire (depuis une application connectée).
2. Utilisez **Generate Document** pour créer le document avec les données du formulaire.
3. Utilisez **Document Generated** pour attendre le fichier.
4. Téléchargez le fichier et envoyez-le en pièce jointe d’un e-mail.

### Enregistrement CRM vers document puis stockage cloud {#crm-to-storage}

1. Déclenchez sur un enregistrement CRM nouveau ou mis à jour.
2. Utilisez **Generate Document** pour créer un contrat, une facture ou un rapport.
3. Utilisez **Document Generated** pour obtenir l’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md).
4. Importez le fichier vers Google Drive, Dropbox ou un autre service de stockage.

### Générer, stocker et nettoyer {#generate-store-cleanup}

1. Déclenchez sur un événement dans votre application (nouvelle commande, contrat approuvé, etc.).
2. Utilisez **Generate Document** pour créer le fichier.
3. Utilisez **Document Generated** pour obtenir l’URL de téléchargement.
4. Importez le fichier vers un stockage permanent (S3, Google Drive, Sharepoint).
5. Utilisez **Delete Document** pour supprimer le fichier de PDFMonkey.

## Résolution de problèmes {#troubleshooting}

### URL de téléchargement expirée {#download-url-expired}

L’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) est valide pendant 1 heure. Si une étape ultérieure de votre recette échoue parce que l’URL a expiré, restructurez votre recette pour que le téléchargement se fasse immédiatement après le déclenchement du trigger **Document Generated**.

Pour plus de détails, consultez [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md).

### Modèle non publié {#template-not-published}

Si les documents générés ne reflètent pas vos dernières modifications de modèle, la cause la plus probable est un modèle non publié. Ouvrez votre modèle dans PDFMonkey et cliquez sur **Publish** avant de relancer la recette.

> [!WARNING]
> **Erreur fréquente**
>
> Oublier de publier votre modèle est une erreur courante, surtout lorsque vous alternez entre Workato et PDFMonkey. Pensez toujours à publier après avoir effectué des modifications.


## Étapes suivantes {#next-steps}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : créez votre compte PDFMonkey et votre premier modèle
- [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) : apprenez à structurer le payload JSON pour vos modèles
- [Nom de fichier personnalisé](https://pdfmonkey.io/fr/docs/generation-de-documents/nom-de-fichier-personnalise.md) : contrôlez le nom des fichiers générés
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprenez le cycle de vie d’un document généré
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : recevez des notifications en temps réel lorsque les documents sont générés
- [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : configurez le nettoyage automatique des documents avec le TTL
- Explorez d’autres intégrations : [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [Make](https://pdfmonkey.io/fr/docs/integrations/make.md), [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md)


## FAQ

**Comment générer des documents avec PDFMonkey et Workato ?**

Ajoutez le connecteur PDFMonkey à votre recette Workato, saisissez votre clé secrète API pour vous connecter, puis utilisez l’action Generate Document pour créer un document à partir d’un modèle avec votre payload de données dynamiques.

**Comment savoir quand un document PDFMonkey est prêt dans Workato ?**

Utilisez le trigger Document Generated pour démarrer une étape de recette quand un document finit d’être généré. Il fournit l’URL de téléchargement, le nom de fichier, les métadonnées et le statut. Vous pouvez filtrer par modèle pour que la recette ne s’exécute que pour des documents spécifiques.

**Peut-on supprimer automatiquement des documents après traitement dans Workato ?**

Oui. Utilisez l’action Delete Document dans une étape ultérieure de la recette pour supprimer le document de PDFMonkey après l’avoir téléchargé, envoyé par email ou stocké. Vous pouvez aussi configurer la suppression automatique (TTL) dans PDFMonkey pour nettoyer les documents après une durée définie.


---

# Intégration Bubble : générer des documents dans votre application Bubble

Source: https://pdfmonkey.io/fr/docs/integrations/bubble.md

Le plugin officiel PDFMonkey pour [Bubble](https://bubble.io/) vous permet de générer des documents directement depuis vos workflows Bubble, sans écrire de code backend. Installez-le depuis le marketplace Bubble, ajoutez une seule action à votre workflow et récupérez une URL de téléchargement dès que le document est prêt.

Il existe deux façons de connecter PDFMonkey à Bubble :

- **[Plugin PDFMonkey](#pdfmonkey-plugin)** (recommandé) : installez-le depuis le marketplace pour une intégration sans code avec polling intégré.
- **[API Connector](#api-connector)** : appelez l’API REST PDFMonkey directement pour un contrôle total sur les requêtes et les réponses.

## Prérequis {#prerequisites}

Avant de commencer, assurez-vous de disposer des éléments suivants :

- Un compte PDFMonkey ([inscription ici](https://dashboard.pdfmonkey.io/register))
- Un compte [Bubble](https://bubble.io/) avec une application
- Un modèle publié dans PDFMonkey

Pour la création de compte et la configuration d’un modèle, consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

Vous avez également besoin de votre **clé secrète API**, disponible sur la page [Mon compte](https://dashboard.pdfmonkey.io/account). Consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md) pour plus de détails.

## Plugin PDFMonkey {#pdfmonkey-plugin}

Le plugin officiel PDFMonkey est le moyen le plus rapide de générer des documents depuis Bubble. Il gère automatiquement l’authentification, la création de documents et le polling : vous ajoutez une seule action à votre workflow et elle renvoie le document finalisé.

### Installer le plugin {#installing-the-plugin}

1. Ouvrez l’éditeur de votre application Bubble.
2. Accédez à **Plugins** et cliquez sur **Add plugins**.
3. Recherchez **PDFMonkey** et installez le plugin [PDFMonkey](https://bubble.io/plugin/pdfmonkey-uploader-1674229694738x439725903180202000).
4. Dans les paramètres du plugin, collez votre **clé secrète API** depuis la page [Mon compte](https://dashboard.pdfmonkey.io/account).

C’est tout ce qu’il faut pour l’authentification. Le plugin transmet votre clé via l’en-tête `Authorization` à chaque requête.

### Action « Generate a Document » {#generate-a-document-action}

Le plugin fournit une action serveur appelée **PDFMonkey - Generate a Document**. Ajoutez-la à n’importe quel workflow Bubble pour créer et générer un document à partir de l’un de vos modèles.

#### Champs d’entrée {#input-fields}

| Champ | Type | Requis | Description |
| --- | --- | --- | --- |
| **Template ID** | Valeur dynamique | Oui | L’identifiant de votre modèle PDFMonkey (disponible dans les paramètres du modèle) |
| **Document data** | Paires clé/valeur | Oui | Les données dynamiques pour votre modèle ; les clés doivent correspondre aux noms de variables définis dans votre modèle |
| **Document meta-data** | Paires clé/valeur | Non | Métadonnées attachées au document (non accessibles dans le modèle) |
| **Filename** | Valeur dynamique | Non | Un nom de fichier personnalisé pour le fichier généré |

> [!NOTE]
> **Nommage des variables**
>
> Les clés de **Document data** doivent correspondre exactement aux noms de variables de votre modèle. Consultez la référence sur le [nommage des variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour les règles de formatage.


#### Valeurs renvoyées {#returned-values}

Une fois l’action terminée, les valeurs suivantes sont disponibles dans les étapes suivantes du workflow (via **Result of step X**) :

| Champ | Type | Description |
| --- | --- | --- |
| **id** | texte | L’identifiant unique du document généré |
| **Download URL** | fichier | Une URL temporaire pour télécharger le fichier (valide 1 heure) |
| **Public Share Link** | texte | Un lien de partage permanent (disponible sur les plans Premium) |
| **Filename** | texte | Le nom du fichier généré |
| **Document meta-data** | texte | Les métadonnées attachées au document |
| **Status** | texte | Le statut du document (`success` ou `failure`) |
| **Failure cause** | texte | Le message d’erreur en cas d’échec de la génération |
| **Creation Date** | date | Date de création du document |
| **Generation Date** | date | Date de fin de génération du document |
| **Workspace ID** | texte | L’identifiant du workspace contenant le modèle |
| **Template ID** | texte | L’identifiant du modèle utilisé |
| **Template name** | texte | Le nom (identifiant) du modèle utilisé |

### Fonctionnement de l’action {#how-the-action-works}

Lorsque l’action s’exécute, elle :

1. Crée un document via l’API PDFMonkey avec le statut `pending`, ce qui déclenche immédiatement la génération.
2. Interroge automatiquement l’API (polling) jusqu’à ce que le document atteigne le statut `success` ou `failure`.
3. Renvoie le résultat à votre workflow.

L’action **bloque donc jusqu’à ce que le document soit prêt**. Vous n’avez pas besoin de configurer de polling, de webhooks ou de traitement asynchrone. Lorsque l’étape suivante de votre workflow s’exécute, le document est déjà généré et l’URL de téléchargement est disponible.

> [!TIP]
> Comme l’action gère le polling pour vous, elle peut prendre quelques secondes selon la complexité de votre modèle. C’est un comportement normal ; Bubble attend le résultat avant de passer à l’étape suivante.


### Exemple de workflow {#workflow-example}

Voici un workflow typique qui génère une facture et l’envoie par e-mail au client :

1. L’utilisateur clique sur un bouton **Générer la facture**.
2. Dans le workflow, ajoutez l’action **PDFMonkey - Generate a Document**.
3. Définissez **Template ID** avec l’identifiant de votre modèle de facture (vous pouvez le coder en dur ou le récupérer dynamiquement depuis votre base de données).
4. Associez vos données Bubble aux clés de **Document data**. Par exemple :
   - `customerName` → Current User’s Name
   - `invoiceNumber` → Current Invoice’s Number
   - `lineItems` → Current Invoice’s Items (formaté en JSON)
5. L’action attend que le document soit prêt.
6. À l’étape suivante, ajoutez une action **Send Email** et utilisez **Result of step X’s Download URL** comme pièce jointe.

> [!WARNING]
> **Publiez votre modèle au préalable**
>
> Si vos documents générés ne reflètent pas vos dernières modifications, vérifiez que vous avez publié le modèle dans PDFMonkey. Oublier de publier après une modification est une erreur fréquente.


### Source de données « List Workspaces » {#list-workspaces}

Le plugin expose également une source de données **List Workspaces** qui renvoie les workspaces disponibles dans votre compte PDFMonkey. Vous pouvez l’utiliser pour construire des menus déroulants dynamiques ou permettre aux utilisateurs de sélectionner un workspace avant de générer un document.

## API Connector {#api-connector}

Si vous avez besoin de plus de contrôle sur les requêtes (en-têtes personnalisés, endpoints spécifiques ou accès direct à la réponse complète de l’API), vous pouvez appeler l’API REST PDFMonkey via le plugin API Connector intégré à Bubble.

> [!NOTE]
> **Quand utiliser l’API Connector**
>
> Pour la plupart des cas d’usage, le [plugin PDFMonkey](#pdfmonkey-plugin) est plus simple et suffisant. Envisagez l’API Connector si vous avez besoin d’appeler des endpoints non couverts par le plugin (comme lister ou supprimer des documents), ou si vous souhaitez gérer le polling ou les webhooks vous-même.


### Configurer l’API Connector {#setting-up-the-api-connector}

1. Dans l’éditeur de votre application Bubble, accédez à **Plugins** et installez le plugin **API Connector** (s’il n’est pas déjà installé).
2. Cliquez sur **Add another API** et nommez-la `PDFMonkey`.
3. Définissez **Authentication** sur **Private key in header** et configurez :
   - **Key name :** `Authorization`
   - **Key value :** `Bearer VOTRE_CLÉ_SECRÈTE_API`
4. Ajoutez un nouvel appel API avec les paramètres suivants :

| Paramètre | Valeur |
| --------- | ------ |
| **Name** | Create Document |
| **Use as** | Action |
| **Method** | POST |
| **URL** | `https://api.pdfmonkey.io/api/v1/documents` |
| **Headers** | `Content-Type`: `application/json` |

5. Dans le **Body**, collez le JSON suivant :

```json
{
  "document": {
    "document_template_id": "<template_id>",
    "status": "pending",
    "payload": {
      "name": "<name>"
    }
  }
}
```

Remplacez `<template_id>` par l’identifiant de votre modèle (disponible dans votre tableau de bord PDFMonkey) et ajustez les clés du `payload` pour correspondre aux [données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) de votre modèle.

6. Cliquez sur **Initialize call** pour tester la connexion. En cas de succès, Bubble détecte automatiquement les champs de la réponse.

> [!WARNING]
> **Définissez le statut sur pending**
>
> Vous devez inclure `&#34;status&#34;: &#34;pending&#34;` pour que PDFMonkey commence immédiatement la génération du document. Si vous l’omettez ou le définissez sur `&#34;draft&#34;`, le document est créé mais pas généré. Consultez [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) pour plus de détails.


### Utiliser des valeurs dynamiques {#using-dynamic-values}

Pour transmettre des données dynamiques depuis votre application Bubble, encadrez les paramètres de chevrons (`<paramètre>`) dans le body de l’API Connector. Bubble les transforme en champs que vous pouvez associer à des valeurs dynamiques dans vos workflows.

Par exemple, pour générer une facture, votre body pourrait ressembler à ceci :

```json
{
  "document": {
    "document_template_id": "<template_id>",
    "status": "pending",
    "payload": {
      "customerName": "<customer_name>",
      "invoiceNumber": "<invoice_number>",
      "totalAmount": "<total_amount>"
    }
  }
}
```

Chaque `<paramètre>` devient un champ dans l’action du workflow, que vous pouvez remplir avec les données de votre application Bubble.

> [!NOTE]
> **Nommage des variables**
>
> Les noms de variables dans votre payload doivent correspondre à ceux utilisés dans votre modèle. Consultez la référence sur le [nommage des variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour les règles de formatage.


### Récupérer le fichier généré {#retrieving-the-generated-file}

La génération de documents est asynchrone. Une fois l’appel Create Document effectué, le document n’est pas encore prêt. Vous avez deux options pour récupérer le fichier finalisé :

- **Polling** : ajoutez un second appel API (`GET https://api.pdfmonkey.io/api/v1/documents/<document_id>`) et vérifiez le champ `status` jusqu’à ce qu’il atteigne `success`. La réponse inclut alors une `download_url`.
- **Webhook** : configurez un [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) dans PDFMonkey pour notifier votre application Bubble lorsque le document est prêt. Cette approche évite le polling et convient mieux en production.

> [!TIP]
> L’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) expire après 1 heure. Si vous avez besoin d’un lien permanent, utilisez un [lien de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) ou stockez le fichier dans votre propre espace de stockage.


## Dépannage {#troubleshooting}

### Échec de la génération {#document-generation-fails}

Si l’action du plugin renvoie un statut `failure`, consultez le champ **Failure cause** (ou `failureCause` dans la réponse API) pour connaître le message d’erreur. Les causes fréquentes incluent des erreurs de syntaxe dans votre modèle ou des données dynamiques invalides.

### JSON invalide dans l’API Connector {#invalid-json}

Si vous obtenez une erreur `422` en utilisant l’API Connector, votre body JSON est probablement mal formé. Causes fréquentes :

- **Guillemets doubles non échappés** dans les valeurs dynamiques : si une valeur saisie par l’utilisateur contient `"`, elle casse la structure JSON. Nettoyez les données avant de les transmettre.
- **Sauts de ligne** dans les valeurs : les sauts de ligne bruts sont invalides en JSON. Remplacez-les par `\n` ou `<br />` avant l’envoi.

Pour en savoir plus sur l’échappement JSON, consultez la section [Réponses 422](https://pdfmonkey.io/fr/docs/integrations/zapier.md#422-responses) du guide Zapier (les mêmes principes s’appliquent).

### Document bloqué en brouillon {#document-stuck-in-draft}

Si votre document est créé mais ne se génère jamais (API Connector uniquement), vérifiez que `"status": "pending"` est bien inclus dans le body de la requête. Sans cela, PDFMonkey crée le document en tant que brouillon et attend que vous déclenchiez la génération. Consultez [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md).

> [!TIP]
> Ce problème ne concerne pas le plugin PDFMonkey, qui définit toujours automatiquement le statut sur `pending`.


### URL de téléchargement expirée {#download-url-expired}

L’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) est valide pendant 1 heure. Si votre workflow met plus de temps à traiter le fichier, téléchargez-le immédiatement après la génération ou utilisez un [lien de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) pour un accès permanent.

Pour plus de détails, consultez [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md).

## Étapes suivantes {#next-steps}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : configurez votre compte PDFMonkey et créez votre premier modèle
- [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) : apprenez à structurer le payload JSON pour vos modèles
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprenez le cycle de vie d’un document généré
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : recevez des notifications en temps réel lorsque les documents sont générés
- [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) : fonctionnement des URL de téléchargement et leur expiration
- Découvrez les autres intégrations : [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [Make](https://pdfmonkey.io/fr/docs/integrations/make.md), [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md)


---

# Intégration Glide : générer des documents depuis votre application no-code

Source: https://pdfmonkey.io/fr/docs/integrations/glide.md

> [!WARNING]
> **Aidez-nous à contacter l’équipe Glide**
>
> Nous avons contacté l’équipe Glide à plusieurs reprises pour améliorer cette intégration — notamment pour ajouter la prise en charge des tableaux et des lignes de détail — mais n’avons jamais reçu de réponse. Si vous avez un contact direct chez Glide ou un moyen de faire avancer les choses, nous vous en serions très reconnaissants. Une meilleure intégration profiterait à tous ceux qui génèrent des factures, devis et autres documents avec des lignes de détail depuis Glide.


L’intégration PDFMonkey pour [Glide](https://www.glideapps.com/) vous permet de générer des documents directement depuis votre application no-code. Ajoutez une action **Generate PDF file** à un bouton, un formulaire ou un workflow, associez vos données à un modèle PDFMonkey et récupérez un lien de téléchargement dès que le document est prêt.

## Prérequis {#prerequisites}

Avant de commencer, assurez-vous de disposer des éléments suivants :

- Un compte PDFMonkey ([inscription ici](https://dashboard.pdfmonkey.io/register))
- Un compte [Glide](https://www.glideapps.com/) sur un plan payant (l’intégration n’est pas disponible sur les plans gratuits)
- Un modèle publié dans PDFMonkey

Pour la création de compte et la configuration d’un modèle, consultez [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

Vous avez également besoin de votre **clé secrète API**, disponible sur la page [Mon compte](https://dashboard.pdfmonkey.io/account). Consultez [Authentification](https://pdfmonkey.io/fr/docs/api/authentication.md) pour plus de détails.

## Configurer l’intégration {#setting-up-the-integration}

1. Dans votre application Glide, accédez à **Settings**.
2. Ouvrez la section **Integrations** et trouvez **PDFMonkey**.
3. Cliquez sur **Add to app**.
4. Collez votre **clé secrète API** PDFMonkey et enregistrez.

Une fois la connexion établie, l’action **Generate PDF file** est disponible dans les actions et workflows de votre application.

## Action « Generate PDF file » {#generate-pdf-file-action}

L’action **Generate PDF file** crée un document à partir de l’un de vos modèles PDFMonkey et renvoie un lien vers le fichier finalisé. Vous pouvez la déclencher depuis :

- Un **bouton** ou tout autre composant interactif
- La soumission d’un **formulaire**
- Le **Workflow Editor**

### Champs de l’action {#action-fields}

| Champ | Requis | Description |
| --- | --- | --- |
| **Template ID** | Oui | L’identifiant de votre modèle PDFMonkey. Copiez-le depuis les paramètres du modèle dans votre tableau de bord PDFMonkey. |
| **Filename** | Oui | Le nom du fichier généré. Vous pouvez utiliser des valeurs dynamiques issues de vos données Glide. |
| **File output** | Oui | La colonne où le lien de téléchargement sera enregistré une fois le document prêt. Utilisez une colonne de type **text** (pas une colonne URL). |
| **Dynamic values** | Non | Paires clé/valeur qui remplacent les variables de votre modèle. Cliquez sur **+Add value** pour associer les colonnes Glide aux variables du modèle. |

> [!NOTE]
> **Nommage des variables**
>
> Les clés ajoutées dans la section des valeurs dynamiques doivent correspondre exactement aux noms de variables de votre modèle PDFMonkey. Consultez la référence sur le [nommage des variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) pour les règles de formatage.


### Fonctionnement de l’action {#how-the-action-works}

Lorsque l’action s’exécute, elle envoie l’identifiant du modèle et vos valeurs dynamiques à l’API PDFMonkey. PDFMonkey génère le document et renvoie un lien de téléchargement, que Glide enregistre dans la colonne spécifiée comme **File output**.

> [!WARNING]
> **Publiez votre modèle au préalable**
>
> Si les documents générés ne reflètent pas vos dernières modifications, vérifiez que vous avez publié le modèle dans PDFMonkey. Oublier de publier après une modification est une erreur fréquente.


### Exemple de workflow {#workflow-example}

Voici un flux typique qui génère un certificat lorsqu’un utilisateur termine une formation :

1. L’utilisateur appuie sur un bouton **Télécharger le certificat** dans votre application Glide.
2. Le bouton déclenche l’action **Generate PDF file**.
3. Définissez **Template ID** avec l’identifiant de votre modèle de certificat.
4. Définissez **Filename** avec un nom descriptif, par exemple le nom de l’utilisateur combiné au titre de la formation.
5. Associez vos valeurs dynamiques :
   - `recipientName` → la colonne contenant le nom de l’utilisateur
   - `courseName` → la colonne contenant le titre de la formation
   - `completionDate` → la colonne contenant la date de fin
6. Définissez **File output** vers une colonne de type text dans votre source de données.
7. Une fois la génération terminée, le lien de téléchargement apparaît dans la colonne de sortie. Vous pouvez l’afficher comme un lien ou l’utiliser dans une action suivante (par exemple, envoyer un e-mail).

## Gérer les lignes de détail {#working-with-line-items}

L’intégration Glide transmet les données à PDFMonkey sous forme de paires clé/valeur simples. Elle ne prend pas en charge nativement les tableaux ou le JSON imbriqué, ce qui signifie que vous ne pouvez pas envoyer une liste de lignes de détail (comme les lignes d’une facture) de la même manière qu’avec [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md#line-items) ou [Make](https://pdfmonkey.io/fr/docs/integrations/make.md).

Il s’agit d’une limitation côté Glide, pas côté PDFMonkey. Les modèles PDFMonkey prennent en charge les tableaux et les boucles, mais l’intégration Glide ne peut pas envoyer de données structurées sous forme de tableau. Les solutions ci-dessous contournent cette limitation selon que vous utilisez des modèles Code ou des modèles Builder.

### Modèles Code : chaîne JSON avec parse_json {#workaround-json-string}

L’approche la plus propre pour les [modèles Code](https://pdfmonkey.io/fr/docs/modeles-code) consiste à transmettre vos lignes de détail sous forme de chaîne JSON, puis à l’analyser dans le modèle avec le filtre [`parse_json`](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#parse_json).

**Dans Glide :**

1. **Créez une colonne template** dans votre table d’éléments qui formate chaque ligne comme un objet JSON. Par exemple : `{"product":"Waffle","qty":12,"unitPrice":"3.50","total":"42.00"}`
2. **Créez une colonne Joined List** dans la table parente qui joint toutes les lignes avec des virgules.
3. **Créez une autre colonne template** qui entoure la liste jointe de crochets pour former un tableau JSON valide : `[<liste jointe>]`
4. **Transmettez cette chaîne** comme valeur dynamique dans l’action Generate PDF file, par exemple sous le nom `lineItemsJson`.

**Dans votre modèle PDFMonkey**, analysez la chaîne et parcourez le tableau obtenu :

```liquid title="HTML"
{% assign items = lineItemsJson | parse_json %}

<table>
  <thead>
    <tr>
      <th>Produit</th>
      <th>Qté</th>
      <th>Prix unitaire</th>
      <th>Total</th>
    </tr>
  </thead>
  <tbody>
    {% for item in items %}
    <tr>
      <td>{{ item.product }}</td>
      <td>{{ item.qty }}</td>
      <td>{{ item.unitPrice }}</td>
      <td>{{ item.total }}</td>
    </tr>
    {% endfor %}
  </tbody>
</table>
```

Vous obtenez un vrai tableau sur lequel itérer, avec un accès complet à chaque champ — exactement comme si les données avaient été envoyées en JSON structuré.

> [!TIP]
> Si la chaîne JSON est vide ou invalide, `parse_json` renvoie `nil`. Vous pouvez fournir une valeur de repli : `lineItemsJson | parse_json: &#34;[]&#34;`. Consultez la référence complète de [parse_json](https://pdfmonkey.io/fr/docs/modeles-code/filtres.md#parse_json).


### Modèles Builder : Custom JS avec JSON.parse {#workaround-builder-json-parse}

Pour les [modèles Builder](https://pdfmonkey.io/fr/docs/modeles-builder), l’approche est similaire : transmettez une chaîne JSON depuis Glide, puis analysez-la dans l’éditeur [Custom JS](https://pdfmonkey.io/fr/docs/modeles-builder/js-personnalise.md) pour utiliser le tableau obtenu dans les bindings de votre modèle.

**Dans Glide**, construisez la chaîne JSON de la même manière que [ci-dessus](#workaround-json-string).

**Dans l’éditeur Custom JS** de votre modèle Builder, analysez la chaîne et assignez le résultat à `window` :

```javascript
window.lineItems = JSON.parse($docPayload.lineItemsJson || '[]');
```

Vous pouvez ensuite utiliser `lineItems` dans les fonctionnalités de boucle et de binding du builder pour itérer sur le tableau et afficher chaque élément.

### Alternative : HTML pré-construit {#workaround-pre-built-html}

Si vous préférez gérer le formatage entièrement dans Glide, vous pouvez construire les lignes de détail sous forme de chaîne HTML et transmettre le résultat comme une seule variable :

1. **Créez une colonne template** dans votre table d’éléments qui formate chaque ligne en tant que ligne de tableau HTML. Par exemple :

   ```html
   <tr>
     <td>Nom du produit</td>
     <td>2</td>
     <td>15,00 €</td>
     <td>30,00 €</td>
   </tr>
   ```

   Utilisez les références de colonnes Glide pour insérer les valeurs réelles.

2. **Créez une colonne Joined List** dans la table parente qui concatène toutes les lignes formatées en une seule chaîne.

3. **Transmettez le HTML assemblé** comme valeur dynamique dans l’action Generate PDF file. Par exemple, associez-le à une variable nommée `lineItemsHtml`.

4. **Dans votre modèle PDFMonkey**, affichez la variable pour que le HTML soit rendu correctement :

   ```liquid title="HTML"
   <table>
     <thead>
       <tr>
         <th>Produit</th>
         <th>Qté</th>
         <th>Prix unitaire</th>
         <th>Total</th>
       </tr>
     </thead>
     <tbody>
       {{ lineItemsHtml }}
     </tbody>
   </table>
   ```

> [!NOTE]
> Cette approche est plus simple à mettre en place mais moins flexible : vous ne pouvez pas réutiliser les données individuelles de chaque élément pour des calculs ou de la logique conditionnelle dans le modèle. Si vous en avez besoin, utilisez plutôt l’[approche par chaîne JSON](#workaround-json-string) ou l’[approche Builder](#workaround-builder-json-parse).


### Alternative : utiliser une plateforme d’automatisation {#alternative-automation-platform}

Si vous avez besoin de données structurées sous forme de tableau sans contournement, envisagez de passer par une plateforme d’automatisation comme [Make](https://pdfmonkey.io/fr/docs/integrations/make.md) ou [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md). Ces plateformes prennent en charge les lignes de détail nativement et peuvent recevoir un déclencheur depuis Glide via webhook, puis appeler l’API PDFMonkey avec un payload JSON correctement structuré.

## Dépannage {#troubleshooting}

### Documents vides {#blank-documents}

Si le lien de téléchargement est généré mais que le document est vide :

- **Vérifiez les noms de vos variables.** Les noms de colonnes contenant des espaces ne fonctionnent pas comme clés de variables. Utilisez le `camelCase` ou le `snake_case` à la place. Par exemple, utilisez `customerName` et non `Customer Name`.
- **Vérifiez vos données de test dans PDFMonkey.** Ouvrez votre modèle, accédez à l’onglet **Test data** et vérifiez que le document s’affiche correctement avec un JSON d’exemple. Si cela fonctionne dans PDFMonkey mais pas depuis Glide, le problème vient de l’association des données.
- **Consultez l’historique PDFMonkey.** Ouvrez votre tableau de bord PDFMonkey et examinez le document dans l’onglet **History**. Le payload montre exactement les données envoyées par Glide, ce qui permet de repérer facilement les variables manquantes ou mal nommées.

### Type de la colonne File output {#file-output-column-type}

Le champ **File output** doit pointer vers une colonne de type **text** dans votre source de données Glide. L’utilisation d’une colonne URL ou d’un autre type peut empêcher l’enregistrement correct du lien.

### Échec de la génération {#document-generation-fails}

Si aucun lien n’apparaît dans la colonne de sortie :

- Vérifiez que votre **clé secrète API** est correcte dans les paramètres de l’intégration.
- Confirmez que votre **Template ID** est valide et que le modèle est publié.
- Consultez le tableau de bord PDFMonkey pour obtenir les détails de l’erreur sur le document en échec.

### URL de téléchargement expirée {#download-url-expired}

L’[URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) est valide pendant 1 heure. Si le lien ne fonctionne plus après ce délai, l’URL a expiré. Vous pouvez :

- Générer un nouveau document pour obtenir un lien valide.
- Utiliser un [lien de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) pour un accès permanent (disponible sur les plans Premium).

Pour plus de détails, consultez [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md).

### Consommation d’updates Glide {#glide-updates-consumption}

Chaque exécution réussie de l’action Generate PDF file consomme des updates Glide. Le nombre exact est affiché lors de la configuration de l’action. Les actions en échec ne consomment pas d’updates. Consultez la [documentation de facturation Glide](https://www.glideapps.com/docs/billing) pour plus de détails sur les coûts et les quotas d’updates.

## Étapes suivantes {#next-steps}

- [De zéro à votre premier document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) : configurez votre compte PDFMonkey et créez votre premier modèle
- [Définir les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) : apprenez à structurer le payload JSON pour vos modèles
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) : comprenez le cycle de vie d’un document généré
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : recevez des notifications en temps réel lorsque les documents sont générés
- [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) : fonctionnement des URL de téléchargement et leur expiration
- Découvrez les autres intégrations : [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [Make](https://pdfmonkey.io/fr/docs/integrations/make.md), [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md), [Workato](https://pdfmonkey.io/fr/docs/integrations/workato.md), [Bubble](https://pdfmonkey.io/fr/docs/integrations/bubble.md)


## FAQ

**Comment générer des PDF depuis une application Glide avec PDFMonkey ?**

Dans les Settings de votre application Glide, ajoutez l’intégration PDFMonkey avec votre clé secrète API. Puis utilisez l’action Generate PDF file dans un bouton, un formulaire ou un workflow, en fournissant votre Template ID, un nom de fichier, des valeurs dynamiques et une colonne texte pour le lien de sortie.

**Peut-on envoyer des lignes de détail ou des tableaux depuis Glide vers PDFMonkey ?**

Pas directement. Glide transmet des paires clé/valeur plates et ne peut donc pas envoyer de tableaux nativement. La solution consiste à construire une chaîne JSON dans Glide avec des colonnes template et une colonne Joined List, puis à l’analyser dans votre modèle PDFMonkey avec parse_json (modèles Code) ou JSON.parse dans Custom JS (modèles Builder).

**Pourquoi mes documents PDFMonkey générés depuis Glide sont-ils vides ?**

La cause la plus fréquente est une différence de noms de variables. Les noms de colonnes avec des espaces ne fonctionnent pas comme clés de variables — utilisez plutôt le camelCase ou le snake_case. Vérifiez le payload du document dans l’onglet History de PDFMonkey pour voir exactement quelles données Glide a envoyées.


---

# InvoiceBerry (via Zapier)

Source: https://pdfmonkey.io/fr/docs/integrations/invoiceberry.md

![](https://pdfmonkey.io/fr/docs/img/invoiceberry-logo.png)

## Qu’est-ce qu’InvoiceBerry ?

InvoiceBerry est un outil de facturation en ligne principalement utilisé par les propriétaires de petites entreprises. Il permet de créer et personnaliser des factures selon les besoins de l’entreprise, de créer et envoyer des devis aux clients, de configurer des factures récurrentes, d’envoyer des rappels et de suivre les dépenses. InvoiceBerry offre un environnement convivial et pratique pour centraliser la gestion financière et comptable de votre entreprise.

## Comment InvoiceBerry fonctionne-t-il avec PDFMonkey ?

InvoiceBerry est un logiciel de facturation en ligne conçu pour simplifier vos processus de facturation et PDFMonkey est un moyen simple de générer des documents PDF. L’intégration de ces deux applications permet de générer automatiquement des documents PDF et de retrouver des documents en réponse à la création de nouveaux clients, factures, dépenses InvoiceBerry et plus encore. Il existe actuellement [14 intégrations Zapier possibles entre PDFMonkey et InvoiceBerry](https://www.zapier.com/apps/pdfmonkey/integrations/invoiceberry).

## Que pouvez-vous faire avec InvoiceBerry et PDFMonkey ?

* Générer un PDF à partir d’une facture InvoiceBerry nouvellement créée
* Créer un client dans InvoiceBerry lorsqu’un nouveau document est généré dans PDFMonkey
* Rechercher un document dans PDFMonkey à partir d’un nouveau client créé dans InvoiceBerry
* Rechercher un document dans PDFMonkey en réponse à une nouvelle facture InvoiceBerry


## FAQ

**Comment InvoiceBerry s'intègre-t-il avec PDFMonkey ?**

InvoiceBerry se connecte à PDFMonkey via Zapier. Vous pouvez configurer des workflows automatisés qui génèrent des documents PDF personnalisés chaque fois qu’une nouvelle facture, un nouveau client ou une nouvelle dépense est créé dans InvoiceBerry.

**Que peut-on automatiser entre InvoiceBerry et PDFMonkey ?**

Vous pouvez générer des PDF à partir de factures nouvellement créées, créer des clients InvoiceBerry quand des documents sont générés, et rechercher des documents en réponse à de nouveaux clients ou factures. Il existe 14 intégrations Zapier possibles entre les deux applications.


---

# Ruby SDK

Source: https://pdfmonkey.io/fr/docs/integrations/sdk-ruby.md

Nous fournissons un [SDK Ruby](https://github.com/pdfmonkey/pdfmonkey-ruby) pour se connecter à PDFMonkey. Ce gem est le moyen le plus rapide d’utiliser notre API avec Ruby.

GitHub : [https://github.com/pdfmonkey/pdfmonkey-ruby](https://github.com/pdfmonkey/pdfmonkey-ruby)

## Installation

Ajoutez cette ligne au Gemfile de votre application :

```ruby title="Gemfile"
gem 'pdfmonkey'
```

Puis exécutez :

```bash
$ bundle
```

Ou installez-le directement :

```bash
$ gem install pdfmonkey
```

## Utilisation

### Configuration de l’authentification

#### Utilisation de la variable d’environnement par défaut

PDFMonkey recherche la variable d’environnement `PDFMONKEY_PRIVATE_KEY`. Cette variable doit contenir votre clé privée obtenue sur https://dashboard.pdfmonkey.io/account.

```bash
PDFMONKEY_PRIVATE_KEY=j39ckj4…
```

#### Configuration manuelle des identifiants

Vous pouvez configurer vos identifiants explicitement dans votre application :

```ruby
Pdfmonkey.configure do |config|
  config.private_key = 'j39ckj4…'
end
```

#### Identifiants par requête

La configuration est globale. Si vous avez besoin d’identifiants par requête (par ex. en multi-tenant), utilisez `with_adapter` :

```ruby
config = Pdfmonkey::Configuration.new
config.private_key = 'tenant-specific-key'

adapter = Pdfmonkey::Adapter.new(config: config)

Pdfmonkey.with_adapter(adapter) do
  Pdfmonkey::Document.generate!(
    document_template_id: 'b13ebd75-…',
    payload: { name: 'John Doe' }
  )
end
```

Toutes les opérations à l’intérieur du bloc utilisent l’adapter fourni. Les appels en dehors du bloc continuent d’utiliser la configuration globale.

### Documents

#### Génération synchrone

Si vous souhaitez attendre la fin de la génération d’un document avant de poursuivre votre flux de travail, utilisez la méthode `generate!`. Elle envoie une demande de génération et attend le succès ou l’échec avant de vous donner une réponse.

```ruby
document = Pdfmonkey::Document.generate!(
  document_template_id: 'b13ebd75-d290-409b-9cac-8f597ae3e785',
  payload: { name: 'John Doe' }
)

document.status       # => 'success'
document.download_url # => 'https://…'
```

> [!WARNING]
> **L’URL de téléchargement est temporaire**
>
> L’URL de téléchargement d’un document n’est valide que **pendant 1 heure**. Passé ce délai, rechargez le document pour en obtenir une nouvelle :
&gt; 
&gt; ```ruby
&gt; document.reload!
&gt; ```


#### Génération asynchrone

PDFMonkey a été conçu avec un flux de travail asynchrone en tête. Il fournit des [webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour vous informer du succès ou de l’échec de la génération d’un document.

Pour tirer parti de ce comportement et continuer à travailler pendant la génération de votre document, utilisez la méthode `generate` :

```ruby
document = Pdfmonkey::Document.generate(
  document_template_id: 'b13ebd75-d290-409b-9cac-8f597ae3e785',
  payload: { name: 'John Doe' }
)

document.status       # => 'pending'
document.download_url # => nil
```

Si vous avez configuré une URL de webhook, elle sera appelée avec votre document une fois la génération terminée. Vous pouvez la simuler pour vos tests avec la commande cURL suivante :

```bash
curl <url de votre application> \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
        "document": {
          "id": "76bebeb9-9eb1-481a-bc3c-faf43dc3ac81",
          "app_id": "d9ec8249-65ae-4d50-8aee-7c12c1f9683a",
          "created_at": "2020-01-02T03:04:05.000+01:00",
          "document_template_id": "f7fbe2b4-a57c-46ee-8422-5ae8cc37daac",
          "meta": "{\"_filename\":\"my-doc.pdf\"}",
          "output_type": "pdf",
          "status": "success",
          "updated_at": "2020-01-02T03:04:15.000+01:00",
          "xml_data": null,
          "payload": "{\"name\": \"John Doe\"}",
          "download_url": "https://example.com/76bebeb9-9eb1-481a-bc3c-faf43dc3ac81.pdf",
          "checksum": "ac0c2b6bcc77e2b01dc6ca6a9f656b2d",
          "failure_cause": null,
          "filename": "my-doc.pdf",
          "generation_logs": [],
          "preview_url": "https://preview.pdfmonkey.io/pdf/web/viewer.html?file=…",
          "public_share_link": "https://example.com/76bebeb9-9eb1-481a-bc3c-faf43dc3ac81.pdf"
        }
      }'
```

#### Documents brouillons

Vous pouvez créer un document brouillon qui ne sera pas mis en file d’attente pour la génération.

> [!TIP]
> C’est utile pour intégrer un aperçu via `preview_url` avant de déclencher la génération. C’est ce que nous faisons dans le tableau de bord PDFMonkey pour vous montrer un aperçu de votre document avant de le générer, en utilisant une `iframe`.


```ruby
draft = Pdfmonkey::Document.create_draft(
  document_template_id: 'b13ebd75-d290-409b-9cac-8f597ae3e785',
  payload: { name: 'John Doe' }
)
draft.status      # => 'draft'
draft.preview_url # => 'https://…'

# Quand vous êtes prêt, déclenchez la génération et attendez la fin :
draft.generate!
draft.status       # => 'success'
draft.download_url # => 'https://…'

# Ou déclenchez la génération sans attendre :
draft.generate
draft.status # => 'pending'
```

#### Joindre des métadonnées

En plus du payload du document, vous pouvez ajouter des métadonnées lors de la génération. Passez l’argument `meta:` aux méthodes `generate!` et `generate` :

```ruby
meta = {
  _filename: 'john-doe-contract.pdf',
  client_id: '123xxx123'
}

document = Pdfmonkey::Document.generate!(
  document_template_id: template_id,
  payload: payload,
  meta: meta
)
document.meta
# => '{"_filename":"john-doe-contract.pdf","client_id":"123xxx123"}'

document = Pdfmonkey::Document.generate(
  document_template_id: template_id,
  payload: payload,
  meta: meta
)
document.meta
# => '{"_filename":"john-doe-contract.pdf","client_id":"123xxx123"}'
```

#### Génération d’images

La génération d’images suit le même flux API que la génération de PDF. L’attribut `output_type` du template indique s’il produit une sortie `'pdf'` ou `'image'`. Les options spécifiques aux images sont passées via le paramètre `meta` :

```ruby
doc = Pdfmonkey::Document.generate!(
  document_template_id: template_id,
  payload: payload,
  meta: {
    _type: 'png',       # webp (défaut), png ou jpg
    _width: 800,        # pixels
    _height: 600,       # pixels
    _quality: 80        # webp uniquement, défaut 100
  }
)
doc.download_url # => URL vers l’image générée
```

#### Mettre à jour un document

```ruby
document.update!(status: 'pending')
```

#### Lister les documents

```ruby
cards = Pdfmonkey::Document.list_cards(page: 1, status: 'success')

cards.each do |card|
  puts card.id
  puts card.status
end

cards.current_page # => 1
cards.total_pages  # => 5

# Naviguer entre les pages
next_cards = cards.next_page
prev_cards = cards.prev_page
```

Vous pouvez filtrer par `document_template_id:`, `status:`, `workspace_id:` et `updated_since:`.

#### Récupérer un document

> [!CAUTION]
> **Préférez `fetch_card` à `fetch`**
>
> Récupérer un document complet inclut son payload, ce qui peut représenter un volume important selon les données fournies. Nous recommandons **fortement** d’utiliser uniquement `fetch_card` sauf si vous avez une raison spécifique de récupérer le document complet.


Vous pouvez récupérer un document existant avec `.fetch` (ou son alias explicite `.fetch_full`) :

```ruby
document = Pdfmonkey::Document.fetch('76bebeb9-9eb1-481a-bc3c-faf43dc3ac81')
```

Pour récupérer uniquement la représentation légère (recommandé) :

```ruby
card = Pdfmonkey::Document.fetch_card('76bebeb9-9eb1-481a-bc3c-faf43dc3ac81')
```

#### Supprimer un document

Vous pouvez supprimer un document existant avec la méthode `.delete` :

```ruby
Pdfmonkey::Document.delete('76bebeb9-9eb1-481a-bc3c-faf43dc3ac81')
#=> true
```

Vous pouvez également appeler la méthode `#delete!` sur une instance de document :

```ruby
document.delete!
#=> true
```

### Gestion des erreurs

Les erreurs API et les erreurs réseau lèvent des exceptions :

```ruby
begin
  document = Pdfmonkey::Document.generate(
    document_template_id: template_id,
    payload: data
  )
rescue Pdfmonkey::ApiError => e
  e.message     # => "Document template must exist"
  e.errors      # => ["Document template must exist"]
  e.status_code # => 422
rescue Pdfmonkey::ConnectionError => e
  e.message # => "Failed to open TCP connection to api.pdfmonkey.io:443 ..."
end
```

Lors de l’utilisation de `generate!`, une exception supplémentaire peut être levée si le statut du document est `'error'` ou `'failure'` :

```ruby
begin
  document = Pdfmonkey::Document.generate!(
    document_template_id: template_id,
    payload: data
  )
rescue Pdfmonkey::GenerationError => e
  e.message  # => "Document generation failed: Template error"
  e.document # => #<Pdfmonkey::Document …> (le document en échec)
end
```

Toutes les classes d’exception héritent de `Pdfmonkey::Error`, ce qui permet de les intercepter de manière générale :

```ruby
begin
  document = Pdfmonkey::Document.generate!(
    document_template_id: template_id,
    payload: data
  )
rescue Pdfmonkey::Error => e
  puts "Une erreur est survenue : #{e.message}"
end
```

### Templates

#### Récupérer un template

> [!CAUTION]
> **Les templates complets peuvent être volumineux**
>
> Récupérer un template complet inclut son body et ses paramètres, qui peuvent être volumineux. Utilisez `list_cards` quand vous n’avez besoin que des métadonnées.


```ruby
template = Pdfmonkey::Template.fetch('b13ebd75-d290-409b-9cac-8f597ae3e785')
template.identifier # => 'my-invoice'
template.body       # => '<h1>Invoice</h1>…'  (version publiée)
template.body_draft # => '<h1>Invoice v2</h1>…'  (version brouillon)
```

Vous pouvez aussi utiliser l’alias explicite `.fetch_full` :

```ruby
template = Pdfmonkey::Template.fetch_full('b13ebd75-d290-409b-9cac-8f597ae3e785')
```

#### Créer un template

Lors de la création d’un template, les attributs comme `body`, `scss_style`, `settings`, `sample_data` et `pdf_engine_id` sont automatiquement écrits dans leurs équivalents brouillons (`body_draft`, `scss_style_draft`, etc.) :

```ruby
template = Pdfmonkey::Template.create(
  identifier: 'my-invoice',
  body: '<h1>Invoice</h1>'
)
template.body_draft # => '<h1>Invoice</h1>'
```

#### Mettre à jour un template

Comme `create`, `update!` écrit dans les champs brouillons :

```ruby
template.update!(body: '<h1>Updated Invoice</h1>')
template.body_draft # => '<h1>Updated Invoice</h1>'
```

#### Publier un template

Une fois satisfait du brouillon, publiez-le pour copier tous les champs brouillons vers leurs équivalents publiés :

```ruby
template.publish!
template.body # => '<h1>Updated Invoice</h1>'
```

#### Lister les templates

```ruby
cards = Pdfmonkey::Template.list_cards(workspace_id: 'f4ab650c-…')
```

#### Supprimer un template

```ruby
Pdfmonkey::Template.delete('b13ebd75-…')
# ou
template.delete!
```

### Template Folders

```ruby
# Lister les dossiers
folders = Pdfmonkey::TemplateFolder.list

# Créer un dossier
folder = Pdfmonkey::TemplateFolder.create(identifier: 'invoices')

# Récupérer un dossier
folder = Pdfmonkey::TemplateFolder.fetch('folder-id')

# Mettre à jour un dossier
folder.update!(identifier: 'receipts')

# Supprimer un dossier
Pdfmonkey::TemplateFolder.delete('folder-id')
# ou
folder.delete!
```

Pour créer un template dans un dossier spécifique, passez le `template_folder_id` :

```ruby
folder = Pdfmonkey::TemplateFolder.create(identifier: 'invoices')

template = Pdfmonkey::Template.create(
  identifier: 'monthly-invoice',
  body: '<h1>Invoice</h1>',
  template_folder_id: folder.id
)
```

### Snippets

Les snippets sont des composants HTML réutilisables qui peuvent être inclus dans les templates.

```ruby
# Lister les snippets
snippets = Pdfmonkey::Snippet.list

# Créer un snippet
snippet = Pdfmonkey::Snippet.create(
  identifier: 'header',
  code: '<div class="header">…</div>',
  workspace_id: 'f4ab650c-…'
)

# Récupérer un snippet
snippet = Pdfmonkey::Snippet.fetch('snippet-id')

# Mettre à jour un snippet
snippet.update!(code: '<div class="header">Updated</div>')

# Supprimer un snippet
Pdfmonkey::Snippet.delete('snippet-id')
# ou
snippet.delete!
```

### Workspaces

Les workspaces sont des ressources en lecture seule. Ils peuvent être listés et récupérés, mais pas créés, mis à jour ou supprimés via l’API.

```ruby
# Lister les workspaces
workspaces = Pdfmonkey::Workspace.list_cards

workspaces.each do |workspace|
  puts workspace.identifier
end

# Récupérer un workspace
workspace = Pdfmonkey::Workspace.fetch('workspace-id')
workspace.identifier # => 'my-app'
```

### Webhooks

Les webhooks vous permettent de recevoir des notifications lorsque des documents sont générés.

```ruby
# Créer un webhook pour tous les templates d’un workspace
webhook = Pdfmonkey::Webhook.create(
  url: 'https://example.com/webhooks/pdfmonkey',
  event: 'document.generation.completed',
  workspace_id: 'f4ab650c-…'
)

# Restreindre optionnellement à certains templates
webhook = Pdfmonkey::Webhook.create(
  url: 'https://example.com/webhooks/pdfmonkey',
  event: 'document.generation.completed',
  workspace_id: 'f4ab650c-…',
  document_template_ids: ['tpl-1', 'tpl-2']
)

# Vous pouvez aussi spécifier un canal personnalisé pour le routage
webhook = Pdfmonkey::Webhook.create(
  url: 'https://example.com/webhooks/pdfmonkey',
  event: 'document.generation.completed',
  workspace_id: 'f4ab650c-…',
  custom_channel: 'invoices'
)

# Supprimer un webhook
Pdfmonkey::Webhook.delete('webhook-id')
# ou
webhook.delete!
```

### Engines

Lister les moteurs de rendu PDF disponibles :

```ruby
engines = Pdfmonkey::Engine.list

engines.each do |engine|
  puts "#{engine.name} (déprécié : #{engine.deprecated_on || 'non'})"
end
```

Vous pouvez utiliser un moteur lors de la création d’un template :

```ruby
engines = Pdfmonkey::Engine.list
v4 = engines.find { |e| e.name == 'v4' }

template = Pdfmonkey::Template.create(
  identifier: 'my-template',
  body: '<h1>Hello</h1>',
  pdf_engine_id: v4.id
)
```

### Utilisateur courant

Récupérer les informations de l’utilisateur authentifié :

```ruby
user = Pdfmonkey::CurrentUser.fetch

user.email               # => 'user@example.com'
user.current_plan        # => 'pro'
user.available_documents # => 1000
```

### Pagination

Toutes les méthodes de liste retournent des objets `Pdfmonkey::Collection` qui supportent la pagination :

```ruby
collection = Pdfmonkey::Document.list_cards(page: 1)

collection.current_page     # => 1
collection.total_pages      # => 5
collection.next_page_number # => 2
collection.prev_page_number # => nil

# Naviguer vers la page suivante/précédente
next_page = collection.next_page  # => Collection ou nil
prev_page = collection.prev_page  # => Collection ou nil
```

> [!NOTE]
> Les collections sont `Enumerable`. Les méthodes comme `.each`, `.map` et `.select` opèrent sur les éléments **de la page courante uniquement** — elles ne récupèrent pas automatiquement les pages suivantes.


```ruby
# Toutes ces méthodes agissent sur les éléments de la page courante
collection.each { |item| puts item.id }
collection.map(&:status)
collection.select { |item| item.status == 'success' }

# Pour traiter toutes les pages, naviguez manuellement
page = Pdfmonkey::Template.list_cards(page: 1)
while page
  page.each { |item| process(item) }
  page = page.next_page
end
```

### Sérialisation

Toutes les ressources supportent `to_json` et `to_h` :

```ruby
document.to_json # => '{"document":{"id":"…","status":"success",…}}'
document.to_h    # => {id: "…", status: "success", errors: nil, …}
```

> [!TIP]
> `to_json` encapsule les attributs sous la clé membre API de la ressource, omet les valeurs `nil` et supprime l’attribut `errors` (destiné aux requêtes API). Utilisez `to_h` quand vous avez besoin du hash complet des attributs pour le logging ou la mise en cache.



## FAQ

**Comment installer le SDK Ruby PDFMonkey ?**

Ajoutez gem 'pdfmonkey' à votre Gemfile et exécutez bundle install, ou exécutez directement gem install pdfmonkey. Définissez votre clé API via la variable d’environnement PDFMONKEY_PRIVATE_KEY ou configurez-la dans un initializer.

**Quelle est la différence entre generate! et generate dans le gem Ruby PDFMonkey ?**

generate! est synchrone — il bloque jusqu’à ce que le document atteigne le statut success ou failure, puis renvoie le document avec une URL de téléchargement. generate est asynchrone — il renvoie immédiatement avec un statut pending, et vous gérez le résultat via des webhooks.

**Peut-on utiliser des clés API par requête avec le SDK Ruby PDFMonkey ?**

Oui. Créez une Pdfmonkey::Configuration avec une clé spécifique au tenant, encapsulez-la dans un Adapter et passez-la à Pdfmonkey.with_adapter. Toutes les opérations à l’intérieur du bloc utilisent cet adapter tandis que les appels en dehors continuent d’utiliser la configuration globale.

**Comment gérer les erreurs dans le SDK Ruby PDFMonkey ?**

Interceptez Pdfmonkey::ApiError pour les erreurs API (inclut status_code et errors), Pdfmonkey::ConnectionError pour les problèmes réseau, ou Pdfmonkey::GenerationError lors de l’utilisation de generate! quand le document échoue. Toutes héritent de Pdfmonkey::Error pour une interception globale.



---

# Comment supprimer votre compte PDFMonkey

Source: https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md
Vous pouvez supprimer votre compte PDFMonkey à tout moment depuis la page [Mon compte](https://dashboard.pdfmonkey.io/account) du tableau de bord. Le processus se fait en deux clics si votre compte ne présente aucun problème, mais il peut être nécessaire de résoudre des questions de propriété d’espace de travail ou de facturation au préalable.

## Lancer le processus de suppression {#starting-the-deletion-process}

1. Rendez-vous sur la page [Mon compte](https://dashboard.pdfmonkey.io/account).
2. Faites défiler jusqu’à la section **Account deletion** en bas de page.
3. Cliquez sur **Delete my account**.

PDFMonkey effectue alors une vérification préalable et affiche les résultats. Selon l’état de votre compte, un ou plusieurs points peuvent nécessiter votre attention avant de poursuivre.

## Vérifications préalables {#pre-deletion-checks}

Lorsque vous cliquez sur le bouton de suppression, PDFMonkey vérifie trois éléments :

| Vérification | Signification | Comment résoudre |
|:-------------|:--------------|:-----------------|
| **Propriété d’espaces de travail partagés** | Vous êtes propriétaire d’un ou plusieurs espaces de travail ayant des collaborateurs. | Transférez la propriété de chaque espace de travail partagé à un autre membre avant de supprimer votre compte. Rendez-vous dans les paramètres de l’espace de travail pour réattribuer la propriété. |
| **Factures en attente** | Vous avez des factures en état « en attente » ou « en erreur ». | [Contactez-nous](https://pdfmonkey.io/contact) pour résoudre le problème de facturation avant de continuer. |
| **Factures existantes** | Vous avez des factures passées (déjà réglées). | Cochez la case de confirmation pour attester que vous avez téléchargé toutes les factures dont vous avez besoin. Une fois votre compte supprimé, les factures ne seront plus accessibles. |

Si vous n’avez aucun espace de travail partagé et aucune facture en attente, le processus passe directement à l’étape de confirmation.

> [!WARNING]
> **Résolvez les blocages d’abord**
>
> Vous ne pouvez pas supprimer votre compte tant que vous êtes propriétaire d’espaces de travail partagés ou que vous avez des factures en attente. Ces deux points doivent être résolus pour que le bouton de confirmation finale devienne actif.


## Confirmer la suppression {#confirming-the-deletion}

Une fois toutes les vérifications validées (coches vertes), cliquez sur **I am sure, delete my account** pour confirmer. PDFMonkey procède immédiatement aux actions suivantes :

- Annulation de votre abonnement et archivage de votre enregistrement client Stripe
- Suppression de votre compte utilisateur et de toutes les données associées
- Déconnexion du tableau de bord

> [!CAUTION]
> **La suppression est définitive**
>
> Il n’est pas possible d’annuler la suppression d’un compte. Tous vos modèles, documents, fichiers générés et paramètres de compte sont définitivement supprimés. Assurez-vous d’avoir téléchargé tous les fichiers et factures dont vous avez besoin avant de confirmer.


## Ce qui est supprimé {#what-gets-deleted}

Lors de la suppression de votre compte, PDFMonkey supprime :

- **Votre profil utilisateur** (adresse e-mail, nom, informations sur l’entreprise)
- **Tous les espaces de travail dont vous êtes propriétaire** (ainsi que leurs modèles et documents)
- **Tous les fichiers générés** (PDF, images) stockés sur les serveurs de PDFMonkey
- **Votre abonnement et votre enregistrement client Stripe**

Les ressources partagées telles que les snippets et suggestions communautaires auxquels vous avez contribué sont réattribuées à un compte de remplacement plutôt que supprimées.

> [!NOTE]
> Les espaces de travail où vous êtes collaborateur (et non propriétaire) ne sont pas affectés. Seuls les espaces de travail dont vous êtes propriétaire sont supprimés avec votre compte.


## Avant de partir {#before-you-go}

> [!TIP]
> **Aidez-nous à nous améliorer**
>
> Si vous partez parce que PDFMonkey ne répondait pas à vos besoins, nous apprécierions sincèrement de connaître vos raisons. [Envoyez-nous un message](https://pdfmonkey.io/contact) avec vos retours. Nous lisons chaque réponse et l’utilisons pour améliorer le produit.


## Pages associées {#related-pages}

- [Stockage des données et conservation](https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md) — quelles données PDFMonkey conserve et pendant combien de temps
- [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) — comment vos données sont protégées tant que votre compte est actif
- [Conservation et suppression automatique des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) — nettoyage des documents basé sur le TTL
- [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) — détails des abonnements et comparaison des offres


---

# Comment réinitialiser ou changer votre mot de passe PDFMonkey

Source: https://pdfmonkey.io/fr/docs/compte-et-securite/changement-de-mot-de-passe.md
PDFMonkey ne propose pas d’option de changement de mot de passe dans le Dashboard. Pour changer ou réinitialiser votre mot de passe, utilisez le processus de réinitialisation depuis la [page de connexion](https://dashboard.pdfmonkey.io/login).

## Comment réinitialiser votre mot de passe

1. Rendez-vous sur la [page de connexion](https://dashboard.pdfmonkey.io/login).
2. Cliquez sur **Forgot your password?** sous le bouton de connexion.
3. Saisissez l’adresse e-mail associée à votre compte et validez le formulaire.
4. Consultez votre boîte de réception : un e-mail de PDFMonkey contient un lien de réinitialisation.
5. Cliquez sur le lien dans l’e-mail. Une page s’ouvre pour définir un nouveau mot de passe.
6. Saisissez votre nouveau mot de passe et validez. Vous êtes redirigé vers la page de connexion.
7. Connectez-vous avec votre nouveau mot de passe.

> [!WARNING]
> **Expiration du lien**
>
> Le lien de réinitialisation expire au bout de **6 heures**. S’il a expiré, reprenez à l’étape 1 pour en demander un nouveau.


## Exigences relatives au mot de passe

Votre nouveau mot de passe doit comporter entre **6 et 128 caractères**. Il n’y a pas d’exigence de complexité supplémentaire (majuscules, symboles, etc.).

## Comptes avec connexion sociale

Si vous vous êtes inscrit via **Google**, **GitHub** ou **Microsoft**, vous n’avez pas de mot de passe PDFMonkey. Vous vous connectez via votre fournisseur d’identité. Le processus de réinitialisation ne s’applique pas aux comptes avec connexion sociale.

Si vous souhaitez ajouter un mot de passe à un compte avec connexion sociale, [contactez le support](https://pdfmonkey.io/fr/docs/premiers-pas/support.md) pour obtenir de l’aide.

## Dépannage

### Je n’ai pas reçu l’e-mail de réinitialisation

- Vérifiez votre dossier spam ou courrier indésirable.
- Assurez-vous d’avoir saisi l’adresse e-mail exacte utilisée lors de l’inscription.
- Si vous vous êtes inscrit via Google, GitHub ou Microsoft, vous n’avez pas de compte basé sur un mot de passe (voir [Comptes avec connexion sociale](#comptes-avec-connexion-sociale) ci-dessus).
- Si vous ne trouvez toujours pas l’e-mail, [contactez le support](https://pdfmonkey.io/fr/docs/premiers-pas/support.md).

### Le lien de réinitialisation ne fonctionne pas

- Le lien a peut-être expiré. Les liens de réinitialisation sont valides pendant 6 heures. Demandez-en un nouveau depuis la [page de connexion](https://dashboard.pdfmonkey.io/login).
- Assurez-vous de cliquer sur le lien le plus récent. Si vous avez demandé plusieurs réinitialisations, seul le dernier lien est valide.

## Pages associées

- [Suppression de compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md) — comment supprimer définitivement votre compte PDFMonkey
- [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) — comment vos données sont protégées
- [Support](https://pdfmonkey.io/fr/docs/premiers-pas/support.md) — comment contacter l’équipe PDFMonkey


---

# Sécurité PDFMonkey : comment vos données sont protégées

Source: https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md
PDFMonkey est conçu pour protéger vos données à chaque étape : lors de l’envoi, pendant le stockage et lorsqu’elles ne sont plus nécessaires. Cette page décrit les mesures en place pour protéger vos Templates, Documents et données dynamiques.

## Chiffrement en transit

Toutes les communications avec PDFMonkey sont chiffrées via HTTPS (TLS). L’API impose le SSL sur chaque requête ; les connexions HTTP non sécurisées sont automatiquement redirigées vers HTTPS.

Cela s’applique aux :

- Requêtes et réponses de l’API
- Sessions du Dashboard et du Builder
- Livraisons de webhooks vers votre serveur
- URL de téléchargement des fichiers générés

## Chiffrement au repos

Les données dynamiques que vous envoyez pour générer un Document (les champs `payload` et `meta`) sont stockées dans une colonne de base de données chiffrée. Elles sont déchiffrées à la volée uniquement lorsque nécessaire pour la génération du Document, et ne sont jamais stockées en clair.

Les fichiers générés (PDF et images) sont stockés dans des buckets S3 privés. L’accès est contrôlé via des URL présignées à durée limitée qui expirent après une heure.

## Isolation des données et contrôle d’accès

PDFMonkey traite vos données avec des limites strictes :

| Principe | Détails |
|:---------|:--------|
| **Limitation de finalité** | Vos données sont utilisées exclusivement pour générer le Document demandé. Elles ne sont jamais partagées avec des partenaires, vendues ou utilisées à des fins d’analyse. |
| **Aucune analyse tierce** | Vos données ne sont analysées ni par PDFMonkey ni par un service externe. |
| **Isolation des comptes** | Les Templates, Documents et fichiers générés de chaque compte sont isolés. Vous ne pouvez accéder qu’aux ressources appartenant à vos propres Workspaces. |
| **Authentification API** | Chaque requête API nécessite une clé API secrète envoyée sous forme de [Bearer token](https://pdfmonkey.io/fr/docs/api/authentication.md). Les clés sont limitées à votre compte. |

> [!WARNING]
> **Gardez votre clé API secrète**
>
> Votre clé API secrète possède les mêmes privilèges que votre compte. Ne la partagez jamais publiquement et ne la versionnez jamais dans un dépôt de code. Si votre clé est compromise, régénérez-la depuis la page Clé API du Dashboard.


## Hébergement européen

L’infrastructure de PDFMonkey est hébergée sur Amazon Web Services (AWS) dans la région **UE (Paris)**. Cela inclut :

- Les serveurs applicatifs
- La base de données (avec colonnes chiffrées)
- Les buckets S3 stockant les fichiers générés et les payloads volumineux

## Suppression des données

Vos données sont supprimées lorsque vous n’en avez plus besoin :

- **Suppression manuelle** : supprimer un Document via le Dashboard ou l’API supprime définitivement son payload, ses métadonnées et son fichier généré.
- **Suppression automatique (TTL)** : chaque Template dispose d’une période de rétention configurable. Lorsque le TTL d’un Document expire, il est automatiquement supprimé. Consultez [Rétention et suppression automatique](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) pour plus de détails.
- **Suppression de compte** : supprimer votre compte supprime définitivement tous les Workspaces, Templates, Documents et fichiers générés. Consultez [Suppression de compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md).

Les pages HTML temporaires générées pendant le processus de rendu sont supprimées immédiatement après la génération.

## Sécurité des webhooks

Lorsque PDFMonkey envoie des notifications webhook vers votre serveur, le payload est transmis via HTTPS. Vous pouvez vérifier l’authenticité des livraisons webhook grâce à la vérification de signature. Consultez [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour le guide complet de configuration.

## Pages associées

- [Authentification API](https://pdfmonkey.io/fr/docs/api/authentication.md) : comment les requêtes API sont authentifiées
- [Stockage des données et rétention](https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md) : quelles données PDFMonkey stocke et pendant combien de temps
- [Rétention et suppression automatique](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : nettoyage automatique des documents par TTL
- [Conformité et DPA](https://pdfmonkey.io/fr/docs/compte-et-securite/conformite-et-dpa.md) : conformité RGPD, accords de traitement des données et liste des sous-traitants
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) : configuration des webhooks et vérification de signature


## FAQ

**PDFMonkey est-il sécurisé ?**

Oui. PDFMonkey chiffre toutes les données en transit via HTTPS (TLS) et au repos avec des colonnes de base de données chiffrées. Les fichiers générés sont stockés dans des buckets S3 privés avec des URL présignées qui expirent après une heure. Toute l’infrastructure est hébergée sur AWS dans la région UE (Paris).

**Où sont hébergées les données PDFMonkey ?**

Toute l’infrastructure PDFMonkey est hébergée sur Amazon Web Services (AWS) dans la région UE (Paris), y compris les serveurs applicatifs, la base de données et les buckets S3 qui stockent les fichiers générés.

**PDFMonkey partage-t-il ou analyse-t-il mes données ?**

Non. Vos données sont utilisées exclusivement pour générer le document demandé. Elles ne sont jamais partagées, vendues ou analysées par PDFMonkey ou un service tiers.


---

# Stockage des données et politique de rétention de PDFMonkey

Source: https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md
PDFMonkey ne stocke que les données nécessaires à la génération de vos documents et à la distribution des fichiers produits. Cette page explique ce qui est stocké, où ces données résident et quand elles sont supprimées.

## Quelles données PDFMonkey stocke-t-il ?

Trois catégories de données interviennent dans la génération de documents :

| Données | Description | Emplacement | Durée de vie |
|:--------|:------------|:------------|:-------------|
| **Données dynamiques** | Les champs `payload` et `meta` envoyés lors de la création d’un Document | Base de données | Jusqu’à la suppression du Document |
| **Page HTML temporaire** | Le HTML rendu utilisé pour produire le fichier final | S3 (temporaire) | Supprimée après la génération |
| **Fichier généré** | Le fichier de sortie (PDF, PNG, WebP ou JPG) | S3 (bucket privé) | Jusqu’à la suppression du Document |

### Données dynamiques (payload et meta)

Lorsque vous créez un Document, vous envoyez un `payload` JSON contenant les données de votre Template, ainsi que des champs `meta` optionnels. PDFMonkey stocke ces données pour que vous puissiez les consulter ultérieurement dans le Dashboard ou les récupérer via l’API.

Ces données sont supprimées lors de la suppression du Document, que celle-ci soit manuelle ou déclenchée par l’expiration automatique du TTL.

> [!NOTE]
> **Payloads volumineux**
>
> Si un payload dépasse la taille limite de la colonne en base de données, PDFMonkey le stocke dans un bucket S3 privé. Il reste accessible via l’API de la même manière et suit les mêmes règles de suppression.


### Page HTML temporaire

Pendant la génération, PDFMonkey effectue le rendu de votre Template avec le payload fourni dans une page HTML complète. Cette page est envoyée vers un emplacement S3 temporaire puis transmise au moteur de rendu. Une fois la génération terminée (que le Document réussisse ou échoue), la référence à cette page HTML est supprimée. Le fichier HTML lui-même est nettoyé par une politique de cycle de vie S3.

La page HTML temporaire n’est jamais accessible via l’API ni le Dashboard.

### Fichier généré

Le fichier de sortie (PDF ou image) est stocké dans un bucket S3 privé. Il n’est accessible que par des URL présignées à durée limitée qui expirent après une heure. Chaque fois que vous demandez une URL de téléchargement, PDFMonkey génère une nouvelle URL présignée.

Consultez [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) pour les détails sur l’accès à vos fichiers générés.

## Où les données sont hébergées

Toute l’infrastructure de PDFMonkey fonctionne sur Amazon Web Services (AWS) dans la région **UE (Paris)**. Cela inclut :

- Les serveurs applicatifs
- La base de données
- Les buckets S3 stockant les fichiers générés, les payloads volumineux et les pages HTML temporaires

Pour plus de détails sur le chiffrement et les contrôles d’accès, consultez [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md).

## Quand les données sont supprimées

Vos données sont supprimées de trois manières :

### Suppression manuelle

Vous pouvez supprimer un Document à tout moment via le [Dashboard](https://dashboard.pdfmonkey.io) ou l’[API](https://pdfmonkey.io/fr/docs/api/documents.md#delete-a-document). Supprimer un Document supprime définitivement ses données dynamiques (`payload` et `meta`) ainsi que son fichier généré.

### Suppression automatique (TTL)

Chaque Template dispose d’un **TTL (Time To Live)** configurable qui détermine combien de temps ses Documents sont conservés après une génération réussie. Lorsque le TTL d’un Document expire, PDFMonkey le supprime automatiquement.

Les valeurs de TTL disponibles vont de 5 minutes à illimité, selon votre plan. Consultez [Rétention et suppression automatique des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) pour la référence complète des TTL, les valeurs par plan et l’impact des changements de plan sur la rétention.

### Suppression de compte

Supprimer votre compte PDFMonkey supprime définitivement tous les Workspaces, Templates, Documents et fichiers générés associés à votre compte. Consultez [Suppression de compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md) pour la procédure complète.

> [!CAUTION]
> **La suppression est définitive**
>
> Il n’est pas possible de récupérer des Documents, fichiers générés ou données dynamiques supprimés. Si vous devez conserver des fichiers à long terme, téléchargez-les vers votre propre stockage avant que la suppression n’intervienne.


## Questions fréquentes

**Mes données sont-elles partagées avec des tiers ?**

Non. Vos données sont utilisées exclusivement pour générer les Documents que vous demandez. Elles ne sont jamais partagées avec des partenaires, vendues ou utilisées à des fins d’analyse. Consultez [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) pour la politique complète d’isolation des données.

**Où trouver l’accord de traitement des données (DPA) de PDFMonkey ?**

PDFMonkey fournit un DPA et un accord de sous-traitement des données pour les organisations qui en ont besoin. Consultez [Conformité et DPA](https://pdfmonkey.io/fr/docs/compte-et-securite/conformite-et-dpa.md) pour les liens de téléchargement et les coordonnées de contact.

**Comment savoir quand un Document sera automatiquement supprimé ?**

L’objet Document n’expose pas directement le champ `expires_at`. Vous pouvez le calculer à partir de la valeur `ttl` du Template et de l’horodatage `updated_at` du Document. Consultez [Rétention et suppression automatique des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md#how-ttl-works) pour les détails.

## Pages associées

- [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) : chiffrement, contrôles d’accès et isolation des données
- [Rétention et suppression automatique des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : configuration du TTL et limites par plan
- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) : accéder aux fichiers générés avant leur expiration
- [Suppression de compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md) : ce qui se passe lorsque vous supprimez votre compte
- [Conformité et DPA](https://pdfmonkey.io/fr/docs/compte-et-securite/conformite-et-dpa.md) : accords de traitement des données
- [Nos plans](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) : comparatif des plans avec les limites de rétention


## FAQ

**Quelles données PDFMonkey stocke-t-il ?**

PDFMonkey stocke trois types de données : les données dynamiques que vous envoyez (payload et meta), une page HTML temporaire utilisée lors du rendu, et le fichier généré (PDF ou image). Les données dynamiques et le fichier généré persistent jusqu’à la suppression du document ; la page HTML est supprimée après la génération.

**Où les données PDFMonkey sont-elles hébergées ?**

Toute l’infrastructure de PDFMonkey est hébergée sur Amazon Web Services (AWS) dans la région UE (Paris), y compris les serveurs applicatifs, la base de données et les buckets de stockage S3.

**Combien de temps PDFMonkey conserve-t-il mes documents ?**

Chaque template dispose d’un TTL (Time To Live) configurable. Lorsque le TTL d’un document expire, PDFMonkey le supprime automatiquement avec son fichier généré et ses données dynamiques. Vous pouvez aussi supprimer des documents manuellement à tout moment. Les options de TTL vont de 5 minutes à illimité selon votre plan.

**Puis-je supprimer mes données de PDFMonkey ?**

Oui. Vous pouvez supprimer des documents individuels via le Dashboard ou l’API, configurer la suppression automatique par TTL, ou supprimer votre compte entier pour effacer définitivement toutes vos données.


---

# Conformité RGPD de PDFMonkey et accord de traitement des données (DPA)

Source: https://pdfmonkey.io/fr/docs/compte-et-securite/conformite-et-dpa.md
PDFMonkey aligne ses pratiques de traitement des données sur les exigences du RGPD. Cette page couvre la posture de conformité de l’entreprise, les accords juridiques disponibles et les engagements clés en matière de confidentialité intégrés à la plateforme.

## Posture de conformité

PDFMonkey ne détient pas de certification de conformité formelle (telle que SOC 2 ou ISO 27001). En tant que petite entreprise spécialisée, poursuivre ces certifications n’est pas envisageable actuellement. En revanche, PDFMonkey met en place des [mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) concrètes qui protègent vos données à chaque étape : chiffrement en transit et au repos, hébergement exclusivement européen, contrôles d’accès stricts et rétention des données configurable.

> [!NOTE]
> **L’absence de certification ne signifie pas l’absence de sécurité**
>
> L’absence d’un badge de certification ne reflète pas l’absence de pratiques de sécurité. Les mesures techniques et organisationnelles de PDFMonkey sont documentées dans la page [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) et formalisées dans le DPA ci-dessous.


## Rôles RGPD

Lorsque vous utilisez PDFMonkey, les rôles RGPD sont définis comme suit :

| Rôle | Partie | Responsabilité |
|:-----|:-------|:---------------|
| **Responsable de traitement** | Vous (l’Utilisateur) | Vous déterminez quelles données personnelles sont envoyées à PDFMonkey et dans quel but. |
| **Sous-traitant** | PDFMonkey | PDFMonkey traite vos données exclusivement pour générer les Documents que vous demandez, selon vos instructions. |

PDFMonkey traite vos données uniquement aux fins de la fourniture du service. Elles ne sont jamais analysées, partagées avec des partenaires, vendues ou utilisées à d’autres fins.

Si vous êtes vous-même sous-traitant agissant pour le compte d’un responsable de traitement (par exemple, en générant des documents pour vos propres clients), PDFMonkey fournit un **accord de sous-traitance des données** (DsPA) distinct qui formalise la chaîne Responsable de traitement-Sous-traitant-Sous-traitant ultérieur.

## Accord de traitement des données (DPA)

PDFMonkey fournit deux accords standard couvrant les obligations de traitement des données au titre du RGPD :

| Document | Cas d’utilisation | Lien |
|:---------|:------------------|:-----|
| **Accord de traitement des données (DPA)** | Vous êtes le responsable de traitement ; PDFMonkey est votre sous-traitant | [Télécharger le DPA (PDF)](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/documents/2023-03-01%20PDFMonkey%20DPA.pdf) |
| **Accord de sous-traitance des données (DsPA)** | Vous êtes sous-traitant ; PDFMonkey est sous-traitant ultérieur agissant pour le compte de votre responsable de traitement | [Télécharger le DsPA (PDF)](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/documents/2023-03-01%20PDFMonkey%20DsPA.pdf) |

Les deux accords sont datés du 1er mars 2023 et couvrent :

- Les définitions alignées sur la terminologie du RGPD
- Les obligations de traitement des données et les instructions
- Les mesures de sécurité et la confidentialité
- Les droits d’audit (une fois par an, préavis de 30 jours)
- Les procédures de notification de violation de données
- Les garanties relatives aux transferts internationaux de données
- La liste des sous-traitants approuvés
- La suppression des données à la fin du contrat

> [!TIP]
> **Besoin d’un accord personnalisé ?**
>
> Si votre organisation a besoin que PDFMonkey examine et signe un accord de confidentialité des données personnalisé, [contactez-nous](https://pdfmonkey.io/contact). Les demandes relatives au DPA peuvent également être envoyées directement à tinymonkey@pdfmonkey.io.


## Engagements clés au titre du RGPD

Les engagements suivants sont formalisés dans le DPA et reflétés dans l’implémentation technique de PDFMonkey :

### Hébergement exclusivement européen

Toute l’infrastructure fonctionne sur AWS dans la région **UE (Paris)**. Vos données ne quittent pas l’EEE sauf si un sous-traitant l’exige ; dans ce cas, le transfert est protégé par des garanties conformes au RGPD (décisions d’adéquation ou clauses contractuelles types). Consultez [Mesures de sécurité : hébergement européen](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md#hebergement-europeen) pour plus de détails.

### Limitation de finalité

PDFMonkey traite vos données exclusivement pour générer les Documents que vous demandez. Elles ne sont jamais analysées par PDFMonkey ou un service externe, jamais partagées avec des tiers et jamais utilisées à des fins de profilage ou d’analyse.

### Minimisation des données et rétention

Vous contrôlez la durée de stockage de vos données. Chaque Template dispose d’un [TTL (Time To Live)](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) configurable qui supprime automatiquement les Documents après l’expiration de la période de rétention. Vous pouvez également [supprimer des Documents manuellement](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md#manual-deletion) à tout moment. Consultez [Stockage des données et rétention](https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md) pour une vue complète de ce qui est stocké et quand les données sont supprimées.

### Notification de violation de données

Si PDFMonkey prend connaissance d’une violation de données personnelles affectant vos données, il vous en informe sans délai. La notification inclut la nature et l’étendue de la violation, un point de contact, les conséquences probables et les mesures correctives prises ou proposées.

### Suppression des données à la fin du contrat

Lorsque vous [supprimez votre compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md), PDFMonkey cesse tout traitement et détruit définitivement toutes vos données, y compris les Templates, Documents, fichiers générés et données dynamiques.

## Sous-traitants approuvés

PDFMonkey utilise un nombre limité de sous-traitants. Le DPA exige que PDFMonkey vous informe par écrit avant d’ajouter ou de remplacer un sous-traitant, en vous laissant le temps de vous opposer.

| Sous-traitant | Finalité |
|:--------------|:---------|
| **Amazon Web Services** | Hébergement et stockage |
| **Heroku** | Hébergement |
| **SendGrid** | Envoi d’e-mails |
| **Dropbox** | Stockage des factures |
| **Svix** | Livraison de webhooks |
| **Zapier** | Plateforme d’intégration |
| **Rollbar** | Journalisation des erreurs |
| **Sentry** | Journalisation des erreurs |
| **Cloudflare** | Services DNS et réseau |

Pour les coordonnées complètes et les liens de conformité de chaque sous-traitant, consultez la section 5 du [DPA](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/documents/2023-03-01%20PDFMonkey%20DPA.pdf) ou du [DsPA](https://pdfmonkey-resources.s3-eu-west-3.amazonaws.com/documents/2023-03-01%20PDFMonkey%20DsPA.pdf).

## Questions fréquentes

**PDFMonkey possède-t-il une certification SOC 2 ou ISO 27001 ?**

Non. PDFMonkey est une petite entreprise et ne détient pas actuellement de certification de conformité formelle. La page [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) décrit les mesures techniques et organisationnelles en place.

**Puis-je auditer PDFMonkey ?**

Oui. Le DPA vous accorde le droit d’auditer les pratiques de traitement des données de PDFMonkey une fois par an, pendant les heures ouvrables, avec un préavis écrit d’au moins 30 jours. Les frais d’audit sont à votre charge, sauf si l’audit révèle un manquement de la part de PDFMonkey.

**Que deviennent mes données si j’annule mon abonnement ?**

Lorsque vous [supprimez votre compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md), PDFMonkey supprime définitivement tous vos Workspaces, Templates, Documents et fichiers générés. Consultez [Suppression de compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md) pour le processus complet.

**Mes données sont-elles transférées hors de l’UE ?**

PDFMonkey s’engage à traiter les données au sein de l’EEE. Si un sous-traitant nécessite un transfert hors de l’EEE, des garanties conformes au RGPD (décisions d’adéquation ou clauses contractuelles types) sont en place.

## Pages associées

- [Mesures de sécurité](https://pdfmonkey.io/fr/docs/compte-et-securite/mesures-de-securite.md) : chiffrement, contrôles d’accès et isolation des données
- [Stockage des données et rétention](https://pdfmonkey.io/fr/docs/compte-et-securite/stockage-et-conservation-des-donnees.md) : quelles données PDFMonkey stocke et pendant combien de temps
- [Rétention et suppression automatique](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : configuration du TTL et limites par forfait
- [Suppression de compte](https://pdfmonkey.io/fr/docs/compte-et-securite/suppression-de-compte.md) : ce qui se passe lorsque vous supprimez votre compte
- [Support](https://pdfmonkey.io/fr/docs/premiers-pas/support.md) : comment contacter l’équipe PDFMonkey


## FAQ

**PDFMonkey est-il conforme au RGPD ?**

PDFMonkey applique les principes du RGPD : les données sont traitées exclusivement dans l’UE (région AWS Paris), chiffrées en transit et au repos, jamais partagées avec des tiers, et supprimées lorsqu’elles ne sont plus nécessaires. PDFMonkey agit en tant que sous-traitant (Processor) pour votre compte.

**PDFMonkey fournit-il un accord de traitement des données (DPA) ?**

Oui. PDFMonkey fournit un DPA standard et un accord de sous-traitance des données (DsPA), tous deux disponibles en téléchargement. Si votre organisation nécessite un accord personnalisé, vous pouvez contacter PDFMonkey pour organiser une revue et une signature.

**Où sont hébergées les données de PDFMonkey ?**

Toute l’infrastructure de PDFMonkey est hébergée sur Amazon Web Services (AWS) dans la région UE (Paris). Cela inclut les serveurs applicatifs, la base de données et le stockage S3. Les données sont traitées exclusivement au sein de l’EEE.

**Quels sous-traitants PDFMonkey utilise-t-il ?**

PDFMonkey utilise un nombre limité de sous-traitants : AWS (hébergement et stockage), Heroku (hébergement), SendGrid (e-mail), Dropbox (stockage des factures), Svix et Zapier (intégrations), Rollbar et Sentry (journalisation des erreurs), et Cloudflare (DNS). La liste complète est détaillée dans le DPA.



---

# Offres et tarifs PDFMonkey : Free, Starter, Pro, Pro+ et Premium

Source: https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md
PDFMonkey propose cinq offres adaptées à différents volumes de génération de documents. Chaque nouveau compte bénéficie d’un [essai Pro de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md) pour tester les fonctionnalités premium avant de choisir une offre. Rendez-vous sur [pdfmonkey.io/pricing](https://pdfmonkey.io/pricing) pour consulter les tarifs en vigueur.

## Comparaison des fonctionnalités {#feature-comparison}

| Fonctionnalité | Free | Starter | Pro | Pro+ | Premium |
|:---------------|:----:|:-------:|:---:|:----:|:-------:|
| Documents par mois | 20 | 300 | 3 000 | 5 000 | 60 000 |
| [Rétention des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) | 1 jour | 1 jour | 7 jours | Illimitée | Illimitée |
| [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) | Non | Oui | Oui | Oui | Oui |
| Membres d’équipe | 1 | 1 | 2 | Illimité | Illimité |
| [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) | Non | Non | Non | Oui | Oui |
| Temps de génération max | 30 sec | 30 sec | 2 min | 3 min | 5 min |
| [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) | Non | Non | Non | Oui | Oui |

> [!TIP]
> **Vous ne savez pas quelle offre choisir ?**
>
> Commencez avec l’offre Free et passez à une offre supérieure à tout moment. Les changements d’offre prennent effet immédiatement et la facturation est calculée au prorata. Consultez [Changer d’offre](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md).

## Détail des offres {#plan-details}

### Free

L’offre Free vous donne 20 documents par mois avec une limite de génération de 30 secondes. C’est une bonne option pour tester PDFMonkey avant de souscrire à une offre payante. Les [ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) (polices web, images distantes) ne sont pas disponibles sur cette offre.

### Starter

L’offre Starter porte votre quota à 300 documents par mois et débloque les [ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md). Si vous générez un faible volume de documents et n’avez pas besoin de collaboration en équipe, Starter couvre l’essentiel.

### Pro

L’offre Pro prend en charge jusqu’à 3 000 documents par mois avec une [rétention de 7 jours](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) et une limite de génération de 2 minutes. Vous pouvez inviter un membre d’équipe supplémentaire, portant le total à deux places.

### Pro+

L’offre Pro+ fournit 5 000 documents par mois avec une rétention illimitée, un nombre illimité de membres d’équipe, des [liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) et une limite de génération de 3 minutes.

### Premium

L’offre Premium gère jusqu’à 60 000 documents par mois avec toutes les fonctionnalités de Pro+, plus une limite de génération de 5 minutes.

## Facturation annuelle {#annual-billing}

Toutes les offres payantes bénéficient d’une réduction de 10 % avec la facturation annuelle. Vous pouvez passer de la facturation mensuelle à annuelle (et inversement) à tout moment depuis le Dashboard. Consultez [pdfmonkey.io/pricing](https://pdfmonkey.io/pricing) pour les tarifs annuels exacts.

## Atteindre votre quota {#reaching-your-quota}

Lorsque vous atteignez 80 % de votre quota mensuel, PDFMonkey vous envoie un e-mail d’avertissement. À 100 %, les nouvelles demandes de génération sont bloquées et les documents passent au [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) **draft**. Vous n’êtes pas facturé pour les générations bloquées.

Votre quota se réinitialise automatiquement au début de chaque cycle de facturation. Si vous avez besoin de plus de documents avant la réinitialisation, vous avez trois options :

- **Passer à une offre supérieure :** passez à un niveau supérieur pour un quota mensuel plus important. Consultez [Changer d’offre](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md).
- **Acheter un Boost Pack :** achetez un bloc unique de crédits de génération supplémentaires. Consultez [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md).
- **Activer le paiement à l’usage :** soyez facturé automatiquement pour chaque document au-delà de votre quota (tous les forfaits payants). Consultez [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md).

## Offres personnalisées {#custom-plans}

Si vous avez besoin de plus de 60 000 documents par mois, [contactez-nous](https://pdfmonkey.io/contact) pour discuter d’une offre personnalisée adaptée à votre volume.

## Questions fréquentes {#faq}

**Que deviennent mes documents si je passe à une offre inférieure ?**

Les documents situés dans la [fenêtre de rétention](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) de la nouvelle offre sont conservés. Les documents en dehors sont définitivement supprimés. Les fonctionnalités réservées aux offres supérieures (comme les [liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md)) cessent de fonctionner jusqu’à un éventuel retour à une offre éligible.

**Puis-je générer des images en plus des PDF ?**

Oui. Toutes les offres prennent en charge les formats PDF, PNG, WebP et JPG. Consultez [Générer des images au lieu de PDF](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) pour plus de détails.

**Les documents non utilisés sont-ils reportés au mois suivant ?**

Non. Votre quota mensuel est remis à zéro au début de chaque cycle de facturation. Les documents non utilisés ne s’accumulent pas.

**Y a-t-il un essai gratuit ?**

Oui. Chaque nouveau compte bénéficie d’un [essai Pro de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md) avec 300 documents, les ressources externes et une limite de génération de 2 minutes. À la fin de l’essai, votre compte passe automatiquement à l’offre Free.

## Pages associées {#related-pages}

- [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md) — crédits de documents supplémentaires ponctuels
- [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) — facturation automatique par document au-delà du quota
- [Changer d’offre](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) — fonctionnement des montées en gamme, rétrogradations et prorata
- [Essai Pro de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md) — contenu de l’essai et ce qui se passe à son expiration
- [Rétention et suppression des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) — paramètres TTL et limites de rétention par offre
- [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) — URL publiques permanentes pour les documents générés
- [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) — polices web, images distantes, CSS et JS externes


## FAQ

**Combien coûte PDFMonkey ?**

PDFMonkey propose cinq forfaits : Gratuit (20 documents/mois), Starter (300/mois), Pro (3 000/mois), Pro+ (5 000/mois) et Premium (60 000/mois). Tous les forfaits payants offrent une réduction de 10 % sur la facturation annuelle. Chaque nouveau compte bénéficie d’un essai Pro de 30 jours. Consultez pdfmonkey.io/pricing pour les tarifs actuels.

**Que se passe-t-il quand j’atteins mon quota de documents PDFMonkey ?**

À 80 % de votre quota mensuel, PDFMonkey vous envoie un e-mail d’avertissement. À 100 %, les nouvelles demandes de génération sont bloquées. Vous pouvez passer au forfait supérieur, acheter un Boost Pack ponctuel ou activer le paiement à l’usage.

**Les documents PDFMonkey non utilisés sont-ils reportés au mois suivant ?**

Non. Votre quota mensuel est remis à zéro au début de chaque cycle de facturation. Les documents non utilisés ne s’accumulent pas.

**PDFMonkey propose-t-il un forfait gratuit ?**

Oui. Le forfait Gratuit vous donne 20 documents par mois avec un temps de génération limité à 30 secondes. Les ressources externes (polices web, images distantes) ne sont pas disponibles sur ce forfait.


---

# Boost Packs : acheter des crédits de génération supplémentaires

Source: https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md
Les Boost Packs sont des achats ponctuels de crédits de génération de documents supplémentaires. Chaque Boost Pack ajoute 1 000 documents à votre quota pour **5 EUR** (HT). Les crédits sont disponibles immédiatement et restent valables jusqu’à la fin de votre cycle de facturation en cours.

> [!TIP]
> **En bref**
>
> Le quota du forfait est consommé en premier, puis les crédits Boost Pack. Les crédits Boost Pack non utilisés expirent au renouvellement de votre abonnement.

## Tarifs et disponibilité {#pricing}

| Détail | |
|:-------|:--|
| **Prix** | 5 EUR par Boost Pack (HT) |
| **Crédits par pack** | 1 000 documents |
| **Achat minimum** | 1 pack (1 000 documents) |
| **Achat maximum** | 1 000 packs (1 000 000 documents) par transaction |
| **Disponible sur** | Tous les forfaits payants (Starter, Pro, Pro+, Premium) |
| **Remboursement** | Non remboursable |

> [!WARNING]
> **Les Boost Packs sont réservés aux clients payants. Si vous êtes sur le [forfait Free](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md#plan-details), vous devez d’abord passer à un forfait payant.**
>
> 

Rendez-vous sur [pdfmonkey.io/pricing](https://pdfmonkey.io/pricing) pour les derniers tarifs.

## Boost Packs vs. paiement à l’usage {#boost-packs-vs-payg}

PDFMonkey propose deux façons de gérer le dépassement de quota. Elles sont mutuellement exclusives : vous devez choisir l’une ou l’autre.

| | Boost Packs | [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) |
|---|---|---|
| **Facturation** | Ponctuelle, payée à l’avance | Automatique, par document |
| **Tarif** | 5 EUR pour 1 000 documents (0,005 EUR/doc) | 0,005–0,006 EUR par document |
| **Achat minimum** | 1 000 documents (1 pack) | Aucun (facturé par document utilisé) |
| **Disponibilité** | Tous les forfaits payants | Tous les forfaits payants |
| **Action requise** | Achat manuel dans le Dashboard | Aucune (automatique une fois activé) |
| **Idéal pour** | Dépassement prévisible avec budget fixe | Volume imprévisible sans engagement initial |

> [!NOTE]
> **Si vous êtes sur un forfait annuel, le dépassement par paiement à l’usage est tout de même facturé mensuellement.**
>
> 

## Ordre de consommation des crédits {#consumption-order}

Lorsque vous générez un document, PDFMonkey puise dans vos crédits selon cet ordre :

1. Le **quota mensuel du forfait** est consommé en premier.
2. Les **crédits Boost Pack** sont consommés ensuite, une fois le quota du forfait entièrement épuisé.

Tant qu’il reste des crédits dans votre quota de forfait, votre solde Boost Pack reste intact.

Les Boost Packs et le [paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) sont mutuellement exclusifs : vous ne pouvez pas activer les deux en même temps.

## Comment acheter des Boost Packs {#how-to-buy}

1. Ouvrez votre Dashboard et rendez-vous dans la section **Billing**.
2. Faites défiler la page jusqu’à la zone **Boost Packs**.
3. Utilisez les boutons **+** et **-** pour sélectionner le nombre de packs souhaité (chaque pack correspond à 1 000 documents).
4. Cochez la case de consentement pour confirmer le montant et les conditions.
5. Cliquez sur **Give me a Boost Pack** (ou **Give me X Boost Packs** pour plusieurs).

L’achat est débité immédiatement sur votre moyen de paiement par défaut. Les crédits sont ajoutés à votre compte dès que le paiement est validé.

> [!NOTE]
> **Si une erreur survient lors de l’achat, vérifiez que votre moyen de paiement est à jour dans la section Billing. Contactez le support via le chat intégré si le problème persiste.**
>
> 

## Expiration {#expiry}

Les crédits Boost Pack **expirent à la fin de votre cycle de facturation en cours**. Au renouvellement de votre abonnement, les crédits Boost Pack non utilisés sont remis à zéro et votre quota revient à l’allocation de base de votre forfait.

Si vous avez besoin de crédits qui persistent d’un cycle à l’autre, envisagez plutôt de passer à un [forfait supérieur](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md).

## Questions fréquentes {#faq}

**Puis-je acheter des Boost Packs avec le forfait Free ?**

Non. Les Boost Packs nécessitent un abonnement payant actif (Starter, Pro, Pro+ ou Premium). [Changez de forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) au préalable.

**Les crédits Boost Pack non utilisés sont-ils reportés au cycle suivant ?**

Non. Les crédits non utilisés sont remis à zéro au renouvellement de votre abonnement. N’achetez des Boost Packs que lorsque vous en avez besoin dans le cycle en cours.

**Puis-je obtenir un remboursement pour des crédits Boost Pack non utilisés ?**

Non. Les Boost Packs ne sont pas remboursables.

**Les crédits Boost Pack sont-ils partagés entre les Workspaces ?**

Les crédits Boost Pack sont liés aux Workspaces que vous possédez et augmentent le quota de documents de ces Workspaces. Ils ne s’appliquent pas aux Workspaces d’autres comptes auxquels vous avez été invité.

**Que se passe-t-il si mon moyen de paiement est refusé ?**

L’achat n’est pas finalisé et aucun crédit n’est ajouté. Mettez à jour votre moyen de paiement dans la section Billing du Dashboard, puis réessayez.

## Pages associées {#related-pages}

- [Nos forfaits](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) — comparer les forfaits et les quotas mensuels
- [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) — facturation automatique par document au-delà de votre quota
- [Changer de forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) — fonctionnement des mises à niveau, rétrogradations et prorations
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre ce qui se passe lorsque votre quota est épuisé


## FAQ

**Que sont les Boost Packs PDFMonkey ?**

Les Boost Packs sont des achats ponctuels de crédits de génération de documents supplémentaires. Chaque Boost Pack ajoute 1 000 documents à votre quota pour 5 EUR (HT). Les crédits sont disponibles immédiatement et restent valables jusqu’à la fin de votre cycle de facturation en cours.

**Puis-je acheter des Boost Packs avec le forfait Free ?**

Non. Les Boost Packs nécessitent un abonnement payant actif (Starter, Pro, Pro+ ou Premium). Vous devez d’abord passer à un forfait payant.

**Les crédits Boost Pack non utilisés sont-ils reportés ?**

Non. Les crédits non utilisés sont remis à zéro au renouvellement de votre abonnement. N’achetez des Boost Packs que lorsque vous en avez besoin dans le cycle en cours.

**Combien coûtent les Boost Packs ?**

Chaque Boost Pack coûte 5 EUR (HT) et inclut 1 000 crédits de génération de documents. Vous pouvez acheter entre 1 et 1 000 packs par transaction.


---

# Paiement à l’usage : facturation automatique par document sur PDFMonkey

Source: https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md
Le paiement à l’usage (PAYG) est un mode de facturation automatique qui vous facture pour chaque document généré après l’épuisement de votre quota mensuel. Au lieu d’être bloqué lorsque votre quota est atteint, vous continuez à générer des documents et payez un petit montant par document.

> [!TIP]
> **En bref**
>
> Le PAYG n’impose aucun minimum d’achat ni engagement initial. Vous ne payez que les documents générés au-delà de votre quota mensuel, facturés automatiquement au tarif par document de votre offre.

## Tarifs par document {#per-document-rates}

| Offre | Tarif par document |
|:------|:-------------------|
| Pro+ | 0,006 EUR |
| Premium | 0,005 EUR |

Ces tarifs s’appliquent à chaque document généré au-delà de votre quota mensuel, qu’il produise un PDF ou une [image](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md).

Rendez-vous sur [pdfmonkey.io/pricing](https://pdfmonkey.io/pricing) pour les derniers tarifs.

## Disponibilité {#availability}

Le paiement à l’usage est disponible sur tous les forfaits payants : **Starter**, **Pro**, **Pro+** et **Premium**. Il n’est pas disponible sur l’offre Free. Consultez [Nos forfaits](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md#feature-comparison) pour une comparaison complète des fonctionnalités.

## Fonctionnement {#how-it-works}

1. Votre **quota mensuel** est consommé en premier.
2. Une fois votre quota épuisé, chaque document supplémentaire est facturé au tarif par document de votre offre.
3. Les frais de dépassement sont calculés en fin de période de facturation et ajoutés à votre prochaine facture.

Le PAYG s’applique à tous les Workspaces **que vous possédez**. Il ne s’applique pas aux Workspaces d’autres comptes auxquels vous avez été invité.

> [!NOTE]
> **Si vous êtes sur un forfait annuel, le dépassement PAYG est tout de même facturé mensuellement.**
>
> 

## Activer le paiement à l’usage {#enabling}

Pour activer ou désactiver le PAYG sur votre compte, ouvrez la section **Billing** de votre Dashboard et recherchez l’option de paiement à l’usage. Si vous ne la voyez pas, contactez le support via le chat intégré.

Une fois activé, le PAYG se déclenche automatiquement chaque fois que votre quota mensuel est épuisé. Aucune action manuelle n’est nécessaire à chaque dépassement.

## Paiement à l’usage vs Boost Packs {#payg-vs-boost-packs}

PDFMonkey propose deux façons de gérer le dépassement au-delà de votre quota mensuel. Elles sont **mutuellement exclusives** : vous devez choisir l’une ou l’autre.

| | Paiement à l’usage | [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md) |
|---|---|---|
| **Facturation** | Automatique, par document | Ponctuelle, payée à l’avance |
| **Tarif** | 0,005–0,006 EUR par document | 5 EUR pour 1 000 documents (0,005 EUR/doc) |
| **Achat minimum** | Aucun (facturé par document utilisé) | 1 000 documents (1 pack) |
| **Disponibilité** | Tous les forfaits payants | Tous les forfaits payants |
| **Action requise** | Aucune (automatique une fois activé) | Achat manuel dans le Dashboard |
| **Expiration** | Sans objet (facturé à l’utilisation) | Fin du cycle de facturation en cours |
| **Idéal pour** | Volume imprévisible sans engagement initial | Dépassement prévisible avec budget fixe |

> [!WARNING]
> **Vous ne pouvez pas avoir le PAYG et les Boost Packs actifs en même temps. Si vous souhaitez passer d’une méthode de dépassement à l’autre, désactivez d’abord celle en cours.**
>
> 

## Questions fréquentes {#faq}

**Y a-t-il un nombre minimum de documents pour le PAYG ?**

Non. Le PAYG n’impose aucun minimum d’achat. Vous n’êtes facturé que pour les documents effectivement générés au-delà de votre quota, même s’il ne s’agit que d’un seul document.

**Le PAYG s’applique-t-il à tous mes Workspaces ?**

Le PAYG s’applique aux Workspaces que vous possédez. Si vous avez été invité à des Workspaces appartenant à d’autres comptes, votre paramètre PAYG ne couvre pas ces Workspaces.

**Que se passe-t-il si je passe au forfait Free ?**

Le PAYG est automatiquement désactivé car il n’est pas disponible sur le forfait Free. Tout dépassement accumulé avant la rétrogradation reste facturé. Consultez [Changer de forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) pour plus de détails.

**Puis-je définir un plafond de dépenses ?**

Il n’existe actuellement pas de plafond de dépenses intégré pour le PAYG. Si vous souhaitez limiter les coûts de dépassement, envisagez plutôt les [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md), qui offrent un coût fixe et connu.

**Le PAYG comptabilise-t-il la génération d’images en plus des PDF ?**

Oui. Chaque document généré est décompté de votre quota et facturé via le PAYG, que le résultat soit un PDF ou une [image](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md).

## Pages associées {#related-pages}

- [Nos forfaits](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) — comparer les forfaits et les quotas mensuels
- [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md) — crédits supplémentaires ponctuels (mutuellement exclusifs avec le PAYG)
- [Changer de forfait](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md) — fonctionnement des mises à niveau, rétrogradations et prorations
- [Statuts des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre ce qui se passe lorsque votre quota est épuisé
- [Générer des images au lieu de PDF](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) — la génération d’images compte dans votre quota


## FAQ

**Qu’est-ce que le paiement à l’usage PDFMonkey ?**

Le paiement à l’usage (PAYG) est un mode de facturation automatique qui vous facture pour chaque document généré après l’épuisement de votre quota mensuel. Au lieu d’être bloqué lorsque votre quota est atteint, vous continuez à générer des documents et payez un petit montant par document.

**Y a-t-il un nombre minimum de documents pour le paiement à l’usage ?**

Non. Le PAYG n’impose aucun minimum d’achat. Vous n’êtes facturé que pour les documents effectivement générés au-delà de votre quota, même s’il ne s’agit que d’un seul document.

**Puis-je définir un plafond de dépenses pour le paiement à l’usage ?**

Il n’existe actuellement pas de plafond de dépenses intégré pour le PAYG. Si vous souhaitez limiter les coûts de dépassement, envisagez plutôt les Boost Packs, qui offrent un coût fixe et connu.

**Quel est le tarif par document pour le paiement à l’usage ?**

Le tarif par document dépend de votre offre : Pro+ à 0,006 EUR et Premium à 0,005 EUR. Ces tarifs s’appliquent à chaque document généré au-delà de votre quota mensuel.


---

# Changer d’offre PDFMonkey : passage à une offre supérieure, inférieure et facturation

Source: https://pdfmonkey.io/fr/docs/tarifs-et-facturation/changer-d-offre.md
Vous pouvez changer votre offre PDFMonkey à tout moment depuis la section Facturation de votre Dashboard. Les passages à une offre supérieure prennent effet immédiatement ; les passages à une offre inférieure s’appliquent au début de votre prochain cycle de facturation.

## Comment changer d’offre {#how-to-change-your-plan}

1. Ouvrez votre Dashboard et rendez-vous dans la section **Facturation**.
2. Cliquez sur **Gérer mon abonnement** pour ouvrir le portail de facturation.
3. Choisissez une nouvelle offre et confirmez le changement.

Pour les passages à une offre supérieure, PDFMonkey utilise un processus dédié qui applique le changement immédiatement après confirmation. Pour les passages à une offre inférieure ou les annulations, le portail Stripe vous permet de planifier le changement pour la fin de votre cycle de facturation en cours.

## Passer à une offre supérieure {#upgrading}

Lorsque vous passez à une offre supérieure, le changement prend effet **immédiatement**. Vous accédez instantanément aux fonctionnalités de la nouvelle offre, au quota de documents plus élevé et au temps de génération plus long.

> [!NOTE]
> **Facturation au prorata**
>
> Vous n’êtes facturé que pour le reste de votre cycle de facturation en cours au tarif de la nouvelle offre. La portion inutilisée de votre ancienne offre est créditée sur la nouvelle charge. Si vous avez des questions spécifiques sur le calcul de la proratisation, contactez le support via le chat intégré.

### Ce qui change lors d’un passage à une offre supérieure

- **Le quota de documents** augmente immédiatement à la capacité de la nouvelle offre.
- **Le temps de génération maximum** augmente selon le maximum de la nouvelle offre (par exemple, de 30 secondes sur Free à 2 minutes sur Pro).
- **La rétention des documents** est étendue. Les templates dont le TTL était au maximum de l’ancienne offre sont automatiquement mis à jour avec le maximum de la nouvelle offre. Consultez [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md).
- **Les fonctionnalités** sont débloquées instantanément. Par exemple, le passage à Pro+ ou Premium active les [liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) pour tous les documents existants générés avec succès, sans avoir besoin de les regénérer.

## Passer à une offre inférieure {#downgrading}

Lorsque vous passez à une offre inférieure, le changement est **planifié pour le début de votre prochain cycle de facturation**. Vous conservez les fonctionnalités et le quota de votre offre actuelle jusqu’à la fin du cycle.

> [!WARNING]
> **Impact sur les fonctionnalités et les données**
>
> Le passage à une offre inférieure peut affecter vos documents de manière permanente. Consultez les sections ci-dessous avant de confirmer.

### Ce qui change lors d’un passage à une offre inférieure

- **Le quota de documents** diminue selon la capacité de la nouvelle offre au début du prochain cycle de facturation.
- **Le temps de génération maximum** diminue. Les documents nécessitant plus de temps que le maximum de la nouvelle offre risquent d’échouer à la génération.
- **La rétention des documents** est réduite. Les templates dont le TTL dépasse le maximum de la nouvelle offre sont automatiquement abaissés à ce maximum, et les dates d’expiration des documents existants sont recalculées en conséquence. Les documents qui tombent en dehors de la nouvelle fenêtre de rétention sont définitivement supprimés et ne peuvent pas être récupérés. Consultez [Rétention et suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md).
- **Les liens de partage** cessent de fonctionner si vous passez de Pro+ ou Premium à une offre qui ne les inclut pas (Pro, Starter ou Free). Si vous repassez ensuite à Pro+ ou Premium, les liens de partage redeviennent actifs pour les documents encore existants. Consultez [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md).
- **Les ressources externes** (polices web, images distantes, CSS/JS externes) cessent de fonctionner si vous passez à l’offre Free. Les documents qui les référencent échoueront à la génération. Consultez [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md).
- **Le paiement à l’usage** est automatiquement désactivé si vous passez à l’offre Free. Tout dépassement accumulé avant le changement reste facturé. Consultez [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md).

## Changer de fréquence de facturation {#switching-billing-frequency}

Vous pouvez passer de la facturation mensuelle à annuelle et inversement. La facturation annuelle vous permet d’économiser **10 %** par rapport au tarif mensuel. Vous pouvez effectuer ce changement à tout moment depuis le portail de facturation.

Lorsque vous passez du mensuel à l’annuel, vous êtes facturé au tarif annuel immédiatement (au prorata du temps restant sur votre cycle mensuel en cours). Le passage de l’annuel au mensuel prend effet à la fin de votre période annuelle en cours.

Consultez [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) pour le détail des offres disponibles, ou rendez-vous sur [pdfmonkey.io/pricing](https://pdfmonkey.io/pricing) pour les tarifs en vigueur.

## Impact sur les méthodes de dépassement {#effect-on-overage-methods}

Si vous avez des [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md) ou le [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) activé, gardez les points suivants en tête :

- **Les crédits Boost Pack** sont conservés lorsque vous changez d’offre au sein du même cycle de facturation. Ils expirent toujours à la fin du cycle, indépendamment du changement d’offre.
- **Le paiement à l’usage** reste actif lors des changements entre offres payantes. Il est automatiquement désactivé uniquement si vous passez à l’offre Free.
- Les deux méthodes de dépassement ne sont pas disponibles sur l’offre Free.

## Questions fréquentes {#faq}

**Y a-t-il un contrat ou un engagement minimum ?**

Non. Toutes les offres PDFMonkey sont facturées de manière récurrente, sans contrat à long terme. Vous pouvez passer à une offre supérieure, inférieure ou annuler à tout moment.

**Qu’advient-il de mes documents lorsque je passe à une offre inférieure ?**

Les documents compris dans la [fenêtre de rétention](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) de la nouvelle offre sont conservés. Les documents en dehors de cette fenêtre sont définitivement supprimés lorsque le changement prend effet. Les fonctionnalités réservées aux offres supérieures (comme les [liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md)) cessent de fonctionner jusqu’à un éventuel retour à une offre supérieure.

**Puis-je changer d’offre pendant mon essai de 30 jours ?**

Oui. Vous pouvez [passer à n’importe quelle offre payante](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) à tout moment pendant l’essai. Le changement prend effet immédiatement. Consultez [Essai Pro de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md) pour les détails de ce que l’essai inclut.

**Vais-je perdre mes templates si je passe à une offre inférieure ?**

Non. Vos templates ne sont jamais supprimés lors d’un changement d’offre. Seuls les documents générés sont affectés par les changements de rétention.

**Comment la proratisation est-elle calculée ?**

La proratisation est gérée par Stripe. Lors d’un passage à une offre supérieure en cours de cycle, le temps inutilisé de votre ancienne offre est crédité et le coût proportionnel de la nouvelle offre est facturé pour les jours restants du cycle. Les montants exacts apparaissent comme des lignes distinctes sur votre prochaine facture.

## Pages liées {#related-pages}

- [Nos offres](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/nos-offres.md) : comparez les offres, quotas et fonctionnalités
- [Boost Packs](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/boost-packs.md) : crédits de génération supplémentaires ponctuels
- [Paiement à l’usage](https://pdfmonkey.io/fr/docs/tarifs-et-facturation/paiement-a-l-usage.md) : facturation automatique par document au-delà de votre quota
- [Essai Pro de 30 jours](https://pdfmonkey.io/fr/docs/premiers-pas/essai-de-30-jours.md) : ce que l’essai inclut et ce qui se passe à son terme
- [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) : URL publiques permanentes et impact des changements d’offre
- [Rétention et suppression des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) : paramètres TTL et limites de rétention par offre
- [Ressources externes](https://pdfmonkey.io/fr/docs/premiers-pas/ressources-externes.md) : définition des ressources externes et restrictions de l’offre Free


## FAQ

**Y a-t-il un contrat ou un engagement minimum sur PDFMonkey ?**

Non. Toutes les offres PDFMonkey sont facturées de manière récurrente, sans contrat à long terme. Vous pouvez passer à une offre supérieure, inférieure ou annuler à tout moment.

**Qu’advient-il de mes documents lorsque je passe à une offre inférieure ?**

Les documents compris dans la fenêtre de rétention de la nouvelle offre sont conservés. Les documents en dehors de cette fenêtre sont définitivement supprimés lorsque le changement prend effet. Les fonctionnalités réservées aux offres supérieures, comme les liens de partage, cessent de fonctionner jusqu’à un éventuel retour à une offre supérieure.

**Vais-je perdre mes templates si je passe à une offre inférieure ?**

Non. Vos templates ne sont jamais supprimés lors d’un changement d’offre. Seuls les documents générés sont affectés par les changements de rétention.

**Comment la proratisation est-elle calculée lors d’un passage à une offre supérieure ?**

La proratisation est gérée par Stripe. Lors d’un passage à une offre supérieure en cours de cycle, le temps inutilisé de votre ancienne offre est crédité et le coût proportionnel de la nouvelle offre est facturé pour les jours restants du cycle. Les montants exacts apparaissent comme des lignes distinctes sur votre prochaine facture.



---

# Pourquoi mon Document PDFMonkey est-il vide ?

Source: https://pdfmonkey.io/fr/docs/depannage/le-document-est-vide.md
Un document vide signifie généralement que PDFMonkey a généré le document avec succès, mais que le résultat ne contient aucun contenu visible. La cause la plus fréquente est un template non publié.

## Le template n’est pas publié {#template-not-published}

C’est de loin la cause la plus courante. Les templates PDFMonkey possèdent deux versions de leur contenu : un **brouillon** (ce que vous éditez) et une version **publiée** (ce que PDFMonkey utilise pour générer les documents). Si vous n’avez jamais cliqué sur **Publish**, le contenu publié est vide et chaque document généré à partir de ce template sera vierge.

### Comment corriger {#fix-unpublished-template}

1. Ouvrez votre template dans l’éditeur (Dashboard ou Builder).
2. Cliquez sur le bouton **Publish**.
3. Relancez la génération du document.

> [!WARNING]
> **Publiez après chaque modification**
>
> Cliquer sur **Publish** copie le brouillon actuel vers la version publiée. Si vous modifiez votre template sans republier, les documents continuent d’utiliser l’ancien contenu publié. Pensez toujours à publier après avoir effectué des modifications que vous souhaitez voir apparaître dans les documents générés.

Pour un guide complet du workflow template-vers-document, consultez [De zéro à votre premier Document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md).

## La logique conditionnelle masque tout le contenu {#conditional-logic}

Si votre template enveloppe le contenu dans des blocs conditionnels, le résultat peut être vide lorsque les conditions ne sont pas remplies.

**Les templates Code** utilisent la syntaxe Liquid :

```liquid
{% if items.size > 0 %}
  <!-- contenu ici -->
{% endif %}
```

Si `items` est absent du payload ou est un tableau vide, rien ne s’affiche.

**Les templates Builder** utilisent des règles de visibilité sur les composants. Si une condition de visibilité s’évalue à faux pour chaque composant, la page apparaît vide.

### Comment corriger {#fix-conditional-logic}

- Comparez les noms de variables dans vos conditions avec les clés de votre [payload](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md). Une faute de frappe ou une différence de casse (`Items` au lieu de `items`) fait échouer la condition silencieusement.
- Testez avec le payload que vous envoyez réellement, pas uniquement les données de test du template.
- Supprimez temporairement les conditions pour vérifier que le contenu s’affiche sans elles, puis réintroduisez-les une par une.

## Une erreur JavaScript ou d’expression dans un template Builder {#builder-js-error}

Les templates Builder peuvent échouer silencieusement lorsqu’ils contiennent une erreur à l’exécution. Deux scénarios courants :

- **Bibliothèques JavaScript externes ou code personnalisé dans des blocs HTML.** Si un script lève une erreur non interceptée, le rendu peut s’interrompre et produire un document vide.
- **Erreurs de syntaxe dans les conditions ou les répétitions.** Une faute de frappe dans une condition de visibilité ou une expression de répétition (par exemple une parenthèse manquante ou une variable mal orthographiée) empêche le composant de s’évaluer, ce qui peut produire un résultat vide.

### Comment corriger {#fix-builder-js-error}

1. Ouvrez le template dans le Builder et vérifiez l’**aperçu**. Si l’aperçu lui-même est vide ou cassé, l’erreur se trouve dans la logique du template.
2. Examinez les **blocs HTML** contenant des balises `<script>`. Essayez de les supprimer temporairement pour isoler le problème.
3. Relisez les expressions de **condition** et de **répétition** de vos composants à la recherche de fautes de frappe ou d’erreurs de syntaxe.
4. Si vous utilisez des bibliothèques externes chargées via une URL CDN, vérifiez que l’URL est correcte et que la bibliothèque est accessible au moment de la génération.

> [!TIP]
> **Pour déboguer, réduisez le template à sa forme la plus simple (texte statique, aucun script, aucune condition) et confirmez qu’il se génère correctement. Ajoutez ensuite la complexité élément par élément pour identifier ce qui casse.**
>
> 

## Le payload est vide ou manquant {#empty-payload}

Si vous créez un document sans fournir de `payload` (ou avec `"payload": {}`), chaque variable du template est évaluée comme vide. Quand le template ne contient aucun contenu statique, le résultat est un document vierge.

### Comment corriger {#fix-empty-payload}

Assurez-vous que votre requête API inclut un `payload` avec les données attendues par votre template :

```json
{
  "document": {
    "document_template_id": "YOUR_TEMPLATE_ID",
    "status": "pending",
    "payload": {
      "name": "Jane Doe",
      "items": [{ "description": "Widget", "price": 9.99 }]
    }
  }
}
```

Consultez [Mes données n’apparaissent pas](https://pdfmonkey.io/fr/docs/depannage/les-donnees-ne-s-affichent-pas.md) pour en savoir plus sur les décalages entre payload et variables du template.

## Le CSS masque le contenu {#css-hides-content}

Des règles CSS peuvent rendre le contenu invisible sans le supprimer du HTML. Causes fréquentes :

- `display: none` ou `visibility: hidden` sur un élément englobant
- Texte blanc (ou transparent) sur fond blanc
- `opacity: 0` sur un conteneur
- Un élément positionné hors page avec `position: absolute` et des décalages négatifs importants

### Comment corriger {#fix-css}

1. Ouvrez l’éditeur de template et vérifiez l’onglet **CSS** à la recherche de règles susceptibles de masquer le contenu.
2. Utilisez l’aperçu en direct pour confirmer que le contenu s’affiche comme prévu.
3. Si vous utilisez des classes CSS conditionnelles, vérifiez que les données du payload activent la bonne classe.

## Questions fréquentes {#faq}

**Je vois du contenu dans l’aperçu mais le document généré est vide.**

L’aperçu utilise la version **brouillon** de votre template, tandis que la génération utilise la version **publiée**. Cliquez sur **Publish** dans l’éditeur de template et relancez la génération.

**J’ai publié mon template, mais seul l’ancien contenu apparaît.**

Vous avez probablement modifié le template après l’avoir publié. Chaque fois que vous modifiez le brouillon, vous devez cliquer de nouveau sur **Publish** pour reporter ces changements vers la version publiée.

**Mon template Builder génère un document vide alors que l’aperçu est correct.**

Vérifiez que vous avez publié le template depuis le **Dashboard** (pas simplement sauvegardé dans le Builder). Vérifiez également que les règles de visibilité de vos composants s’évaluent correctement avec le payload que vous envoyez via l’API.

## Pages associées {#related-pages}

- [De zéro à votre premier Document](https://pdfmonkey.io/fr/docs/premiers-pas/de-zero-a-votre-premier-document.md) — guide complet de création de template et de document
- [Visite du Dashboard](https://pdfmonkey.io/fr/docs/premiers-pas/visite-guidee-du-tableau-de-bord.md) — où trouver le bouton Publish et les onglets de l’éditeur
- [Mes données n’apparaissent pas](https://pdfmonkey.io/fr/docs/depannage/les-donnees-ne-s-affichent-pas.md) — corriger les décalages entre payload et variables
- [Statuts des Documents et cycle de vie](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre les statuts draft, pending et autres
- [API Templates : propriétés brouillon et publiées](https://pdfmonkey.io/fr/docs/api/templates.md#draft-vs-published-properties) — relation entre champs brouillon et publiés dans l’API


## FAQ

**Pourquoi mon document PDFMonkey est-il vide ?**

La cause la plus fréquente est un template non publié. PDFMonkey utilise la version publiée d’un template pour générer les documents. Si vous n’avez jamais cliqué sur Publier, le contenu publié est vide et le document généré sera vierge.

**Comment publier un template dans PDFMonkey ?**

Ouvrez votre template dans l’éditeur et cliquez sur le bouton Publish. Cela copie le contenu brouillon (HTML, CSS, paramètres) vers la version publiée que PDFMonkey utilise pour la génération. Vous devez publier à nouveau après chaque modification que vous souhaitez voir apparaître dans les documents générés.

**Mon template est publié mais le document est toujours vide. Quelle autre cause possible ?**

Autres causes possibles : une logique conditionnelle (blocs Liquid if/unless ou règles de visibilité du Builder) qui masque tout le contenu quand les données du payload ne correspondent pas ; des erreurs JavaScript ou des erreurs de syntaxe dans les conditions et répétitions du Builder ; un payload vide ou manquant ; des règles CSS comme display:none ou visibility:hidden ; ou du texte blanc sur fond blanc.


---

# Pourquoi l’URL de téléchargement PDFMonkey est-elle vide ou null ?

Source: https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-est-vide.md
Le champ `download_url` est `null` tant qu’un document n’a pas atteint le [statut](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) `success`. Cette page détaille chaque cause possible et comment y remédier.

## Le statut du document est « draft » {#status-draft}

C’est la cause la plus fréquente. Si vous ne définissez pas d’attribut `status` lors de la création du document, celui-ci reste en `draft` par défaut et **aucune génération n’est lancée**. Puisque le document n’est jamais généré, il n’y a pas de fichier à télécharger et `download_url` reste `null`.

### Comment corriger {#fix-status-draft}

Définissez `"status": "pending"` lors de la création du document pour lancer la génération immédiatement :

```json
{
  "document": {
    "document_template_id": "YOUR_TEMPLATE_ID",
    "status": "pending",
    "payload": {
      "name": "Jane Doe"
    }
  }
}
```

Vous pouvez également mettre à jour un document existant en envoyant une requête PATCH avec `"status": "pending"`. Consultez la [référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) pour plus de détails.

> [!TIP]
> Définir `&#34;status&#34;: &#34;pending&#34;` dès la création est le schéma le plus courant pour les intégrations API. Cela permet de sauter l’étape « draft » et de lancer la génération en une seule requête.

## Le statut du document est « pending » ou « generating » {#status-pending-generating}

Si vous avez défini `"status": "pending"` lors de la création, la génération est en file d’attente mais n’est pas encore terminée. La réponse à votre requête de création renvoie le document en statut `pending` ou `generating` ; le champ `download_url` est `null` à ce stade car le fichier n’existe pas encore.

### Comment corriger {#fix-status-pending}

Attendez la fin de la génération avant de lire l’URL. Trois options s’offrent à vous :

| Approche | Fonctionnement | Idéal pour |
|:---------|:---------------|:-----------|
| **Webhook** | PDFMonkey envoie un POST à votre endpoint lorsque le document atteint `success` ou `failure`. | Intégrations en production |
| **Polling** | Récupérez le document en boucle jusqu’à ce que `status` soit `success` ou `failure`. | Scripts simples, prototypage |
| **Endpoint synchrone** | `POST /api/v1/documents/sync` crée le document et attend le résultat en une seule requête (timeout de 6 minutes). | Faibles volumes, workflows tolérants à la latence |

Consultez [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) et [Génération synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation) pour les instructions de configuration.

## Le statut du document est « failure » {#status-failure}

Si la génération a échoué, le statut du document est `failure` et `download_url` est `null`. Le champ `failure_cause` contient un message d’erreur lisible et `generation_logs` fournit des détails supplémentaires.

### Comment corriger {#fix-status-failure}

1. Inspectez les champs `failure_cause` et `generation_logs` dans la réponse de l’API.
2. Corrigez le problème sous-jacent dans votre template ou votre payload.
3. Relancez la génération en repassant le statut du document à `"pending"` via une requête PATCH.

Consultez [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md#failure) pour les causes d’échec courantes.

## Ne confondez pas download_url et preview_url {#preview-url-is-not-download}

> [!WARNING]
> **preview_url n’est pas un lien de téléchargement**
>
> Le champ `preview_url` affiche un aperçu visuel du document dans le navigateur. Il fonctionne même pour les brouillons et **ne déclenche pas** le téléchargement d’un fichier. Si vous avez besoin du fichier généré, utilisez `download_url`.
&gt; 
&gt; Un bon exemple de `preview_url` en action est le tableau de bord PDFMonkey : lorsque vous créez un document, le panneau d’aperçu à droite utilise `preview_url` pour montrer le rendu avant la génération.
&gt; 
&gt; Consultez [Intégrer un aperçu de document](https://pdfmonkey.io/fr/docs/generation-de-documents/integrer-un-apercu.md) pour apprendre à utiliser `preview_url` dans votre propre application.

## Questions fréquentes {#faq}

**J’ai défini le statut à « pending » mais l’URL de téléchargement est toujours null.**

La réponse à la requête de création renvoie le document avant la fin de la génération. Vous devez attendre que le statut atteigne `success` en interrogeant l’API, en utilisant un webhook ou en passant par l’[endpoint synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation).

**Combien de temps dure la génération ?**

La plupart des documents sont générés en quelques secondes. Les templates complexes (nombreuses pages, images lourdes, ressources externes) peuvent prendre plus de temps. L’endpoint synchrone a un timeout de 6 minutes.

**Puis-je obtenir l’URL de téléchargement sans polling ?**

Oui. Configurez un [endpoint webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) pour recevoir une notification lorsque la génération réussit. Le payload du webhook inclut le `download_url`. Vous pouvez aussi utiliser l’[endpoint synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation) pour attendre le résultat en une seule requête.

## Pages associées {#related-pages}

- [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre les statuts draft, pending, generating, success et failure
- [URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — fonctionnement des URL signées temporaires et leur expiration
- [Générer des documents via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — guide complet de création de documents via l’API
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) — recevoir des notifications à la fin de la génération
- [Génération synchrone](https://pdfmonkey.io/fr/docs/api/documents.md#synchronous-generation) — créer un document et attendre le résultat en une requête
- [L’URL de téléchargement renvoie une erreur 403](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md) — comment gérer les URL expirées


## FAQ

**Pourquoi l’URL de téléchargement PDFMonkey est-elle vide ou null ?**

Le champ download_url est null tant que le document n’a pas atteint le statut "success". La cause la plus fréquente est l’oubli de passer le statut à "pending" lors de la création, ce qui laisse le document en "draft" et empêche la génération. Passez le statut à "pending", puis attendez la fin de la génération via le polling ou un webhook.

**Comment obtenir une URL de téléchargement depuis PDFMonkey ?**

Créez un document avec le statut "pending" pour lancer la génération. Une fois le statut à "success", le champ download_url contient une URL signée temporaire valide 1 heure. Vous pouvez interroger l’API en boucle, utiliser un webhook, ou utiliser l’endpoint synchrone /api/v1/documents/sync.


---

# Pourquoi l’URL de téléchargement PDFMonkey renvoie-t-elle une erreur 403 ?

Source: https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-renvoie-403.md
Si vous essayez d’accéder à l’URL de téléchargement d’un document et recevez une erreur **403 Forbidden**, l’URL a expiré.

## Pourquoi cela se produit {#why-this-happens}

Les URL de téléchargement sont des [liens signés temporaires](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) valides pendant **1 heure** après leur génération. Passé ce délai, l’URL cesse de fonctionner et renvoie une erreur 403. C’est un comportement normal : l’URL est conçue pour être éphémère pour des raisons de sécurité.

Chaque fois que vous récupérez les détails d’un document (via l’API, une intégration ou le Dashboard), vous recevez une **nouvelle URL de téléchargement** avec une nouvelle fenêtre d’1 heure. Le fichier généré reste disponible sur les serveurs de PDFMonkey jusqu’à sa [suppression](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) ; seule l’URL signée expire.

## Comment corriger {#how-to-fix-it}

Récupérez le document à nouveau pour obtenir une nouvelle URL de téléchargement. Il n’est **pas** nécessaire de regénérer le document.

### Via l’API {#fix-api}

Envoyez une requête GET pour récupérer le document. La réponse inclut une nouvelle `download_url` :

```bash
curl https://api.pdfmonkey.io/api/v1/documents/YOUR_DOCUMENT_ID \
  -H "Authorization: Bearer YOUR_SECRET_API_KEY"
```

Consultez la [référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) pour le format de réponse complet.

### Via une intégration {#fix-integration}

Utilisez une action « Get Document » ou « Find Document » dans [Zapier](https://pdfmonkey.io/fr/docs/integrations/zapier.md), [Make](https://pdfmonkey.io/fr/docs/integrations/make.md), [n8n](https://pdfmonkey.io/fr/docs/integrations/n8n.md), ou une autre plateforme pour rafraîchir l’URL.

### Via le Dashboard {#fix-dashboard}

Ouvrez le document dans le [Dashboard](https://pdfmonkey.io/fr/docs/generation-de-documents/utiliser-le-tableau-de-bord.md). Le lien de téléchargement affiché sur la page de détail du document est toujours à jour.

### Via le SDK Ruby {#fix-ruby-sdk}

Appelez `document.reload!` pour récupérer les attributs les plus récents, dont une `download_url` fraîche :

```ruby
document = PdfMonkey::Document.find("YOUR_DOCUMENT_ID")
document.reload!
document.download_url  # => URL fraîche valide 1 heure
```

Consultez la [documentation du SDK Ruby](https://pdfmonkey.io/fr/docs/integrations/sdk-ruby.md) pour les instructions d’installation.

## Comment éviter ce problème {#how-to-avoid-it}

- **Téléchargez immédiatement après la génération.** Lorsque vous recevez une notification [webhook](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) ou interrogez l’état de complétion, téléchargez le fichier tout de suite plutôt que de stocker l’URL pour plus tard.
- **Stockez le fichier, pas l’URL.** Si vous avez besoin du fichier généré ultérieurement, enregistrez-le dans votre propre stockage (S3, Google Drive, etc.) au lieu de vous fier à l’URL de téléchargement temporaire de PDFMonkey.
- **Utilisez les liens de partage pour un accès permanent.** Si vous avez besoin d’une URL stable à partager par e-mail ou à intégrer dans des pages web, activez les [liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) (disponibles sur les plans Pro+ et Premium). Contrairement aux URL de téléchargement, les liens de partage n’expirent jamais.
- **Re-récupérez si nécessaire.** Si aucune des options ci-dessus ne s’applique et que vous avez besoin du fichier plus tard, récupérez à nouveau les détails du document pour obtenir une nouvelle URL. Cela ne nécessite qu’une seule requête GET.

## Questions fréquentes {#faq}

**L’erreur 403 signifie-t-elle que mon document a été supprimé ?**

Pas nécessairement. Une erreur 403 signifie que l’URL signée a expiré, pas que le fichier a disparu. Récupérez le document via l’API ; si vous obtenez une nouvelle `download_url`, le fichier est toujours disponible. Si le document a été supprimé (via le [TTL](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) ou manuellement), l’API renvoie une erreur 404.

**Quelle est la durée exacte de validité d’une URL de téléchargement ?**

Exactement 1 heure à partir du moment où l’URL est générée (lorsque vous récupérez les détails du document). Le compte à rebours ne commence pas à la création du document ni à la fin de la génération.

**Cela s’applique-t-il aussi aux images ?**

Oui. Les URL de téléchargement fonctionnent de la même manière quel que soit le [format de sortie](https://pdfmonkey.io/fr/docs/generation-de-documents/format-de-sortie.md) (PDF, PNG, JPG ou WebP). Elles expirent toutes après 1 heure.

**Peut-on prolonger la durée de validité ?**

Non. La durée d’1 heure est fixe et ne peut pas être configurée. Si vous avez besoin de liens plus durables, utilisez les [liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) ou enregistrez le fichier dans votre propre stockage.

## Pages associées {#related-pages}

- [L’URL de téléchargement](https://pdfmonkey.io/fr/docs/generation-de-documents/url-de-telechargement.md) — fonctionnement des URL signées temporaires et leur expiration
- [L’URL de téléchargement est vide](https://pdfmonkey.io/fr/docs/depannage/l-url-de-telechargement-est-vide.md) — corriger une `download_url` nulle (problème différent de l’erreur 403)
- [Liens de partage](https://pdfmonkey.io/fr/docs/generation-de-documents/liens-de-partage.md) — URL publiques permanentes qui n’expirent jamais
- [Webhooks](https://pdfmonkey.io/fr/docs/generation-de-documents/webhooks.md) — être notifié dès qu’un document est prêt à télécharger
- [Rétention et suppression automatique](https://pdfmonkey.io/fr/docs/generation-de-documents/conservation-et-suppression.md) — durée de conservation des fichiers avant nettoyage
- [Statuts et cycle de vie des documents](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre quand `download_url` devient disponible
- [Référence API Documents](https://pdfmonkey.io/fr/docs/api/documents.md) — documentation complète des endpoints et des champs


## FAQ

**Pourquoi l’URL de téléchargement PDFMonkey renvoie-t-elle une erreur 403 ?**

Les URL de téléchargement expirent après 1 heure. Récupérez le document via l’API, une intégration ou le SDK Ruby pour obtenir une nouvelle URL avec une nouvelle fenêtre d’1 heure.

**Comment obtenir une nouvelle URL de téléchargement après son expiration ?**

Récupérez le document via l’API (GET /api/v1/documents/:id), via une intégration comme Zapier ou Make, ou dans le Dashboard. Chaque requête renvoie une URL fraîche valide 1 heure. Il n’est pas nécessaire de regénérer le document.

**Peut-on obtenir un lien de téléchargement permanent qui n’expire jamais ?**

Oui. Activez les liens de partage sur les plans Pro+ ou Premium pour obtenir une URL publique permanente pour chaque document. Contrairement aux URL de téléchargement, les liens de partage n’expirent pas.


---

# Pourquoi mes données n’apparaissent-elles pas dans un Document PDFMonkey ?

Source: https://pdfmonkey.io/fr/docs/depannage/les-donnees-ne-s-affichent-pas.md
Lorsque les données dynamiques n’apparaissent pas dans un document généré, la cause est presque toujours une différence entre les noms de variables du template et les clés du payload JSON envoyé. Cette page couvre chaque cause courante et comment y remédier.

## Les noms de variables ne correspondent pas aux clés du payload {#variable-name-mismatch}

C’est la cause la plus fréquente. Le nom de variable dans votre template doit correspondre **exactement** à la clé correspondante dans votre payload JSON.

Si votre template contient :

```liquid
{{ someVariable }}
```

Le payload de votre Document doit inclure une clé correspondante :

```json
{
  "someVariable": "Une valeur"
}
```

Si la clé est absente, mal orthographiée ou utilise une casse différente, la variable s’affiche en blanc.

### Comment corriger {#fix-variable-name-mismatch}

1. Ouvrez votre template et notez les noms exacts des variables utilisées.
2. Comparez-les aux clés du payload JSON que vous envoyez lors de la création du document.
3. Corrigez toute différence d’orthographe ou de structure.

> [!TIP]
> **Utilisez l’onglet de données de test pour vérifier**
>
> Collez le payload JSON exact que vous comptez envoyer dans l’onglet **Test data** de votre éditeur de template. Si l’aperçu s’affiche correctement avec ces données, les noms de variables correspondent. Si des données sont toujours manquantes dans le document généré, le problème vient du payload envoyé via l’API, pas du template lui-même.

## Les noms de variables sont sensibles à la casse {#case-sensitivity}

Les noms de variables sont sensibles à la casse dans les templates Code (Liquid) comme dans les templates Builder (Vue). `firstName`, `firstname` et `FirstName` sont trois variables différentes.

**Template :**

```liquid
{{ firstName }}
```

**Payload (incorrect) :**

```json
{
  "firstname": "Jane"
}
```

**Payload (correct) :**

```json
{
  "firstName": "Jane"
}
```

### Comment corriger {#fix-case-sensitivity}

Adoptez une convention de nommage cohérente (le camelCase est courant) et utilisez-la dans votre template comme dans votre intégration API. Vérifiez les différences subtiles telles que `orderId` vs `orderID` ou `fullName` vs `fullname`.

## Les données imbriquées nécessitent la notation par points {#nested-data}

Si votre payload contient des objets imbriqués, vous devez parcourir la structure avec la notation par points dans votre template.

**Payload :**

```json
{
  "client": {
    "name": "Jane Doe",
    "address": {
      "city": "Paris"
    }
  }
}
```

**Template (Code/Liquid) :**

```liquid
{{ client.name }}
{{ client.address.city }}
```

Écrire `{{ name }}` ou `{{ city }}` seul ne fonctionne pas, car ces clés existent dans des objets imbriqués, pas au niveau racine.

### Comment corriger {#fix-nested-data}

Assurez-vous que le chemin utilisé dans le template suit la structure d’imbrication complète de votre payload. Consultez [Utiliser les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) pour en savoir plus sur l’accès aux valeurs imbriquées et aux tableaux.

## Le payload est vide ou mal formé {#empty-payload}

Si vous créez un document sans `payload` (ou avec `"payload": {}`), chaque variable s’évalue à blanc. De même, si le JSON est mal formé, le payload entier peut être ignoré.

### Comment corriger {#fix-empty-payload}

Vérifiez que votre requête API inclut un objet `payload` valide avec les données attendues par votre template :

```json
{
  "document": {
    "document_template_id": "YOUR_TEMPLATE_ID",
    "status": "pending",
    "payload": {
      "name": "Jane Doe",
      "items": [{ "description": "Widget", "price": 9.99 }]
    }
  }
}
```

> [!WARNING]
> **Vérifiez votre syntaxe JSON**
>
> Une virgule en trop, une clé sans guillemets ou un crochet manquant peuvent rendre le payload impossible à parser. Validez votre JSON avec un outil comme [jsonlint.com](https://jsonlint.com) avant d’envoyer la requête.

## Les templates Builder utilisent Vue, pas Liquid {#builder-templates}

Les templates Builder utilisent des expressions Vue, pas Liquid. Le même principe s’applique (les noms de variables doivent correspondre aux clés du payload), mais la syntaxe est différente.

Dans un template Builder, les données dynamiques sont accessibles via l’objet `$docPayload`. Les variables simples ressemblent à Liquid :

```
{{ name }}
```

Mais si un nom de variable **commence par un chiffre** ou contient des caractères spéciaux, ce n’est pas un identifiant JavaScript valide et il ne peut pas être utilisé directement. Utilisez la notation entre crochets :

```
{{ $docPayload['123varname'] }}
```

### Comment corriger {#fix-builder-templates}

1. Confirmez que les noms de variables dans vos expressions Builder correspondent aux clés de vos données de test ou du payload API.
2. Pour les clés qui ne sont pas des identifiants JavaScript valides, utilisez la notation `$docPayload['clé']`.
3. Vérifiez que les **conditions** et **répétitions** sur vos composants référencent des clés existantes du payload.

Consultez [Builder vs. templates Code](https://pdfmonkey.io/fr/docs/premiers-pas/modeles-builder-vs-code.md#the-builder-does-not-use-liquid) pour plus de détails sur les différences de syntaxe.

## Le template n’est pas publié {#template-not-published}

Si vous avez récemment modifié les noms de variables dans votre template sans le publier, le document généré utilise toujours l’ancienne version publiée. Cela peut donner l’impression que des données manquent alors que le vrai problème est que le template publié attend des noms de variables différents.

### Comment corriger {#fix-template-not-published}

Cliquez sur **Publish** dans l’éditeur de template après vos modifications, puis régénérez le document. Consultez [Pourquoi mon Document est-il vide ?](le-document-est-vide.md#template-not-published) pour une explication détaillée de la distinction entre brouillon et version publiée.

## Questions fréquentes {#faq}

**Je vois les données dans l’aperçu mais elles sont absentes du document généré.**

L’aperçu utilise la version **brouillon** de votre template et les **données de test** que vous avez définies. Le document généré utilise la version **publiée** et le **payload** envoyé via l’API. Assurez-vous d’avoir publié le template et que le payload API correspond à la structure des données de test.

**Ma variable affiche le texte littéral `{{ someVariable }}` au lieu de sa valeur.**

Dans les templates Code, cela signifie que le moteur Liquid n’a pas traité la variable. Vérifiez que les doubles accolades ne contiennent pas de caractères supplémentaires (comme un antislash ou des accolades mal appariées). Dans les templates Builder, cela ne devrait pas se produire sauf si le texte se trouve dans un bloc HTML brut qui contourne le rendu Vue.

**Comment savoir quelles données PDFMonkey a reçues ?**

Créez un document avec `"status": "pending"` puis récupérez-le via l’API. La réponse inclut le champ `payload`, qui montre les données exactes reçues par PDFMonkey. Comparez-les avec ce qu’attend votre template.

**Les tableaux et objets sont-ils pris en charge dans le payload ?**

Oui. Vous pouvez transmettre des tableaux et des objets imbriqués dans votre payload et y accéder dans votre template. Consultez [Utiliser les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) pour des exemples de syntaxe Liquid avec les tableaux et objets.

## Pages associées {#related-pages}

- [Utiliser les données dynamiques](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md) — définir les données de test, accéder aux valeurs imbriquées et nommer correctement les variables
- [Nommer les variables](https://pdfmonkey.io/fr/docs/modeles-code/definir-des-donnees-dynamiques.md#naming-your-variables) — conventions et règles de nommage
- [Builder vs. templates Code](https://pdfmonkey.io/fr/docs/premiers-pas/modeles-builder-vs-code.md) — comprendre les différences de syntaxe entre Liquid et Vue
- [Pourquoi mon Document est-il vide ?](le-document-est-vide.md) — quand le document entier est vide, pas seulement certaines données
- [Générer des Documents via l’API](https://pdfmonkey.io/fr/docs/generation-de-documents/generation-pdf-via-api.md) — exemples complets de payload API
- [Statuts et cycle de vie d’un Document](https://pdfmonkey.io/fr/docs/generation-de-documents/statuts-des-documents.md) — comprendre quand la génération a lieu


## FAQ

**Pourquoi mes données n’apparaissent-elles pas dans le document PDFMonkey ?**

Les noms de variables dans votre template doivent correspondre exactement aux clés de votre payload JSON, y compris la casse. Par exemple, si votre template utilise {{firstName}}, votre payload doit contenir une clé "firstName" — pas "firstname" ni "FirstName".

**Comment accéder aux données imbriquées dans un template PDFMonkey ?**

Dans les templates Code (Liquid), utilisez la notation par points : {{client.name}}. Dans les templates Builder (Vue), la même notation s’applique : {{client.name}}. Votre payload JSON doit contenir la structure imbriquée : {"client": {"name": "Jane Doe"}}.

**Les noms de variables PDFMonkey sont-ils sensibles à la casse ?**

Oui. Les noms de variables sont sensibles à la casse dans les templates Code (Liquid) comme dans les templates Builder (Vue). La clé dans votre payload JSON doit correspondre exactement au nom de la variable, y compris les majuscules et minuscules.