---
title: "Extraire les données de factures en JSON avec un LLM"
description: "Un pipeline de production pour factures, reçus et formulaires : préparation des images, prompt JSON, validation Pydantic, contrôles de calcul, relances, revue."
url: https://broadrouter.com/fr/blog/extract-data-from-documents-with-vision-llm/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/extract-data-from-documents-with-vision-llm/) (mis à jour le 2026-11-14).

# Extraire factures, reçus et formulaires en JSON avec un LLM vision

Par l’équipe BroadNet Inference · 4 min de lecture · Publié 2026-11-14

Convertissez chaque page en image, envoyez-la à un modèle de vision avec un prompt qui nomme chaque champ et son format, et demandez uniquement du JSON. Validez ensuite dans le code : analysez-le, vérifiez son schéma, vérifiez que les lignes s’additionnent jusqu’au total, et relancez une fois avec l’erreur. Les échecs répétés partent vers une personne.

## À retenir

-   Le modèle lit, votre code décide. N’écrivez jamais des données extraites dans une comptabilité sans contrôles de schéma et de calcul.
-   Nommez dans le prompt chaque champ, son type et son format, et dites quoi renvoyer quand un champ manque (null, jamais une supposition).
-   Les contrôles de calcul détectent la plupart des erreurs de lecture : les totaux de ligne doivent faire le sous-total, et sous-total plus taxe doit égaler le total.
-   Relancez une fois avec l’erreur de validation dans le prompt ; les échecs répétés vont dans une file de revue humaine.
-   En paiement à l’usage, les images sont facturées comme tokens d’entrée et les grandes images en consomment davantage : redimensionnez avant l’envoi.

**Sur cette page**

1.  À quoi ressemble le pipeline ?
2.  Comment préparer les images des documents ?
3.  Comment rédiger le prompt d’extraction ?
4.  Comment obtenir une sortie structurée et la valider ?
5.  Quels contrôles détectent le plus d’erreurs ?
6.  Comment mesurer la précision avant la mise en production ?
7.  Quels modèles de vision conviennent sur BroadNet Inference ?
8.  La place de BroadNet Inference

_[image: A paper invoice headed "فاتورة" (invoice) with tabs labelled Vendor, Date and Total, and the text "Turn documents into useful data."]_

Illustrative example.

