OCR-Kosten pro 1.000 Seiten
8 Open-Source-Engines, benchmarked (2026)

Die Kosten pro 1.000 Seiten sind die abgerechnete GPU-Zeit für die Verarbeitung von 1.000 Seiten zum aufgezeichneten Stundensatz — Wall-Clock-Laufzeit × $0,76/Stunde, wobei die Wall-Clock-Zeit die Modellinitialisierung einschließt. Die gesamte Kostenrangliste dieser Seite wird genau so berechnet; die durchgeführte Rechnung ist im Abschnitt So schätzen Sie Ihre eigenen Kosten und in der Quellenzeile jeder Tabelle zu finden.

Da die Abrechnung stundenweise erfolgt, richten sich die Kosten nach der Zeit, nicht nach der Genauigkeit: Eine Engine, die eine Seite in 109 ms liest, kostet ~25× weniger als eine, die sie in 2.668 ms zum gleichen Satz liest. Die Kosten jeder Engine sinken weiter, wenn die Stapelgröße wächst, da die einmaligen Modellinitialisierungskosten auf mehr Seiten umgelegt werden — die Dollar-Beträge unten spiegeln das Ausführungsmuster des Benchmarks (fester Testsplit, warm_then_scored-Messung) wider und werden nicht mit den Kosten Ihrer eigenen Ausführung übereinstimmen.

SROIE 2019: Kostenrangliste pro 1.000 Seiten

Bei 361 englischen Quittungen besetzen die traditionellen zweistufigen OCR-Engines das günstige Ende und die dokumentenparsenden VLMs das teure Ende — aber die Streuung innerhalb jeder Familie ist es, die überrascht: PaddleOCR-VL, ein kompaktes 0,9B-VLM, landet bei $0,2048, innerhalb von 4,3× der günstigsten Engine, während sein VLM-Geschwister Surya2 22,2× der günstigsten kostet — eine 5,2-fache Streuung allein innerhalb des VLM-Clusters.

Quelle: summary_metrics.csv — Spalte cost_per_1000_pages, Zeilen sroie_2019. docTR 0,0479, EasyOCR 0,1098, PaddleOCR-VL 0,2048, PaddleOCR 0,2214, Unlimited-OCR 0,3879, Docling 0,3978, Surya2 1,0609. Tesseract nur CPU: Zelle in der CSV leer (keine abgerechneten GPU-Stunden). Kosten = Wall-Clock-Laufzeit × $0,76/Stunde (RunPod RTX 4090, Preis mit Zeitstempel August 2026), inkl. Modellinit.

Tabelle: summary_metrics.csv — cost_per_1000_pages / pages_per_minute, sroie_2019 rows (je 361 Samples, error_rate 0.0). GPU-Läufe zu $0.76/Stunde (RTX 4090, Preis-Zeitstempel in Manifests); Tesseract lief nur auf CPU (leere Kostenzelle absichtlich — keine abgerechneten GPU-Stunden, nicht Nullkosten). Die Kosten beinhalten die Modellinitialisierung, daher sinken die Kosten pro Seite bei größeren Stapeln.

Kosten folgen dem Durchsatz, nicht der Genauigkeit

Rangsortieren Sie die Engines nach Kosten und nach Zeichengenauigkeit, und die beiden Rankings stimmen kaum überein. Die beste reine Textqualität bei SROIE gehört Surya2 (CER 0.1915) — die teuerste Engine mit $1.0609 —, während die zweitbeste zu docTR gehört (CER 0.1971) — die günstigste mit $0.0479. Kosten sind eine Rechnung für Zeit: Surya2s 12,1 Seiten/min kaufen ~37× weniger Durchsatz als docTRs 449,3 Seiten/min zum gleichen Stundensatz.

Die Architektur-Gewichts-Korrelation ist real, aber locker. Als Klasse liegen die Dokument-Parsing-VLMs (Surya2, Unlimited-OCR, PaddleOCR-VL) über den traditionellen zweistufigen OCR-Engines (docTR, EasyOCR, PaddleOCR), mit dem Pipeline-Parser Docling dazwischen. Aber innerhalb jeder Klasse ist die Streuung groß — der VLM-Cluster umfasst 5,2× ($0,2048 bis $1,0609) und der traditionelle Cluster 4,6× ($0,0479 bis $0,2214) — und PaddleOCR-VL, das kleinste VLM im Test mit 0,9B Parametern, liegt innerhalb von 4,3× der günstigsten Engine, während Surya2 22,2× beträgt. Die praktische Erkenntnis: nehmen Sie an, dass „genauer = teurer" falsch ist, bis Sie es an Ihren eigenen Dokumenten gemessen haben; in diesem Benchmark ist die Beziehung zwischen Kostenrang und Genauigkeitsrang effektiv entkoppelt.

