Générer une facture Factur-X conforme par API — Guide développeur 2026

1. La réforme e-invoicing en France : contexte et calendrier

La réforme de la facturation électronique en France, pilotée par la DGFiP, impose aux entreprises assujetties à la TVA d'émettre et de recevoir leurs factures B2B dans un format structuré (Factur-X, UBL 2.1 ou CII) via une Plateforme de Dématérialisation Partenaire (PDP). L'obligation s'applique aux grandes entreprises et ETI le 1er septembre 2026, puis aux PME et micro-entreprises le 1er septembre 2027.

La France est en train de vivre une transformation majeure de sa fiscalité : la généralisation de la facturation électronique entre entreprises assujetties à la TVA (B2B). Initiée par la loi de finances 2020 et précisée par l'ordonnance du 15 septembre 2021, cette réforme est pilotée par la Direction Générale des Finances Publiques (DGFiP).

Le calendrier de déploiement (après report de 2024) :

La réforme repose sur un modèle "Y" (ou "clearance") : les factures doivent transiter par une Plateforme de Dématérialisation Partenaire (PDP) immatriculée par la DGFiP, ou par le portail public Chorus Pro. La facture est transmise à l'administration fiscale en temps réel, ce qui vise à lutter contre la fraude à la TVA estimée à 13 milliards d'euros par an en France. En 2026, plus de 60 PDPs ont été immatriculées par la DGFiP pour accompagner la transition. La facturation électronique est déjà obligatoire pour les factures B2G (administration publique) via Chorus Pro depuis le 1er janvier 2020.

2. Qu'est-ce que Factur-X / ZUGFeRD ?

Factur-X est un format de facturation électronique hybride franco-allemand, développé par le FNFE-MPE et le FeRD allemand. C'est un fichier PDF/A-3 qui embarque un XML structuré selon la norme UN/CEFACT CII D22B. Le même format est appelé ZUGFeRD 2.x en Allemagne. La dernière version officielle est Factur-X 1.0.07, conforme à la norme européenne EN16931.

Factur-X est la norme française de facturation électronique hybride. Elle a été développée conjointement par le FNFE-MPE (Forum National de la Facture Électronique) et le FeRD (Forum für elektronische Rechnungen Deutschland) pour créer un standard commun franco-allemand. En Allemagne, ce même format s'appelle ZUGFeRD 2.x.

Le principe du format hybride est élégant : la facture est un fichier PDF/A-3 (archivage long terme) qui contient en pièce jointe un fichier XML structuré suivant la norme UN/CEFACT CII (Cross Industry Invoice). Cela permet :

• Lisibilité humaine : le PDF est lu par n'importe quel lecteur PDF traditionnel
• Traitement automatisé : le XML embarqué est exploitable par les ERP, les PDP et les systèmes de comptabilité sans ressaisie
• Rétrocompatibilité : une facture Factur-X envoyée à un destinataire qui ne supporte pas encore le format reste lisible comme un PDF ordinaire

facture_2026_001.pdf (PDF/A-3)
├── Page visuelle (rendu lisible humain)
└── Pièce jointe : factur-x.xml (CII D22B)
    ├── <rsm:CrossIndustryInvoice>
    │   ├── <rsm:ExchangedDocumentContext>
    │   │   └── <ram:GuidelineSpecifiedDocumentContextParameter>
    │   │       └; Profil : MINIMUM / BASIC / EN16931
    │   ├── <rsm:ExchangedDocument>
    │   │   ├── Numéro de facture, date
    │   │   └── Type (380 = facture, 381 = avoir)
    │   └── <rsm:SupplyChainTradeTransaction>
    │       ├── Vendeur (nom, SIREN, TVA intracommunautaire)
    │       ├── Acheteur
    │       ├── Lignes de facture (articles, quantités, prix)
    │       └── Totaux TVA par taux

3. Les 3 profils Factur-X expliqués

