Invoice & Receipt OCR.

Independent comparison of 6 OCR models on real invoice and receipt processing. We measure what matters: line-item extraction, totals verification, and structure preservation.

Mistral OCR 3 (Cost-Effective)

from mistralai import Mistral
import base64
import json

client = Mistral(api_key="your-api-key")

def extract_invoice(image_path):
    with open(image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    response = client.ocr.process(
        model="mistral-ocr-2512",
        document={"type": "image", "data": image_data}
    )

    # Parse markdown output for invoice fields
    return response.content

Claude Sonnet 4 (Low Hallucination)

import anthropic
import base64
import json

client = anthropic.Anthropic()

def extract_invoice(image_path):
    with open(image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": image_data
                }},
                {"type": "text", "text": """Extract invoice data as JSON:
{
  "invoice_number": "",
  "date": "",
  "vendor": {"name": "", "address": "", "tax_id": ""},
  "buyer": {"name": "", "address": "", "tax_id": ""},
  "line_items": [{"description": "", "qty": 0, "unit_price": 0, "total": 0}],
  "subtotal": 0,
  "tax_rate": "",
  "tax_amount": 0,
  "total": 0
}"""}
            ]
        }]
    )
    return json.loads(message.content[0].text)

GPT-4V with JSON Mode

from openai import OpenAI
import base64
import json

client = OpenAI()

def extract_invoice(image_path):
    with open(image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    response = client.chat.completions.create(
        model="gpt-4o",
        response_format={"type": "json_object"},
        messages=[{
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {
                    "url": f"data:image/png;base64,{image_data}"
                }},
                {"type": "text", "text": """Extract all invoice data.
Return JSON with: invoice_number, date, vendor, buyer,
line_items (description, qty, unit_price, total),
subtotal, tax_rate, tax_amount, total"""}
            ]
        }]
    )
    return json.loads(response.choices[0].message.content)

Azure Document Intelligence (Specialized)

from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

client = DocumentAnalysisClient(
    endpoint="your-endpoint",
    credential=AzureKeyCredential("your-key")
)

def extract_invoice(file_path):
    with open(file_path, "rb") as f:
        poller = client.begin_analyze_document(
            "prebuilt-invoice", f
        )
    result = poller.result()

    invoice = result.documents[0]
    return {
        "invoice_number": invoice.fields.get("InvoiceId").value,
        "vendor": invoice.fields.get("VendorName").value,
        "total": invoice.fields.get("InvoiceTotal").value.amount,
        "line_items": [
            {
                "description": item.value.get("Description").value,
                "quantity": item.value.get("Quantity").value,
                "amount": item.value.get("Amount").value.amount
            }
            for item in invoice.fields.get("Items").value
        ]
    }

Docling (Open Source / Self-Hosted)

from docling.document_converter import DocumentConverter
from docling.datamodel.base_models import InputFormat, DocumentFormat

converter = DocumentConverter()

def extract_invoice(file_path):
    result = converter.convert(file_path)
    doc = result.document

    # Docling returns structured document with tables
    tables = []
    for table in doc.tables:
        tables.append({
            "headers": table.columns,
            "rows": [
                {col: row.cells[i].text for i, col in enumerate(table.columns)}
                for row in table.body
            ]
        })

    return {
        "text": doc.export_to_markdown(),
        "tables": tables
    }

At Scale: 100,000 Invoices/Month