Quelle: summary_metrics.csv — Spalte pages_per_minute, Zeilen sroie_2019. Echte Zeit pro Minute inkl. Modellinitialisierung. Tesseract lief nur auf CPU (78,6 Seiten/min auf CPU-Hardware).

Tabelle: summary_metrics.csv — cer / latency_p50_ms / pages_per_minute / cost_per_1000_pages, sroie_2019 rows. Kostenverhältnisse durch einfache Division durch docTRs 0.0479 berechnet (z. B. 1.0609 / 0.0479 = 22.16). Der CER für Surya2 muss mit dem Vorbehalt zur Groß-/Kleinschreibung in der Methodik gelesen werden (VLM-Ausgaben werden fallnormalisiert; CER überschätzt den VLM-Fehler). Die Latenz von Tesseract bezieht sich auf CPU-Hardware; seine Kostenzelle ist absichtlich leer (keine GPU-Abrechnung).

Die Latenzspalte fügt die Perspektive der interaktiven Arbeitslast hinzu: Kosten pro Volumen und Latenz pro Seite sind zwei Blickwinkel auf denselben Fakt der Echtzeit. docTRs p50 von 108,7 ms macht es sowohl zum günstigsten pro 1.000 Seiten als auch zur einzigen Engine nahe der interaktiven Antwortzeit; Surya2s p50 von 2.668 ms macht es sowohl zum teuersten als auch zu einer reinen Batch-Arbeitslast bei Quittungen. Die Latenzdetails werden im zugehörigen 8-Engine-Vergleich analysiert.

CORD (Indonesische Quittungen): Kosten sind datensatzabhängig

Tauscht man das Dokumentenset aus, verschiebt sich die Kostenrangliste — was beweist, dass die Kosten pro 1.000 Seiten keine Engine-Konstante sind. Bei CORD v2 wird EasyOCR zur günstigsten Engine ($0,0863) und docTR rutscht auf den zweiten Platz ($0,0939), während die Anker an beiden Enden halten: docTR bleibt nahe dem unteren Ende und Surya2 bleibt die teuerste ($1,1616). Die CORD-Spanne verengt sich auf 13,5×.

Der Mechanismus ist der Durchsatz auf dem tatsächlichen Dokumentenset: CORDs indonesische Quittungen sind kürzer und weniger textdicht als SROIEs englische, daher ändert sich die Seiten-pro-Minute-Rate jeder Engine, und die Kosten pro 1.000 Seiten folgen. Die beiden Datensätze werden in diesem Benchmark bewusst getrennt gehalten — CORD weist zudem eine Aufblähung der Annotationsstruktur in seinen Ground-Truth-Daten auf, die seine CER-Werte unzuverlässig macht (siehe Methodik) — behandeln Sie daher die SROIE- und CORD-Spalten als zwei unabhängige Datenpunkte, nicht als eine Rangliste.

Quelle: summary_metrics.csv — Spalte cost_per_1000_pages, Zeilen cord_v2. EasyOCR 0,0863, docTR 0,0939, Unlimited-OCR 0,2063, PaddleOCR-VL 0,2409, PaddleOCR 0,3419, Docling 0,5382, Surya2 1,1616. Tesseract nur CPU (leere Zelle). Gleiche RTX 4090 @ $0,76/Stunde (Preis mit Zeitstempel), Kosten inkl. Modellinitialisierung.

Tabelle: summary_metrics.csv — cost_per_1000_pages, cord_v2 rows (je 100 Stichproben). CORD wird getrennt von der SROIE-Rangliste geführt (andere Sprache, andere Ground-Truth-Struktur); der Vergleichszweck ist, dass sich die Kosten pro 1.000 Seiten mit dem Dokumentset ändern, nicht dass eine Rangliste „gewinnt“.

Monatliche Volumen-Szenarien (abgeleitete Schätzungen)

