Facturen uitlezen met AI: bouw je eigen OCR-tool (Unlimited-OCR)

python invoice_ocr.py input/factuur.pdf

output/
├── factuur.md      # de uitgelezen factuur (markdown)
└── factuur.json    # gestructureerde, gevalideerde gegevens

PDF
 ↓  Unlimited-OCR        (document parsing)
markdown / documentstructuur
 ↓  LLM-extractie        (structured extraction)
JSON
 ↓  validatie
gegevens kloppen  →  boeken   |   twijfel  →  handmatige controle

invoice-ocr/
├── invoice_ocr.py       # de tool (CLI)
├── invoice_schema.py    # Pydantic-schema + validatie
├── requirements.txt
├── input/               # hier zet je je PDF's
└── output/              # hier komt de md + json

mkdir invoice-ocr
cd invoice-ocr
mkdir input output
python -m venv .venv

.venv\Scripts\Activate.ps1

source .venv/bin/activate

nano requirements.txt

torch==2.10.0
torchvision==0.25.0
transformers==4.57.1
Pillow==12.1.1
einops==0.8.2
addict==2.4.0
easydict==1.13
pymupdf==1.27.2.2
pydantic==2.9.2
ollama==0.3.3

pip install -r requirements.txt

python -c "import torch; print(torch.cuda.is_available())"

ollama pull llama3.1

nano invoice_schema.py

from __future__ import annotations
 
import re
from datetime import date
 
from pydantic import BaseModel, Field
 
 
class InvoiceLine(BaseModel):
    description: str | None = None
    quantity: float | None = None
    unit_price: float | None = None
    vat_rate: float | None = None
    total: float | None = None
 
 
class Invoice(BaseModel):
    supplier: str | None = Field(None, description="Naam van de leverancier.")
    invoice_number: str | None = None
    invoice_date: date | None = None
    due_date: date | None = None
    kvk: str | None = None
    vat_number: str | None = None
    iban: str | None = None
    currency: str | None = None
    subtotal: float | None = None
    vat: float | None = None
    total: float | None = None
    lines: list[InvoiceLine] = Field(default_factory=list)
 
 
def _valid_iban(iban: str) -> bool:
    s = re.sub(r"\s+", "", iban).upper()
    if not re.fullmatch(r"[A-Z0-9]{15,34}", s):
        return False
    rearranged = s[4:] + s[:4]
    digits = "".join(str(int(c, 36)) for c in rearranged)
    return int(digits) % 97 == 1
 
 
def validate_invoice(inv: Invoice) -> list[str]:
    """Geeft een lijst met problemen terug. Leeg = klaar om te verwerken."""
    problems: list[str] = []
 
    if not inv.supplier:
        problems.append("Leverancier ontbreekt")
    if not inv.invoice_number:
        problems.append("Factuurnummer ontbreekt")
    if inv.invoice_date is None:
        problems.append("Factuurdatum ontbreekt of is ongeldig")
    if inv.total is None:
        problems.append("Totaalbedrag ontbreekt")
 
    # Rekenkundige controle: subtotaal + btw ≈ totaal (1 cent speling).
    if inv.subtotal is not None and inv.vat is not None and inv.total is not None:
        if abs((inv.subtotal + inv.vat) - inv.total) > 0.01:
            problems.append(f"Bedragen kloppen niet: {inv.subtotal} + {inv.vat} ≠ {inv.total}")
 
    if inv.due_date and inv.invoice_date and inv.due_date < inv.invoice_date:
        problems.append("Vervaldatum ligt vóór de factuurdatum")
 
    if inv.iban and not _valid_iban(inv.iban):
        problems.append(f"IBAN lijkt ongeldig: {inv.iban}")
 
    return problems

nano invoice_ocr.py

from __future__ import annotations
 
import argparse
import json
import re
import shutil
import sys
import tempfile
from pathlib import Path
 
 
def pdf_to_images(pdf_path: Path, dpi: int = 300) -> tuple[list[str], Path]:
    import fitz  # PyMuPDF
 
    tmp_dir = Path(tempfile.mkdtemp(prefix="invoice_ocr_"))
    scale = fitz.Matrix(dpi / 72, dpi / 72)
    paths: list[str] = []
    with fitz.open(pdf_path) as doc:
        for i, page in enumerate(doc):
            out = tmp_dir / f"page_{i + 1:04d}.png"
            page.get_pixmap(matrix=scale).save(out)
            paths.append(str(out))
    return paths, tmp_dir
 
 
_DET_RE = re.compile(r"<\|det\|>([^<\s]+)(?:\s*\[[^\]]*\])?\s*<\|/det\|>(.*)", re.DOTALL)
 
 
def strip_det_markers(raw: str) -> str:
    """Verwijder de <|det|>...<|/det|> markers uit de OCR-uitvoer."""
    blocks: list[list[str]] = []
    current: list[str] | None = None
    for line in raw.splitlines():
        line = line.rstrip()
        if not line:
            continue
        m = _DET_RE.match(line)
        if m:
            category, content = m.group(1).strip(), m.group(2).strip()
            if category == "image":
                continue
            if current is not None:
                blocks.append(current)
            current = [content] if content else []
            continue
        if current is None:
            current = []
        current.append(line)
    if current is not None:
        blocks.append(current)
    return "\n\n".join("\n".join(b) for b in blocks).strip()
 
 