Factur-X définit trois profils de conformité : MINIMUM (données d'identification uniquement, adapté aux micro-entreprises), BASIC (lignes détaillées et ventilation TVA, recommandé pour les PME) et EN16931 dit COMFORT (conformité complète à la norme européenne, obligatoire pour les marchés publics). Le profil BASIC est la référence pour la majorité des transactions B2B françaises.

Factur-X définit plusieurs niveaux de conformité appelés profils, qui déterminent la quantité d'information structurée obligatoire dans le XML. Choisir le bon profil est crucial : un profil trop léger peut ne pas être accepté par certaines PDPs.

4. Générer une facture Factur-X en curl

L'API HubActiva Factur-X génère une facture conforme via un appel POST en curl. Le corps JSON spécifie le profil, les parties (vendeur et acheteur avec SIREN et numéro TVA), les lignes de facturation et les conditions de paiement. La réponse est le fichier PDF/A-3 binaire, sauvegardable directement avec l'option --output.

L'API HubActiva Factur-X accepte une requête POST avec les données de la facture en JSON et retourne le fichier PDF/A-3 avec le XML embarqué. Voici comment l'appeler avec curl :

curl -X POST \
  'https://hubactiva-facturx.p.rapidapi.com/generate' \
  -H 'X-RapidAPI-Key: votre_clé_api_rapidapi' \
  -H 'X-RapidAPI-Host: hubactiva-facturx.p.rapidapi.com' \
  -H 'Content-Type: application/json' \
  -d '{
    "profile": "BASIC",
    "invoice_number": "FA-2026-0042",
    "invoice_date": "2026-03-19",
    "due_date": "2026-04-18",
    "currency": "EUR",
    "seller": {
      "name": "ACME SAS",
      "siren": "123456789",
      "vat_number": "FR12123456789",
      "address": "12 rue de la Paix",
      "postal_code": "75001",
      "city": "Paris",
      "country": "FR"
    },
    "buyer": {
      "name": "Client Corp SARL",
      "siren": "987654321",
      "vat_number": "FR98987654321",
      "address": "45 avenue Victor Hugo",
      "postal_code": "69001",
      "city": "Lyon",
      "country": "FR"
    },
    "lines": [
      {
        "description": "Développement API — Sprint 1",
        "quantity": 10,
        "unit": "JOUR",
        "unit_price_ht": 750.00,
        "vat_rate": 20.0
      },
      {
        "description": "Hébergement cloud — Mars 2026",
        "quantity": 1,
        "unit": "MOIS",
        "unit_price_ht": 299.00,
        "vat_rate": 20.0
      }
    ],
    "payment": {
      "iban": "FR76 3000 6000 0112 3456 7890 189",
      "bank_name": "Crédit Lyonnais"
    }
  }' \
  --output facture_2026_0042.pdf

La réponse est directement le fichier PDF binaire. L'option --output sauvegarde le fichier localement. Pour récupérer uniquement le XML, ajoutez le paramètre "output_format": "xml" dans le corps de la requête.

5. Générer une facture Factur-X en Python

Le client Python pour l'API Factur-X utilise requests.Session pour réutiliser la connexion HTTP. Il accepte des dataclasses Python pour le vendeur, l'acheteur et les lignes de facturation. La méthode generate() retourne les bytes PDF/A-3, tandis que generate_and_save() sauvegarde directement le fichier. Compatible Python 3.8+ et intégrable dans Django, FastAPI et AWS Lambda.

Voici un client Python complet, avec gestion de la réponse binaire et sauvegarde du fichier :

import requests
import json
from datetime import date, timedelta
from pathlib import Path
from dataclasses import dataclass, field
from typing import List, Optional


@dataclass
class InvoiceLine:
    description: str
    quantity: float
    unit_price_ht: float
    vat_rate: float = 20.0
    unit: str = "UNITE"

    @property
    def total_ht(self) -> float:
        return round(self.quantity * self.unit_price_ht, 2)

    @property
    def total_tva(self) -> float:
        return round(self.total_ht * self.vat_rate / 100, 2)


@dataclass
class Party:
    name: str
    siren: str
    vat_number: str
    address: str
    postal_code: str
    city: str
    country: str = "FR"


class HubActivaFacturXClient:
    BASE_URL = "https://hubactiva-facturx.p.rapidapi.com"
    
    def __init__(self, api_key: str):
        self.session = requests.Session()
        self.session.headers.update({
            "X-RapidAPI-Key": api_key,
            "X-RapidAPI-Host": "hubactiva-facturx.p.rapidapi.com",
            "Content-Type": "application/json"
        })

    def generate(
        self,
        invoice_number: str,
        seller: Party,
        buyer: Party,
        lines: List[InvoiceLine],
        profile: str = "BASIC",
        invoice_date: Optional[date] = None,
        payment_days: int = 30,
        iban: Optional[str] = None
    ) -> bytes:
        """
        Génère une facture Factur-X et retourne le PDF en bytes.
        
        Args:
            profile: 'MINIMUM', 'BASIC', ou 'EN16931'
        """
        inv_date = invoice_date or date.today()
        due_date = inv_date + timedelta(days=payment_days)

        payload = {
            "profile": profile,
            "invoice_number": invoice_number,
            "invoice_date": inv_date.isoformat(),
            "due_date": due_date.isoformat(),
            "currency": "EUR",
            "seller": {
                "name": seller.name,
                "siren": seller.siren,
                "vat_number": seller.vat_number,
                "address": seller.address,
                "postal_code": seller.postal_code,
                "city": seller.city,
                "country": seller.country,
            },
            "buyer": {
                "name": buyer.name,
                "siren": buyer.siren,
                "vat_number": buyer.vat_number,
                "address": buyer.address,
                "postal_code": buyer.postal_code,
                "city": buyer.city,
                "country": buyer.country,
            },
            "lines": [
                {
                    "description": l.description,
                    "quantity": l.quantity,
                    "unit": l.unit,
                    "unit_price_ht": l.unit_price_ht,
                    "vat_rate": l.vat_rate,
                }
                for l in lines
            ],
        }
        
        if iban:
            payload["payment"] = {"iban": iban}

        response = self.session.post(
            f"{self.BASE_URL}/generate",
            json=payload,
            timeout=30
        )
        response.raise_for_status()
        return response.content

    def generate_and_save(self, output_path: str, **kwargs) -> Path:
        """Génère et sauvegarde la facture. Retourne le Path du fichier."""
        pdf_bytes = self.generate(**kwargs)
        path = Path(output_path)
        path.write_bytes(pdf_bytes)
        print(f"Facture générée : {path} ({len(pdf_bytes) / 1024:.1f} KB)")
        return path