Die Werte pro 1.000 Seiten multiplizieren sich direkt in die Volumenberechnung, die Budgetverantwortliche benötigen. Bei 100.000 Seiten/Monat auf Basis der SROIE-Kosten beträgt docTRs GPU-Zeit $4,79/Monat und die von Surya2 $106,09/Monat — eine Differenz von etwa $101/Monat, die sich bei 1 Million Seiten auf etwa $1.013/Monat vergrößert. Dies sind arithmetische Ableitungen der gemessenen Werte pro 1.000 Seiten, keine zusätzlichen Messläufe.

Tabelle: Abgeleitete Schätzungen auf Basis der SROIE 2019-Kosten — keine gemessenen Läufe. Jede Zelle ist eine einfache Multiplikation der gemessenen cost_per_1000_pages (docTR 0,0479, Surya2 1,0609; summary_metrics.csv sroie_2019 Zeilen) mit dem Volumen in Tausend, zum selben RTX 4090-Preis von $0,76/Stunde, Preis-Stand August 2026. Nur GPU-Zeit — keine CPU, Speicher, Egress, Orchestrierung oder LLM-Nachbearbeitung. Bei 10 Millionen Seiten/Monat erreicht allein Surya2 auf dieser Grundlage etwa $10.609/Monat (10.000 × $1,0609).

Tesserals reales Kostenprofil: Keine GPU-Rechnung, aber nicht kostenlos

Tesseract ist die einzige reine CPU-Engine im Benchmark, und seine Kostenzelle ist aus Designgründen leer — es wurden keine abgerechneten GPU-Stunden verbraucht, daher gibt es nichts, was zu 0,76 $/Stunde abgerechnet werden könnte. Das ist nicht dasselbe wie nichts zu kosten: Die CPU-Infrastruktur, auf der es läuft (eigene Hardware oder eine gemietete CPU-Instanz), ist ein realer Kostenfaktor, den dieser Benchmark nicht quantifiziert, und seine Grenzen bei der Feldwiederherstellung können die Ausgaben nachgelagert erhöhen.

Auf SROIE erreichte Tesseract auf CPU immer noch 78,6 Seiten/min — mehr als vier der sieben GPU-Engines (PaddleOCR-VL 68,2, Docling 56,7, Unlimited-OCR 34,4, Surya2 12,1). Bei geringem Volumen auf bereits vorhandener CPU-Infrastruktur ist das tatsächlich kosteneffektiv: Keine GPU-Miete. Der Haken zeigt sich, wenn nicht nur Text, sondern auch Felder das Ergebnis sein sollen: Tesserals schwacher Basistext begrenzt, was ein nachgelagerter LLM wiederherstellen kann — sein CORD LLM Feld-F1 ist 0,163 bei einem CORD CER von 0,9523 (field_method_comparison.csv, Zeile tesseract/cord_v2) — daher können die GPU-Einsparungen durch Nachbearbeitungs- und Korrekturausgaben an anderer Stelle aufgezehrt werden. Der CPU-vs-GPU-Tradeoff ist Thema des dedizierten Tesseract vs PaddleOCR-Vergleichs; die Grenzen des Postprozessors werden in Regex vs LLM Feldextraktion behandelt.

Pipeline-Kosten ≠ Engine-Kosten: Die Grenze des LLM-Postprozessors

Jede Zahl auf dieser Seite ist die GPU-Rechnung der OCR-Engine und nichts weiter. Produktions-Extraktionspipelines fügen dem OCR-Text häufig einen LLM-Feldextraktionsdurchlauf hinzu — der Benchmark führte einen (deepseek-v4-flash) über alle 16 Läufe durch — und dieser Durchlauf ist eine separate, pro-Token-API-Kosten, die in keiner Engine-Zahl hier erscheint.

Die Vergleichs-CSV erfasst die Token-Zahlen für den Nachbearbeitungsdurchlauf auf SROIE — zum Beispiel kostete docTRs OCR-Text 151.131 Prompt- + 25.377 Completion-Tokens, um die vier Belegfelder zu extrahieren — und diese Token-Zahlen sind die Grundlage zur Schätzung der zusätzlichen Ausgaben. Diese Seite rechnet Tokens bewusst nicht in Dollar um: LLM-Preise variieren je nach Anbieter, Tarif und Modell, und jede Dollar-Zahl würde sofort veralten. Engine-Kosten und Pipeline-Kosten sind zwei Posten im Budget; die LLM-Zeile ist eine Funktion Ihres Prompt-Designs und Anbieters, nicht der OCR-Engine.