class OCRModel:
    """Laadt Unlimited-OCR één keer."""
 
    def __init__(self, model_name: str) -> None:
        import torch
        from transformers import AutoModel, AutoTokenizer
 
        if not torch.cuda.is_available():
            raise RuntimeError("Geen CUDA-GPU gevonden. Gebruik een NVIDIA-GPU of de online demo.")
 
        self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
        self.model = (
            AutoModel.from_pretrained(
                model_name, trust_remote_code=True, use_safetensors=True, torch_dtype=torch.bfloat16
            )
            .eval()
            .cuda()
        )
 
    def read(self, image_paths: list[str]) -> str:
        out_dir = Path(tempfile.mkdtemp(prefix="invoice_ocr_out_"))
        try:
            self.model.infer_multi(
                self.tokenizer,
                prompt="<image>Multi page parsing.",
                image_files=image_paths,
                output_path=str(out_dir),
                image_size=1024,
                max_length=32768,
                no_repeat_ngram_size=35,
                ngram_window=1024,
                save_results=True,
            )
            texts: list[str] = []
            for pattern in ("*.mmd", "*.md", "*.txt"):
                for path in sorted(out_dir.glob(pattern)):
                    texts.append(path.read_text(encoding="utf-8"))
            return strip_det_markers("\n".join(texts))
        finally:
            shutil.rmtree(out_dir, ignore_errors=True)
 
 
EXTRACTION_PROMPT = """Je krijgt de uitgelezen tekst van een factuur.
Geef uitsluitend geldige JSON terug die exact dit schema volgt:
 
{schema}
 
Regels:
- Bedragen als getallen (punt als decimaalteken), geen valutasymbool.
- Datums als YYYY-MM-DD.
- Onbekende velden: null. lines is een lijst (mag leeg zijn).
- Geen uitleg, alleen de JSON.
 
Factuurtekst:
---
{text}
---
"""
 
 
def extract_json(markdown: str, model: str = "llama3.1") -> dict:
    """Laat een lokaal LLM (via Ollama) de tekst omzetten naar JSON."""
    import ollama
 
    from invoice_schema import Invoice
 
    prompt = EXTRACTION_PROMPT.format(schema=Invoice.model_json_schema(), text=markdown)
    response = ollama.chat(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        format="json",
        options={"temperature": 0},
    )
    return json.loads(response["message"]["content"])
 
 
def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Lees een PDF-factuur uit met Unlimited-OCR.")
    parser.add_argument("pdf", type=Path, help="Pad naar de PDF-factuur.")
    parser.add_argument("--output-dir", type=Path, default=Path("output"))
    parser.add_argument("--model", default="baidu/Unlimited-OCR")
    parser.add_argument("--llm", default="llama3.1")
    parser.add_argument("--dpi", type=int, default=300)
    return parser.parse_args()
 
 
def main() -> int:
    from invoice_schema import Invoice, validate_invoice
 
    args = parse_args()
    if not args.pdf.is_file():
        print(f"Bestand niet gevonden: {args.pdf}", file=sys.stderr)
        return 1
 
    args.output_dir.mkdir(parents=True, exist_ok=True)
    stem = args.pdf.stem
    images, tmp_dir = pdf_to_images(args.pdf, dpi=args.dpi)
    try:
        print(f"[1/3] {len(images)} pagina('s) uitlezen ...")
        markdown = OCRModel(args.model).read(images)
        (args.output_dir / f"{stem}.md").write_text(markdown, encoding="utf-8")
 
        print(f"[2/3] Structureren met {args.llm} ...")
        invoice = Invoice.model_validate(extract_json(markdown, model=args.llm))
 
        print("[3/3] Valideren ...")
        problems = validate_invoice(invoice)
        result = invoice.model_dump(mode="json")
        result["_needs_review"] = bool(problems)
        result["_problems"] = problems
        (args.output_dir / f"{stem}.json").write_text(
            json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
        )
 
        if problems:
            print("\n⚠  Handmatige controle nodig:")
            for p in problems:
                print(f"   - {p}")
        else:
            print("\n✓  Validatie geslaagd.")
    finally:
        shutil.rmtree(tmp_dir, ignore_errors=True)
    return 0
 
 
if __name__ == "__main__":
    raise SystemExit(main())

python invoice_ocr.py input/factuur.pdf

# Voorbeeld B.V.
 
KvK: 12345678 · Btw: NL001234567B01
 
Factuur INV-2026-001
Factuurdatum: 29-08-2026
Vervaldatum: 28-09-2026
 
| Omschrijving | Aantal | Prijs  | Btw | Totaal |
| ------------ | ------ | ------ | --- | ------ |
| Hosting      | 1      | 100,00 | 21% | 100,00 |
 
Subtotaal: € 100,00
Btw 21%: € 21,00
Totaal: € 121,00
 
IBAN: NL91 ABNA 0417 1643 00

{
  "supplier": "Voorbeeld B.V.",
  "invoice_number": "INV-2026-001",
  "invoice_date": "2026-08-29",
  "due_date": "2026-09-28",
  "kvk": "12345678",
  "vat_number": "NL001234567B01",
  "iban": "NL91ABNA0417164300",
  "currency": "EUR",
  "subtotal": 100.0,
  "vat": 21.0,
  "total": 121.0,
  "lines": [
    {
      "description": "Hosting",
      "quantity": 1,
      "unit_price": 100.0,
      "vat_rate": 21,
      "total": 100.0
    }
  ],
  "_needs_review": false,
  "_problems": []
}

factuur uit e-mail
      ↓
n8n / Zapier / Make            (trigger + flow)
      ↓  HTTP
OCR-service (vLLM / SGLang)    (Unlimited-OCR, altijd geladen)
      ↓
LLM-extractie → validatie
      ↓
gegevens kloppen  →  Exact / AFAS / SnelStart
twijfel           →  taak voor een medewerker