# Exemple d'utilisation
if __name__ == "__main__":
    client = HubActivaFacturXClient(api_key="votre_clé_rapidapi")

    ma_societe = Party(
        name="ACME SAS",
        siren="123456789",
        vat_number="FR12123456789",
        address="12 rue de la Paix",
        postal_code="75001",
        city="Paris"
    )

    mon_client = Party(
        name="Client Corp SARL",
        siren="987654321",
        vat_number="FR98987654321",
        address="45 avenue Victor Hugo",
        postal_code="69001",
        city="Lyon"
    )

    lignes = [
        InvoiceLine("Développement API — Sprint 1", 10, 750.00),
        InvoiceLine("Hébergement cloud Mars 2026", 1, 299.00),
    ]

    client.generate_and_save(
        output_path="facture_2026_0042.pdf",
        invoice_number="FA-2026-0042",
        seller=ma_societe,
        buyer=mon_client,
        lines=lignes,
        profile="BASIC",
        iban="FR76 3000 6000 0112 3456 7890 189"
    )

6. Pourquoi la conformité est vitale pour votre business

La non-conformité à la réforme e-invoicing française expose les entreprises à des amendes jusqu'à 15 € par facture non transmise (plafond : 15 000 €/an), au rejet des factures par les PDPs bloquant les paiements, et à l'exclusion des appels d'offres publics. Pour les éditeurs de logiciels, la non-intégration de Factur-X représente un risque commercial majeur dès septembre 2026.

Les sanctions pour non-conformité à la réforme e-invoicing ne sont pas anodines. Voici ce que risquent les entreprises qui ne sont pas prêtes :

• Rejet des factures par les PDPs : une facture non conforme sera rejetée par la plateforme de dématérialisation, ce qui bloque le paiement jusqu'à correction.
• Amendes fiscales : l'administration fiscale peut infliger des amendes pouvant atteindre 15 € par facture non transmise, avec un plafond de 15 000 € par an.
• Inéligibilité aux appels d'offres publics : Chorus Pro (portail pour les marchés publics) exige déjà la facturation électronique. Sans Factur-X ou UBL, impossible de facturer l'État ou les collectivités.
• Perte de clients : les grandes entreprises, soumises à l'obligation dès septembre 2026, exigeront de leurs fournisseurs PME qu'ils envoient des factures électroniques conformes.

Pour les éditeurs de logiciels, la mise en conformité est aussi une opportunité : intégrer Factur-X nativement dans votre produit devient un argument commercial fort auprès des 3,8 millions de PME françaises concernées par la réforme.

7. Accéder à l'API HubActiva Factur-X

L'API HubActiva Factur-X Generator génère des factures PDF/A-3 conformes à la norme Factur-X 1.0.07 via un appel REST. Elle prend en charge les profils MINIMUM, BASIC et EN16931, valide automatiquement la conformité XML avant génération et propose un retour XML seul pour les intégrations avancées. Un plan gratuit de 100 factures par mois est disponible.

L'API HubActiva Factur-X Generator vous permet de générer des factures Factur-X conformes sans avoir à implémenter la norme PDF/A-3 + CII vous-même. Elle prend en charge :

• Les 3 profils : MINIMUM, BASIC, EN16931
• La génération de PDF/A-3 avec XML embarqué
• La validation automatique de la conformité XML avant génération
• Le retour optionnel du XML seul (pour intégration avec votre propre PDF renderer)
• Un plan gratuit (100 factures/mois)