Tabelle: field_method_comparison.csv — llm_prompt_tokens / llm_completion_tokens, sroie_2019 rows; llm_model = deepseek-v4-flash. Die Token-Zahlen decken einen Feldextraktionsdurchlauf (vier Belegfelder) über den 361-seitigen SROIE-Testsplit ab. Sie bilden die Grundlage zur Schätzung der LLM-Nachbearbeitungskosten; eine Dollar-Umrechnung wird nicht angegeben, da die LLM-Preise je nach Anbieter und Tarif variieren.

So schätzen Sie Ihre eigenen Kosten

Sie müssen kein 8-Engine-Benchmark neu ausführen, um eine belastbare Kostenabschätzung für Ihre eigene Arbeitslast zu erhalten. Die Benchmark-Methode — Echtzeit × Ihr Stundensatz — lässt sich in vier Schritten und einem durchgerechneten Beispiel nachvollziehen.

Dies ist eine überschlägige Methode, die auf der eigenen Kostenbasis des Benchmarks basiert (Echtzeit × Satz, inkl. Modellinit); dies ist keine Finanzberatung, und Ihre genauen Zahlen variieren je nach Hardware, Dokumentmischung, Batch-Größen und Auslastung. Der Satz von $0,76/Stunde ist ein mit Zeitstempel versehener On-Demand-Preis von August 2026 — leiten Sie ihn mit aktuellen Sätzen neu ab.

Häufig gestellte Fragen

Was kostet OCR pro 1.000 Seiten?

Zwischen $0,048 (docTR) und $1,061 (Surya2) pro 1.000 Seiten auf SROIE 2019, gemessen auf einer RTX 4090 mit $0,76/Stunde und einem Preis-Stichtag im August 2026 (summary_metrics.csv cost_per_1000_pages, sroie_2019-Zeilen). Die Kosten beinhalten die Modellinitialisierung, sodass die Kosten pro Seite mit steigender Stapelgröße sinken. Auf CORD v2 liegen die Kosten für dieselben Engines zwischen $0,086 (EasyOCR) und $1,162 (Surya2).

Welche Open-Source-OCR-Engine ist die kostengünstigste?

docTR war die kostengünstigste GPU-Engine mit $0,0479 pro 1.000 Seiten auf SROIE (449,3 Seiten/Minute, summary_metrics.csv doctr/sroie_2019-Zeile) — wobei der Hinweis zur Datensatzabhängigkeit wichtig ist: Auf CORD v2 schnitt EasyOCR ($0,0863) besser ab als docTR ($0,0939). Die Antwort auf „kostengünstigste" hängt von Ihrem Dokumentensatz ab; die Eckwerte (docTR niedrig, Surya2 hoch) galten für beide.

Warum ist die schnellste Engine auch die kostengünstigste?

Weil die Abrechnung nach Echtzeitstunden zu $0,76/Stunde erfolgt: Die Engine, die eine Seite in 109 ms (docTR) verarbeitet, zahlt etwa 1/25 der Stunden, die eine 2.668-ms-Engine (Surya2) pro Seite zahlt (summary_metrics.csv latency_p50_ms / cost_per_1000_pages, sroie_2019-Zeilen). Bei abgerechneter GPU-Leistung ist Durchsatz gleich Kosten — weshalb die Kostenrangliste und die Durchsatzrangliste nahezu Spiegelbilder sind.

Ist Tesseract OCR kostenlos?

Nein — Tesseract ist nur CPU-basiert, verbraucht daher keine abgerechneten GPU-Stunden und seine Kostenzelle ist in der Benchmark-CSV ausdrücklich leer, aber das ist kein Nullwert: Die CPU-Infrastruktur, auf der es läuft, verursacht reale Kosten, und seine Grenzen bei der Feldextraktion (CORD LLM Feld-F1 0,163, field_method_comparison.csv tesseract/cord_v2-Zeile) können zusätzliche Kosten für die Nachbearbeitung verursachen. Bei geringem Volumen auf bereits vorhandener CPU-Hardware kann es durchaus kosteneffizient sein — 78,6 Seiten/Minute auf SROIE, schneller als vier der sieben GPU-Engines — aber „keine GPU-Rechnung" und „kostenlos" sind unterschiedliche Aussagen.

