BroadRouter

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

Par l’équipe BroadNet Inference · 4 min de lecture · Publié

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.

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 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 pour la configuration, et OCR arabe ou LLM vision 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 :

# 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, 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 montre comment faire, et le coût d’un LLM vision par image 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.

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 gratuit le construit à partir d’une facture d’exemple :

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. 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.

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.

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. Quand vous essayez un autre modèle, utilisez le même jeu ; évaluer un LLM avant de changer décrit la méthode.

Quels modèles de vision conviennent sur BroadNet Inference ?

Modèle Images Contexte Remarques
Qwen3.8 27B Oui 262 144 Outils, sortie structurée et raisonnement listés ; testé en arabe par BroadNet
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 Oui 1 048 576 Images incluses dans les forfaits illimités

Les prix par million de tokens figurent sur la page des tarifs ; multipliez vos tokens mesurés par page par le volume mensuel dans le calculateur de coût d’API LLM.

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). 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 inclut les images.

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 en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity