Générer un PDF en Python ou Node.js avec une API : guide pratique

Produire un PDF en Python ou un PDF en Node.js est un besoin récurrent : factures, devis, rapports, contrats, attestations. Mais la plupart des développeurs découvrent vite que c'est plus pénible que prévu. Les bibliothèques de mise en page demandent du temps, le rendu diffère d'un serveur à l'autre, et chaque retouche de design impose de modifier le code. Une API de génération de PDF change la donne : vous décrivez le document une fois sous forme de modèle, vous envoyez vos données, et l'API vous renvoie le fichier fini.

Ce guide montre comment générer un PDF par API en Python et en Node.js avec DocX, l'API documentaire de Layerone, avec deux exemples de code complets et prêts à copier.

Le problème : générer des PDF proprement, sans usine à gaz

Quand on veut créer un PDF en JavaScript ou en Python, l'approche classique consiste à empiler des librairies de rendu : on positionne le texte, on gère les sauts de page, les polices, les marges, les tableaux. Le moindre changement de maquette devient un chantier. Pire : le rendu dépend de l'environnement (polices installées, version de la librairie, moteur headless), ce qui produit des PDF différents en local et en production.

Le contenu d'un document change (le client, les montants, les dates) mais sa mise en forme reste stable. Coder cette mise en forme ligne par ligne est donc à la fois fastidieux et fragile. S'ajoutent les coûts cachés : maintenir un navigateur headless ou une chaîne de conversion, surveiller la mémoire sur des documents volumineux, reproduire fidèlement un en-tête ou un pied de page sur chaque page. Autant de code qui n'apporte aucune valeur métier. L'idéal serait de séparer la maquette du code : que les développeurs n'écrivent plus que la logique de données, et que la présentation reste un fichier modifiable par n'importe qui.

La solution : un modèle Word + des données JSON → un PDF

L'approche par modèle inverse la logique. Un gérant ou un graphiste prépare la maquette dans Microsoft Word, un outil qu'il maîtrise déjà, et y place des balises comme {{ client_nom }} ou {{ total_ttc }}. Le développeur se contente d'injecter les données. Il n'y a aucun moteur de rendu à installer ni à maintenir.

Avec DocX, le principe tient en trois étapes :

  1. Vous déposez un modèle Word (.docx) avec vos balises, et vous récupérez son identifiant (template_id).
  2. Vous appelez l'API en envoyant le template_id et vos données au format JSON.
  3. L'API renvoie le document fini (PDF ou Word) directement dans la réponse, sous forme binaire.

Les modèles sont stockés côté serveur : vous pouvez les modifier sans toucher au code de votre application. La transformation template Word vers PDF est entièrement pilotée par l'API.

Authentification : l'en-tête X-API-Key

Toutes les requêtes vers DocX s'authentifient avec un en-tête HTTP X-API-Key. Vous obtenez votre clé sur l'espace développeur après inscription. Cette clé est secrète : conservez-la côté serveur, jamais dans du code front-end public. L'endpoint de génération est POST https://docx.layerone.fr/render-document, et le corps de la requête est envoyé au format formulaire (application/x-www-form-urlencoded) avec trois champs : template_id, json_data (vos données sérialisées en JSON) et output_filename (le nom du fichier voulu).

Générer un PDF en Python

En Python, la bibliothèque requests suffit. On envoie le formulaire avec data=, et comme la réponse est un fichier binaire, on écrit directement response.content sur le disque : 

import json
import requests

CLE_API = "VOTRE_CLE_API"
URL = "https://docx.layerone.fr/render-document"

donnees = {
    "client_nom": "Boulangerie Martin",
    "numero": "F-2026-0042",
    "date": "19/06/2026",
    "total_ttc": "1 250,00 €",
}

reponse = requests.post(
    URL,
    headers={"X-API-Key": CLE_API},
    data={
        "template_id": "facture-standard",
        "json_data": json.dumps(donnees),
        "output_filename": "facture.pdf",
    },
    timeout=120,
)

if reponse.status_code == 200:
    with open("facture.pdf", "wb") as fichier:
        fichier.write(reponse.content)
    print("PDF généré : facture.pdf")
else:
    print(f"Erreur {reponse.status_code} : {reponse.text}")