Warum ist Surya2 so teuer pro 1.000 Seiten?

Weil es die langsamste Engine im Benchmark ist: 12,1 Seiten/Min auf SROIE bedeutet die meisten Echtzeitstunden pro 1.000 Seiten bei derselben Rate von $0,76/Stunde (summary_metrics.csv pages_per_minute / cost_per_1000_pages, Zeile surya2/sroie_2019). Bemerkenswert ist auch die beste Zeichengenauigkeit (CER 0,1915) — das Benchmark-Beispiel, das am klarsten zeigt, dass die Kosten der Zeit folgen und nicht der Genauigkeit.

Sinken die OCR-Kosten pro Seite mit steigendem Volumen?

Ja, bis zu einem Grenzwert. Die Kosten hier beinhalten die Modellinitialisierung, die einmal pro Prozess/Batch bezahlt wird; der docTR-Lauf im Benchmark zahlte die Initialisierung innerhalb von 81.867 ms für 361 Seiten (manifest performance.run_wall_time_ms), sodass bei 1 Million Seiten diese Initialisierung auf nahezu null verdünnt wird und die Kosten dem reinen Durchsatz im稳态 Zustand annähern. Der Grenzwert ist der Kosten im稳态 Zustand selbst — docTRs $0,0479/1K auf SROIE liegt bereits nahe an seinem Grenzwert; Surya2s $1,0609 spiegelt tatsächlich langsame稳态 Inferenz wider, nicht nur den Overhead der Initialisierung.

Was ist in diesen Angaben pro 1.000 Seiten nicht enthalten?

LLM-Nachbearbeitung (eine separate API-Kosten pro Token; Tokenzahlen in field_method_comparison.csv), CPU/Infrastruktur für Tesseract-artige Stacks, Speicher und Egress, Orchestrierung, GPU-Auslastungslücken und Cloud/API-OCR-Dienste — nichts davon ist in den Engine-GPU-Rechnungen enthalten, die diese Zahlen repräsentieren. Cloud-APIs berechnen auch pro Aufruf mit preisgebundenen Funktionen, ein anderes Kostenmodell als gemietete GPU-Echtzeit; sie werden auf dieser Seite nicht benchmarked.

Woher kommen diese Zahlen?

Jede Zahl ist eine Zeile der veröffentlichten CSVs des First-Party-Benchmarks — results/summary_metrics.csv (Kosten pro 1.000 Seiten, Durchsatz, Latenz, Genauigkeit) und results/field_method_comparison.csv (LLM-Nachbearbeitungs-Tokens und Feld-F1) — gehostet bei ImageToTableai/benchmark-ocr, mit einem geschwärzten manifest.json pro Lauf, das die Rate von $0,76/Stunde, den Preiszeitstempel August 2026, Modellversionen und Umgebungs-Hashes aufzeichnet.

Methodik & Quellen

Protokoll

Diese Seite berichtet die Kosten dimension eines unabhängigen, reproduzierbaren Benchmarks (offizielle Stufe) — keine Umfrage von Drittanbieter-Aussagen. Nur feste Test-Splits: SROIE 2019 test (361 englische Quittungen, flache Felder Firma/Datum/Adresse/Gesamtbetrag) und CORD v2 test (100 indonesische Quittungen, verschachtelte Felder Menü/Teilsumme/Gesamtbetrag); Trainings-Splits wurden nie ausgewertet. Jedes (Engine × Datensatz)-Paar verwendete dieselben Bilder, dieselbe Ground Truth und dasselbe Messprotokoll (warm_then_scored: ein fester Warm-up-Durchlauf geht dem bewerteten Durchlauf voraus). Alle 16 Läufe schlossen mit error_rate 0.0 ab (summary_metrics.csv Spalte error_rate).

Laufzeitumgebung und Kostenbasis