Factures, reçus et formulaires posent tous le même problème : les données sont dans une image, et vous en avez besoin dans une base de données. L’OCR à base de modèles casse à chaque nouvelle mise en page de fournisseur. Un [modèle vision-langage](https://broadrouter.com/fr/glossary/vision-language-model/) lit la page et renvoie directement les champs. Le piège : il peut se tromper avec assurance, donc le travail se situe dans le pipeline qui l’entoure. Cet article couvre le pipeline général, quelle que soit la langue. Pour les documents en arabe, voir [lire des factures arabes avec la vision](https://broadrouter.com/fr/guides/read-arabic-invoices-with-vision/) pour la configuration, et [OCR arabe ou LLM vision](https://broadrouter.com/fr/blog/arabic-ocr-vision-llm/) pour savoir quand l’OCR classique est le meilleur outil.

## À quoi ressemble le pipeline ?

1.  **Préparer** chaque page : convertir les PDF en images, corriger la rotation, redimensionner.
2.  **Extraire** : une requête par document avec un prompt champ par champ, JSON uniquement.
3.  **Valider** : analyser, vérifier le schéma, vérifier les calculs.
4.  **Relancer** une fois avec le message d’erreur si la validation échoue.
5.  **Réviser** : tout ce qui échoue encore part vers une personne, avec l’image et le brouillon.
6.  **Mesurer** la précision par champ sur un échantillon étiqueté, et recommencer à chaque changement de modèle ou de prompt.

## Comment préparer les images des documents ?

Convertissez les PDF en images avec PyMuPDF et gardez le plus petit texte net sans envoyer plus de pixels que nécessaire :

```python
# pip install pymupdf pillow
import base64, io
import pymupdf  # older code imports it as fitz
from PIL import Image

def pdf_pages_as_data_urls(path, long_edge=1800):
    urls = []
    for page in pymupdf.open(path):
        pix = page.get_pixmap(dpi=200)
        img = Image.open(io.BytesIO(pix.tobytes("png"))).convert("RGB")
        img.thumbnail((long_edge, long_edge))
        buf = io.BytesIO()
        img.save(buf, format="JPEG", quality=90)
        urls.append("data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode())
    return urls
```

Sur BroadNet Inference, les images passent dans le message sous forme d’URL `data:` avec un type MIME exact et, en [paiement à l’usage](https://broadrouter.com/fr/glossary/pay-as-you-go/), elles sont facturées comme tokens d’entrée ; les grandes images en consomment davantage. Mesurez une fois les tokens par page avec le bloc `usage` et dimensionnez vos lots à partir de là ; [compter les tokens avant l’envoi](https://broadrouter.com/fr/blog/count-tokens-before-sending/) montre comment faire, et [le coût d’un LLM vision par image](https://broadrouter.com/fr/blog/cheapest-vision-llm-api/) convertit les tokens en coût par page. Pour estimer les tokens par page avant tout envoi, déposez un scan d’exemple dans le [calculateur de tokens d’image](https://broadrouter.com/tools/image-token-calculator/).

## Comment rédiger le prompt d’extraction ?

Soyez précis sur les clés, les types, les formats et les valeurs manquantes. Si vous voulez aussi un JSON Schema pour la validation, ou pour les fournisseurs qui en imposent un, le [générateur de JSON Schema](https://broadrouter.com/tools/json-schema-generator/) gratuit le construit à partir d’une facture d’exemple :

```python
PROMPT = """Extract this invoice. Reply with one JSON object only, no prose.
Keys:
- vendor_name: string, as printed
- vendor_tax_id: string or null
- invoice_number: string
- invoice_date: string, YYYY-MM-DD
- currency: ISO 4217 code, e.g. USD, EUR, SAR
- line_items: list of {description: string, quantity: number, unit_price: number, line_total: number}
- subtotal: number
- tax: number or null
- total: number
Rules: numbers without currency symbols or thousands separators. If a field is not on the page, use null. Never guess."""
```

« Never guess » (traduction : « ne jamais deviner ») accompagné d’un `null` explicite est ce qui compte le plus. Sans cela, les modèles comblent les trous avec des valeurs plausibles, ce qui est pire qu’un champ vide, car cela passe un contrôle naïf.

## Comment obtenir une sortie structurée et la valider ?

Il existe deux niveaux de [sortie structurée](https://broadrouter.com/fr/glossary/structured-output/). Le mode JSON garantit un JSON valide. La sortie contrainte par schéma garantit en plus la structure. Le guide d’OpenAI le dit clairement : les deux produisent du JSON valide, mais seuls les Structured Outputs garantissent le respect du schéma. La prise en charge de l’un ou l’autre varie selon le fournisseur et le modèle : validez donc dans le code, quoi que promette l’API.

```python
import json, os
from decimal import Decimal
from pydantic import BaseModel, ValidationError, model_validator
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

class Line(BaseModel):
    description: str
    quantity: Decimal
    unit_price: Decimal
    line_total: Decimal

class Invoice(BaseModel):
    vendor_name: str
    vendor_tax_id: str | None = None
    invoice_number: str
    invoice_date: str
    currency: str
    line_items: list[Line]
    subtotal: Decimal
    tax: Decimal | None = None
    total: Decimal

    @model_validator(mode="after")
    def sums(self):
        tol = Decimal("0.02")
        if abs(sum(l.line_total for l in self.line_items) - self.subtotal) > tol:
            raise ValueError("line_totals do not sum to subtotal")
        if abs(self.subtotal + (self.tax or 0) - self.total) > tol:
            raise ValueError("subtotal + tax != total")
        return self

def extract(image_urls, model="broadnet/qwen3.8-27b"):
    content = [{"type": "text", "text": PROMPT}] + [
        {"type": "image_url", "image_url": {"url": u}} for u in image_urls]
    messages = [{"role": "user", "content": content}]
    for attempt in range(2):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=4000, temperature=0)
        raw = (r.choices[0].message.content or "").strip().removeprefix("```json").removesuffix("```")
        try:
            return Invoice.model_validate(json.loads(raw)), r.usage
        except (json.JSONDecodeError, ValidationError, ValueError) as e:
            messages += [{"role": "assistant", "content": raw},
                         {"role": "user", "content": f"That failed validation: {e}. Re-read the image and reply with corrected JSON only."}]
    return None, r.usage  # send to human review
```

Utilisez `Decimal`, pas `float`, pour les montants. Gardez un `max_tokens` généreux : Qwen3.8 27B raisonne avant de répondre, et le raisonnement compte dans la limite ; un plafond bas renvoie une chaîne vide. Voir [pourquoi les modèles de raisonnement renvoient des réponses vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).

## Quels contrôles détectent le plus d’erreurs ?

| Contrôle | Détecte | Coût |
| --- | --- | --- |
| Le JSON s’analyse | Texte autour du JSON, troncature | Gratuit |
| Le schéma valide | Clés manquantes, mauvais types | Gratuit |
| Les lignes font le sous-total | Chiffres mal lus, lignes sautées | Gratuit |
| Sous-total + taxe = total | Total ou taxe mal lus | Gratuit |
| La date s’analyse et n’est pas dans le futur | Jour et mois inversés, bruit d’OCR | Gratuit |
| Le numéro fiscal du fournisseur figure dans votre liste de fournisseurs | Mauvais fournisseur, fraude | Une recherche |
| Numéro de facture en double pour un fournisseur | Double paiement | Une requête |

Les contrôles de calcul sont les plus rentables : un seul chiffre mal lu casse presque toujours une somme. Les reçus n’ont souvent pas de détail par ligne : vérifiez ce qui est présent et acceptez moins de contrôles pour eux.

## Comment mesurer la précision avant la mise en production ?

Étiquetez à la main 50 à 100 documents réels, lancez le pipeline et notez **par champ**, pas par document. Les totaux et les dates méritent une exigence plus stricte que les descriptions. Suivez trois chiffres : la précision par champ, la part de documents qui passent la validation sans relance, et la part envoyée en revue. La conception de cette étape de revue, y compris les audits aléatoires de documents validés, est détaillée dans [intégrer la revue humaine à votre flux d’IA documentaire](https://broadrouter.com/fr/blog/document-review-queues/). Quand vous essayez un autre modèle, utilisez le même jeu ; [évaluer un LLM avant de changer](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/) décrit la méthode.

## Quels modèles de vision conviennent sur BroadNet Inference ?

| Modèle | Images | Contexte | Remarques |
| --- | --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) | Oui | 262 144 | Outils, sortie structurée et raisonnement listés ; testé en arabe par BroadNet |
| [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) | Oui | 32 768 | Prix le plus bas chez BroadNet ; fonctionne avec le crédit gratuit et la clé horaire |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) | Oui | 1 048 576 | Images incluses dans les forfaits illimités |

Les prix par million de tokens figurent sur la [page des tarifs](https://broadrouter.com/fr/pricing/) ; multipliez vos tokens mesurés par page par le volume mensuel dans le [calculateur de coût d’API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).

## La place de BroadNet Inference

BroadNet Inference accepte des images sur trois modèles de chat via le format de message standard d’OpenAI, et ne conserve ni prompts, ni images, ni réponses après la requête, ce qui compte pour des factures pleines de noms, de numéros fiscaux et de coordonnées bancaires ([conservation zéro des données](https://broadrouter.com/fr/privacy/)). Sa documentation liste la sortie structurée pour Qwen3.8 27B mais ne documente pas de paramètres de schéma : comptez donc sur la couche de validation ci-dessus plutôt que sur l’API pour imposer votre schéma. BroadNet ne publie ni limite de taille d’image ni produit dédié d’IA documentaire, et sa documentation décrit l’entrée d’images, pas l’envoi de PDF : convertissez donc d’abord les pages en images. Pour de gros volumes à budget fixe, un [forfait illimité DeepSeek V4.1 Flash](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/) inclut les images.

Outils gratuits sur ce sujet (en anglais)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Sortie structurée (structured output)](https://broadrouter.com/fr/glossary/structured-output/)

La sortie structurée est une fonction des API LLM qui contraint la réponse d’un modèle à un format défini par le développeur, en général un JSON Schema, pour que le code puisse l’analyser de façon fiable. Elle est plus stricte que le mode JSON, qui garantit un JSON valide mais pas une structure précise.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Reconnaissance optique de caractères (OCR)](https://broadrouter.com/fr/glossary/ocr/)

La reconnaissance optique de caractères (OCR) est une technologie qui détecte le texte imprimé ou manuscrit d’une image, d’un scan ou d’un PDF et le convertit en caractères lisibles par une machine. L’OCR classique produit le texte et sa position sur la page ; les modèles vision-langage peuvent lire le texte et répondre directement à des questions dessus.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

[JSON Schema](https://broadrouter.com/fr/glossary/json-schema/)

JSON Schema est un vocabulaire, écrit en JSON, qui sert à décrire et à valider la structure de données JSON : types, champs obligatoires, valeurs autorisées et imbrication. La version actuelle est la 2020-12. Les API de LLM l’utilisent pour définir les paramètres des outils et la forme exacte que doit suivre une sortie structurée.

[Forfait LLM (flat rate)](https://broadrouter.com/fr/glossary/flat-rate-llm-plan/)

Un forfait LLM facture un prix fixe pour une période, par exemple un mois, en échange de l’accès à une API de modèle de langage, au lieu de facturer au token. Ces forfaits limitent généralement autre chose, comme la concurrence, la vitesse, les modèles ou des fenêtres d’usage : les plafonds comptent donc autant que le prix.

[Mode JSON (JSON mode)](https://broadrouter.com/fr/glossary/json-mode/)

Le mode JSON est un réglage des API de LLM, response\_format {"type": "json\_object"} dans les API de style OpenAI, qui fait de la réponse du modèle un JSON valide et analysable. Contrairement aux Structured Outputs avec un JSON Schema, il ne garantit pas les clés, les types ni les valeurs de l’objet.

## Questions fréquentes

### Un LLM vision peut-il remplacer l’OCR pour les factures ?

Pour beaucoup de mises en page, oui. Un modèle de vision lit l’image et associe le texte aux champs en une seule étape, sans modèle par fournisseur. Il lit parfois mal des chiffres : gardez donc la validation et une file de revue.

### Comment obtenir un JSON fiable d’un modèle de vision ?

Listez dans le prompt les clés, types et formats exacts, demandez uniquement du JSON, et analysez-le dans le code. Si le modèle prend en charge une sortie contrainte par schéma, utilisez-la. Dans tous les cas, validez avec une bibliothèque de schéma et relancez une fois avec l’erreur.

### Comment extraire les données d’une facture PDF de plusieurs pages ?

Convertissez chaque page en image, puis envoyez toutes les pages d’une même facture dans une seule requête si elles tiennent dans le contexte du modèle, pour que les totaux de la dernière page puissent être rapprochés des lignes de la première.

### Quelle résolution choisir pour les images de factures ?

Assez élevée pour que les plus petits chiffres soient nets, et pas plus. Les grandes images consomment plus de tokens d’entrée. Un grand côté d’environ 1 500 à 2 000 pixels est un bon point de départ pour une page A4 ; testez sur vos propres documents.

### Comment mesurer la précision de l’extraction ?

Étiquetez à la main 50 à 100 documents réels et notez champ par champ. Suivez les totaux et les dates séparément des champs en texte libre comme les noms de fournisseurs, car leurs erreurs n’ont pas le même coût.

## À lire ensuite

-   [OCR arabe ou LLM de vision : lire documents et factures en arabe](https://broadrouter.com/fr/blog/arabic-ocr-vision-llm/)
-   [Comparatif des API OCR pour l’arabe : Google, Azure, Textract, Mistral](https://broadrouter.com/fr/blog/arabic-ocr-api-comparison/)
-   [API LLM de vision la moins chère : coût par image et par page, calculé](https://broadrouter.com/fr/blog/cheapest-vision-llm-api/)
-   [Mode JSON ou json\_schema : une sortie structurée qui tient](https://broadrouter.com/fr/blog/structured-output-json-schema/)
-   [Comment évaluer un LLM avant de changer de fournisseur](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/)
-   [Compter les tokens avant d’envoyer une requête LLM](https://broadrouter.com/fr/blog/count-tokens-before-sending/)
-   [Intégrer la relecture humaine à votre workflow d’IA documentaire](https://broadrouter.com/fr/blog/document-review-queues/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Lire des factures et reçus arabes avec un modèle de vision](https://broadrouter.com/fr/guides/read-arabic-invoices-with-vision/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-extract-data-from-documents-with-vision-llm&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API BroadNet Inference : chat avec une image, types MIME, images dans les forfaits (consultée le 2026-11-14) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-extract-data-from-documents-with-vision-llm&utm_content=sources#requests)
-   [Prix, modèles et modalités de BroadNet Inference lisibles par machine, pricing.json (consulté le 2026-11-14) (en anglais)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-extract-data-from-documents-with-vision-llm&utm_content=sources)
-   [Guide Structured Outputs d’OpenAI, mode JSON et respect du schéma (consulté le 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [Documentation Pydantic, modèles et validation (consultée le 2026-11-14)](https://docs.pydantic.dev/latest/concepts/models/)
-   [Documentation PyMuPDF, rendu des pages en images (consultée le 2026-11-14)](https://pymupdf.readthedocs.io/en/latest/recipes-images.html)