Points clés : json_data doit être une chaîne JSON (d'où json.dumps), la réponse est binaire (mode "wb"), et un timeout évite de bloquer votre application si le service tarde. Ce script tient en une vingtaine de lignes et n'a besoin que de la dépendance requests : aucune librairie de mise en page, aucun binaire système à installer. Pour intégrer la génération dans une API web (FastAPI, Flask, Django), il suffit de renvoyer le contenu binaire avec l'en-tête Content-Type: application/pdf.

Générer un PDF en Node.js

En Node.js, on construit un corps de formulaire avec URLSearchParams et on récupère la réponse en binaire. Voici la version avec fetch (disponible nativement depuis Node 18) : 

import { writeFile } from "node:fs/promises";

const CLE_API = "VOTRE_CLE_API";
const URL = "https://docx.layerone.fr/render-document";

const donnees = {
  client_nom: "Boulangerie Martin",
  numero: "F-2026-0042",
  date: "19/06/2026",
  total_ttc: "1 250,00 €",
};

const corps = new URLSearchParams({
  template_id: "facture-standard",
  json_data: JSON.stringify(donnees),
  output_filename: "facture.pdf",
});

const reponse = await fetch(URL, {
  method: "POST",
  headers: { "X-API-Key": CLE_API },
  body: corps,
});

if (reponse.ok) {
  const pdf = Buffer.from(await reponse.arrayBuffer());
  await writeFile("facture.pdf", pdf);
  console.log("PDF généré : facture.pdf");
} else {
  console.error(`Erreur ${reponse.status} : ${await reponse.text()}`);
}

La même logique avec axios est tout aussi directe : il suffit de préciser responseType: "arraybuffer" pour récupérer le PDF binaire. 

import axios from "axios";
import { writeFile } from "node:fs/promises";

const corps = new URLSearchParams({
  template_id: "facture-standard",
  json_data: JSON.stringify({ client_nom: "Boulangerie Martin" }),
  output_filename: "facture.pdf",
});

const reponse = await axios.post("https://docx.layerone.fr/render-document", corps, {
  headers: { "X-API-Key": "VOTRE_CLE_API" },
  responseType: "arraybuffer",
});

await writeFile("facture.pdf", Buffer.from(reponse.data));

Récupérer le PDF et gérer les erreurs

Dans les deux langages, le principe est identique : la réponse n'est pas du texte JSON mais le fichier lui-même, renvoyé en flux binaire. On l'écrit sur le disque, on le renvoie à l'utilisateur, ou on l'archive. Pensez à traiter les cas d'erreur :

  • 401 / 403 : clé API absente, invalide ou expirée. Vérifiez l'en-tête X-API-Key.
  • 404 : le template_id n'existe pas ou a été supprimé.
  • 429 : quota mensuel atteint sur le plan gratuit. Le code response.text précise la cause.
  • 5xx : erreur côté service. Prévoyez un nouvel essai avec temporisation (retry).

Toujours vérifier le code HTTP avant d'écrire le fichier : un corps d'erreur écrit en .pdf donnerait un fichier illisible.

Factures électroniques : l'endpoint Factur-X

Pour les factures, DocX expose un second endpoint, POST /render-facturx, qui produit directement une facture Factur-X (un PDF/A-3 contenant les données structurées), conforme à la réforme française de la facture électronique. Le principe d'appel est le même qu'avec /render-document : en-tête X-API-Key, corps formulaire avec template_id, json_data et output_filename. Vous générez ainsi des factures à la fois lisibles par un humain et exploitables par un logiciel comptable, sans bibliothèque supplémentaire.

Cas d'usage concrets

  • Factures : génération automatique à chaque vente, en PDF classique ou en Factur-X pour la conformité 2026.
  • Devis : un modèle, des données, un devis prêt à envoyer en quelques millisecondes.
  • Rapports : rapports d'intervention, comptes rendus, bilans périodiques générés en masse.
  • Contrats et conventions : remplissez les clauses variables depuis votre base de données.

Intégrable partout, gratuit pour démarrer

Au-delà de Python et Node.js, DocX est aussi disponible via npm, MCP (pour Claude, ChatGPT, Cursor), Zapier, Make, n8n, Pipedream, Bubble, Adalo et Postman. Une spécification OpenAPI publique permet de générer un client dans le langage de votre choix.

Le plan gratuit offre 20 documents par mois, sans carte bancaire : largement de quoi valider votre intégration en conditions réelles avant de passer à l'échelle.

Obtenir une clé API gratuite Découvrir l'API

Questions fréquentes

Générer un PDF par API en Python ou Node.js, est-ce gratuit ?

Oui pour démarrer : le plan gratuit de DocX offre 20 documents par mois, sans carte bancaire. De quoi valider votre intégration Python ou Node.js en conditions réelles avant de passer à l'échelle.

Où obtenir la clé API utilisée dans les exemples de code ?

Sur l'espace développeur https://dev.layerone.fr, après inscription. Cette clé s'envoie dans l'en-tête X-API-Key de chaque requête vers https://docx.layerone.fr. Conservez-la côté serveur, jamais dans du code front-end public.

Faut-il envoyer du JSON ou un formulaire à l'API ?

L'endpoint render-document attend un corps au format formulaire application/x-www-form-urlencoded, et non du JSON brut. Vous passez trois champs : template_id, json_data (vos données sérialisées en chaîne JSON, via json.dumps en Python ou JSON.stringify en Node.js) et output_filename.

Peut-on générer des PDF sans écrire de code Python ni Node.js ?

Oui : au-delà du code, DocX se branche sur des outils no-code comme Zapier, Make, n8n, Pipedream, Bubble et Adalo, ainsi que sur npm, MCP et Postman. Une spécification OpenAPI publique permet aussi de générer un client dans le langage de votre choix.

Articles connexes

API de génération de PDF et documents Word API facture électronique Factur-X Génération de documents par IA (MCP) Présentation de l'API Layerone Espace développeur et clés API