• Hardware: alle GPU-Läufe auf einer NVIDIA RTX 4090 (24 GB); GPU-Kosten berechnet zum RunPod On-Demand-Tarif von $0.76/Stunde, mit dem Preism-Stempel (price_recorded_at_utc 2026-08-13T08:00:00Z) im redigierten Manifest jedes Laufs. Tesseract lief nur CPU und hat keine GPU-Kosten (leere Kostenzelle in der CSV — absichtlich, nicht null).
• Kostenformel: Kosten pro 1.000 Seiten = Wall-Clock-Laufzeit × $0.76/Stunde × (1.000 / verarbeitete Seiten), einschließlich Modellinitialisierung. Überprüft am durchgerechneten docTR-Beispiel im Abschnitt Kosten schätzen (81.867 ms → $0,0479/1K).
• Engines: alle Modelle laufen out-of-the-box, kein Fine-Tuning. Versionen fixiert gemäß den Lauf-Manifesten (Tesseract 5.3.4, PaddleOCR 3.7.0, EasyOCR 1.7.2, docTR v1.0.1, Docling 2.119.0, Surya2 0.22.1, Unlimited-OCR vLLM-served, PaddleOCR-VL 1.6).
• LLM-Nachbearbeitung: deepseek-v4-flash via API bei Temperatur 0 (Spalte llm_model in field_method_comparison.csv); seine Token-Zahlen werden als Grundlage für separate Pipeline-Kosten ausgewiesen — die OCR-Engine-Kosten enthalten sie nicht.
• Feld-Nachbearbeitung: SROIE-Feldmetriken sind postprocessed_sroie_receipt_regex_* / LLM-Varianten — Felder extrahiert aus OCR-Text, nicht nativer strukturierter Ausgabe.
• CORD-Hinweis: CORD-Ground-Truth-Text enthält Annotationstruktur, was den Roh-CER für jede Engine aufbläht; CORD-Zeilen werden daher getrennt von SROIE-Rankings geführt. Kostenzahlen (wall-clock-basiert) sind vom CER-Hinweis nicht betroffen, aber beide Datensätze sind weiterhin nur Quittungen.

Metrikdefinitionen

• Kosten pro 1.000 Seiten: Abgerechnete GPU-Stunden für 1.000 Seiten zum erfassten Tarif von $0.76/Stunde, inkl. Modellinitialisierung (Wall-Clock). Leer für CPU-only Tesseract.
• Seiten pro Minute: Wall-Clock-Durchsatz inkl. Modellinitialisierung.
• Latenz p50/p95: Zeit pro Seite im stabilen Zustand (nach Aufwärmen, vor Scoring, ohne Modellladen).
• CER/WER: Editierdistanz (Einfügungen + Löschungen + Ersetzungen) über Ground-Truth-Zeichen/Wörter. Empfindlich gegenüber Groß-/Kleinschreibung und Formatierungskonventionen — VLM-Ausgaben werden case-normalisiert, daher überschätzt CER den VLM-Fehler (siehe Zusammenfassungsseite).
• Feldwert-F1: Harmonisches Mittel aus Precision und Recall über extrahierte Feldwerte, je nach Nachbearbeiter (Regex oder LLM).

Quellenverzeichnis

1. summary_metrics.csv (GitHub raw). 16 Zeilen = 8 Engines × 2 Beleg-Datensätze (sroie_2019, cord_v2). Spalten: model, compute_type, dataset, cer, wer, field_f1_regex, field_acc_regex, latency_p50_ms, latency_p95_ms, cost_per_1000_pages, pages_per_minute, error_rate. Jede Kosten-, Durchsatz-, Latenz- und CER-Zahl auf dieser Seite lässt sich auf eine Zeile hier zurückführen.
2. field_method_comparison.csv (GitHub raw). 16 Zeilen; Spalten model, dataset, llm_model (= deepseek-v4-flash), regex/LLM Feldwert-Genauigkeit und F1, document-fields-exact, llm_median_latency_ms, llm_prompt_tokens, llm_completion_tokens. Jede Token-Zahl und jedes LLM-Feldwert-F1 lässt sich auf eine Zeile hier zurückführen.
3. ImageToTableai/benchmark-ocr Repository. Öffentliches Repo mit den Ergebnis-CSVs, geschwärzten Lauf-Manifesten, eingefrorenem Protokoll und Datensatz-Beispiellisten (feste Test-Splits) zur Reproduktion.
4. results/manifests/ (GitHub). Ein geschwärztes manifest.json pro veröffentlichtem Lauf (16 Läufe) mit Umgebungsabdruck, Modellversionen, Kostenmetadaten (gpu_hourly_usd, price_recorded_at_utc), Wall-Clock-Zeit und Artefakt-Hashes.
5. Huang et al., "ICDAR2019 Competition on Scanned Receipt OCR and Information Extraction" (2019). SROIE 2019 Datensatzdefinition, Aufgabenstruktur und Lizenz (CC-BY-4.0).
6. Park et al., "CORD: A Consolidated Receipt Dataset for Post-OCR Parsing" (2020). CORD v2 Datensatzdefinition, verschachteltes Feldausschema und Lizenz (CC-BY-4.0).

Einschränkungen

• Einzelne GPU-Stufe und einzelner Preiszeitstempel: Alle GPU-Werte stammen von einer RTX 4090 zu $0.76/Stunde, Preis aufgezeichnet im August 2026. GPU-Spot-/On-Demand-Preise ändern sich — bei aktuellen Raten neu ableiten; andere GPUs, Multi-GPU-Bedienung und Batch-Planung verschieben Durchsatz und Kosten.
• Nur Quittungen: SROIE (Englisch) und CORD (Indonesisch) Quittungen. Kosten, Durchsatz und Genauigkeit bei Rechnungen, Formularen, Verträgen oder langen Dokumenten sind nicht gemessen; die obigen Rankings sind über Quittungen hinaus nicht verallgemeinerbar.
• Kosten beinhalten Modellinitialisierung — batchgrößenabhängig: Die Werte spiegeln das Ausführungsmuster des Benchmarks wider (361/100-seitige feste Aufteilungen, Aufwärm- dann Bewertungsphase). Kleinere Batches zahlen die Initialisierung wiederholt und kosten mehr pro 1.000 Seiten; größere Batches nähern sich dem stabilen Bodenwert.
• CPU/GPU-Asymmetrie: Tesseract (CPU) wird mit GPU-beschleunigten Engines verglichen. Sein Kostenvorteil spiegelt die fehlende GPU-Abrechnung wider, nicht null Kosten — CPU-Infrastruktur, Strom und Personalkosten sind nicht quantifiziert, und seine Grenze der Feldwiederherstellung (CORD LLM Feld F1 0.163) kann Ausgaben in die Nachbearbeitung verlagern.
• Keine Cloud/API-Modelle: AWS Textract, Google Document AI, Azure AI Document Intelligence und gehostete OCR/VLM-APIs sind nicht enthalten; ihre preisgesteuerten, funktionsbasierten Tarife unterscheiden sich grundlegend von der Miet-GPU-Echtzeitabrechnung, und kein Vergleich ist impliziert.
• Auslastung und Leerlaufzeit nicht modelliert: Die Werte gehen davon aus, dass die GPU für die Echtzeit der Ausführung abgerechnet wird und ansonsten ungenutzt ist; reale Bereitstellungen mit Leerlauf, Multi-Tenant oder unterausgelasteten GPUs haben andere effektive Kosten.
• LLM-Nachbearbeitungskosten werden nicht in Dollar umgerechnet: Token-Zahlen (field_method_comparison.csv) sind die Grundlage; LLM-Preise variieren je nach Anbieter und Plan und werden dem Leser bewusst überlassen.
• Abgeleitete Szenarien sind nicht gemessen: Die Monatstabelle ist einfache Arithmetik auf der SROIE-Kostenbasis, gekennzeichnet als abgeleitete Schätzungen — keine zusätzlichen Benchmark-Läufe.
• Stichprobengröße und Versionsfixierung: 361 + 100 Stichproben; die Ergebnisse gelten für die oben aufgeführten Modellversionen vom August 2026. Neuere Engine-Versionen können Kosten/Durchsatz verschieben; einstellige Prozentunterschiede sollten als Rauschen behandelt werden.

Verwandte Referenzen: Traditionelles OCR vs. Dokument-Parsing-VLMs · docTR vs. Surya2: CER-Gleichstand, Kostenunterschied · Tesseract vs. PaddleOCR: CPU-Kostenprofil · Regex vs. LLM-Feldextraktion · Aufschlüsselung der Dokumentverarbeitungskosten

Weiterführende Lektüre: KI-Dokumentextraktionspreise (2026) · KI-OCR vs. traditionelles OCR: Genauigkeit · KI-Bilddatenextraktion vs. traditionelles OCR