Token LabSearch

OCR / DOCUMENT AI

OCR and AI document understanding: mechanisms, frameworks and the startup landscape

Follow a document from pixels to verified business records: neural OCR, layout, tables, VLMs, evidence, cost, open-source frameworks and document-AI companies.

Sources & version details
In this article

1. Start with an invoice: what must the system deliver?

A three-page upload contains a digital invoice, a photographed stamped amendment and a continued line-item table. The user wants editable Word, reconcilable Excel and fields ready for an accounting system. Converting pixels to text completes only one part of that job. This guide is for developers and product builders. It follows the document from ingestion to evidence-backed records, explains implementation choices and ends with a runnable validation fixture.

OCR means optical character recognition. Document parsing recovers paragraphs, headings, tables and reading order. Extraction maps evidence into fields such as invoice number and total. Intelligent document processing, or IDP, adds classification, validation, review and downstream delivery. PDF is a container; its extension cannot tell you whether OCR is needed. A single page may mix text objects and scanned regions.

Layer Input → output Typical failure
Recognition Pixels → characters, locations, scores 0/O confusion, omitted lines
Parsing Regions and text → blocks, cells, relationships Interleaved columns, wrong headers
Extraction Evidence and schema → typed fields Due date mistaken for invoice date
Workflow Validated records → controlled actions Duplicate posting, wrong payment

Recommendations are engineering judgments based on primary documentation checked on November 16, 2026, rather than a uniform benchmark of every product. Scope covers ordinary printed documents, common handwriting and structured extraction, not every historical script or authenticity problem.

2. Inspect the file before invoking vision

Born-digital PDFs often contain text objects, font mappings and coordinates. Extract them first when useful, but drawing order is not necessarily reading order, and broken font mappings can yield nonsense. Scans mostly contain images; previous OCR can create an invisible text layer. A text layer is not evidence that the text is trustworthy. Check agreement with visible content, coverage and geometry.

At intake, bound bytes, pages and decoded pixels; handle encryption and malformed inputs; route per page. Digital pages need native extraction and layout reconstruction. Scanned pages need rendering and recognition. PDF.js provides browser PDF rendering and text-object access, rather than an OCR model.[S33] Isolate file decoders because uploads are untrusted.

Choose resolution based on character size and task. An A4 page at 300 DPI is about 2480×3508 pixels: roughly 33.2 MiB of RGBA pixels. Ten resident pages exceed 330 MiB before model tensors and canvas copies. An upload limit is not a safe simultaneous decoding limit. Use a page queue, release buffers and persist recoverable progress. Higher resolution preserves small print at a cost; enlargement cannot reliably restore missing camera detail.

3. How an OCR pipeline reads characters

A representative pipeline corrects orientation or perspective, detects text regions, crops lines, recognizes sequences and postprocesses results. More preprocessing is not always better: thresholding may erase decimal points and denoising may remove thin strokes. Preserve the original and measure the effect of each transform.

Detection asks where text is; recognition asks what it says. Segmentation detectors predict text regions and turn them into polygons. Differentiable Binarization makes threshold learning part of training.[S3] In a representative CTC recognizer, a line image has shape H×W×3; its encoder emits T×d features and the classifier emits T×(|V|+1) character/blank scores. Other OCR architectures need different contracts.

CTC handles unknown alignment between visual steps and characters by summing probabilities of paths that collapse to the target. Collapse adjacent repeated labels first, then remove blank: h,h,blank,i becomes hi; l,blank,l becomes ll. Training needs paired line images and text, without requiring individual character alignment. Greedy per-step decoding need not find the most probable final string.[S2]

Here x is the line image, y the target character sequence, π a path including blank, B the collapse mapping, T the visual step count and p_t the label probability at step t. The loss is negative log probability of the target. Original two-step example: labels A/blank have probabilities (0.6,0.4) then (0.5,0.5). AA, A blank and blank A collapse to A, giving 0.3+0.3+0.2=0.8; two blanks have probability 0.2.

Modern Tesseract includes an LSTM neural recognizer.[S1] Calling all established OCR “non-AI” obscures the real differences: representation, layout modeling, generative decoding and verification.

4. Layout, reading order and tables are another problem

Perfect characters can still produce an unusable document. A two-column paper needs column order; headers must not interrupt sentences; 80.00 must remain attached to its tax row. Coordinates describe position; relationships give it meaning. Layout analysis classifies regions, reading-order prediction connects blocks and table recognition recovers rows, columns, spans and header associations.

Ruled tables can use line intersections; borderless tables rely more on alignment and visual structure. Cross-page stitching must check column semantics, repeated headers, continuation markers and units. Equal column counts do not establish continuity. Markdown suits simple tables; HTML or explicit cell graphs preserve complex spans. XLSX export should retain numbers, dates and currencies as types.

Keep an intermediate representation with page/block IDs, region classes, source text, coordinates, order, cells and source versions. Derive Markdown, search records, Word and Excel from it. Editable reconstruction and pixel-identical reproduction are different goals. Flowing Word text is easy to edit; fixed-position boxes may resemble the page while being difficult to reflow.

5. Four meanings of AI-assisted OCR

First, post-OCR correction uses recognized text, alternatives and crops to propose repairs. Language priors help prose, but rare names, serial numbers and unusual amounts may be correct. Fluency is not fidelity. Store raw text, normalized value and proposed correction separately, with evidence.

Second, layout-aware understanding combines text, position and images. LayoutLMv3 is a representative model for tasks such as classification and field labeling; it does not eliminate OCR inputs.[S4] Third, image-to-sequence approaches such as Donut generate structured output without a separate OCR component, while retaining hallucination, omission and distribution-shift risks.[S5]

Fourth, hybrid systems run a cheap path first, selectively reread difficult regions with specialized models or VLMs, then extract and validate. Extra passes add latency and cost. Agreement between models with shared biases is not independent proof. Agentic processing should mean bounded rereading, tool selection and validation, with a stopping rule.

6. Why VLMs read documents—and invent content

A vision-language model encodes full pages or crops into visual tokens and decodes text, Markdown or JSON conditioned on instructions. Tiling and dynamic resolution trade small-print detail against token consumption. General models balance many visual tasks; document-specialized models concentrate on text, formulas, layout and tables. PaddleOCR exposes distinct recognition, structured parsing and document-VLM families.[S6][S7]

DeepSeek-OCR and OCR 2 explore visual representations and text reconstruction/compression.[S16][S17] Fewer visual tokens do not prove lower total cost: include rendering, encoding, output decoding, retries and review. Aggressive compression can damage small characters, long identifiers and rare symbols.

For transcription, require uncertainty or null rather than completion of unreadable content, and retain source locations. Store interpretation separately from transcription. A valid JSON schema constrains shape, not truth. A perfectly formed total can still be unsupported by the page.

7. Fields need evidence, types and validation

A total is more than a string. Retain raw text, typed value, currency, page, region, source block, processing versions and review status. Declare pixels versus normalized coordinates, origin and rotation; preserve transforms back to the original page.

Field Example Purpose
raw / value 1O80.00 / null Preserve ambiguous O versus zero
evidence_id / page g / 1 Locate source
bbox / coordinate_system [0.6,0.8,0.9,0.84] / normalized_xyxy Review overlay
model_version / schema_version Pinned identifiers Reproducibility and rollback
status / reasons review / ambiguous_digit Explicit blocking reason

Parse numbers under declared locale conventions. Removing punctuation from 1,234 or 1.234 destroys meaning. Use decimal arithmetic and business-specific tax, discount and rounding rules. Arithmetic consistency is a check, not authenticity proof. A forged invoice can balance. Bank-account changes need independent verification and authorization.

If parsing omitted a value, changing the extraction schema cannot recover it. Inspect the page and parse first, then choose rerecognition or a schema change.[S20]

8. A reference architecture for a real product

The browser owns selection, preview, quality feedback, lightweight local recognition and explicit cloud escalation. The backend owns authentication, tenant boundaries, paid eligibility, page jobs, queues, routing, evidence, validation and export. A zero-paid-inference free tier requires server enforcement of its model access. Hiding a button does not enforce it.

Reference design: local and optional cloud paths converge on a shared evidence representation. Validation precedes review or controlled delivery; the diagram does not describe a vendor’s private system.
Reference design: local and optional cloud paths converge on a shared evidence representation. Validation precedes review or controlled delivery; the diagram does not describe a vendor’s private system. Open full-size diagram
Synthetic invoice evidence: an ambiguous letter O remains unresolved. Arithmetic cannot create missing visual evidence or authorize payment.
Synthetic invoice evidence: an ambiguous letter O remains unresolved. Arithmetic cannot create missing visual evidence or authorize payment. Open full-size diagram

Track each page as queued, processing, needs_review, completed or failed, together with expected page count. Retry identities bind tenant, content, page and configuration. Rerecognizing a page creates a version rather than appending a duplicate. Query asynchronous provider state after a timeout before resubmitting. Cancellation stops pending work and reports cloud calls already incurred.

Explain which pages or crops leave the device. Crops can still be sensitive. Define temporary storage, logs, provider retention and deletion; permanent evidence claims cannot coexist with deletion of all supporting artifacts. Document instructions remain data and must not grant an extraction agent network, email or payment permissions.

9. Frameworks worth evaluating first

There is no universal winner across languages, hardware and document types. This shortlist pairs candidates with their likely use and required checks. Frameworks, weights, inference runtimes and managed APIs are different products.

Candidate Evaluation target Main tradeoff
PaddleOCR: PP-OCR / PP-StructureV3 / VL Multilingual text, structured pages, difficult regions Measure each path separately [S6][S7]
PaddleOCR.js Browser text detection and recognition Not the complete server parsing stack [S8]
Tesseract / Tesseract.js Clear print, offline baseline, browser WASM JS package needs PDF rendering first [S1][S9]
RapidOCR OCR deployment with CPU/ONNX and other runtimes Inference tooling, not a business workflow [S10]
Docling Multi-format unified document representation MIT code; separate model licenses [S11]
MinerU Scientific PDFs, formulas and complex parsing Verify version, backend and weight terms [S12]
Marker + Surya Markdown/JSON and hybrid processing Apache-2.0 code; conditional weight terms [S13][S14]
olmOCR PDF linearization and corpus processing Different target from accounting field accuracy [S15]
Unstructured Partitioning and RAG ingestion Add field/business validation [S26]
Donut / LayoutLMv3 / DeepSeek-OCR Research and task-specific fine-tuning Do not replace the whole production stack [S4][S5][S16]

PaddleOCR.js has official browser deployment documentation; still test assets, runtime, workers and actual devices.[S8] Python compatibility does not establish iPhone browser performance. Marker currently separates Apache-2.0 code from model-weight commercial conditions; older forks can describe obsolete terms.[S34] Record commit, model card, weight version and dependencies for each deployment.

10. What document-AI companies sell

The market spans startups, growth companies and research-oriented platforms. This is not a ranking of ownership status, revenue or market share. Product summaries come from official documentation; the final column contains our procurement questions, not established vendor defects.

Company / product Public product emphasis What to verify
Reducto Multi-pass OCR and VLM processing [S18] Do difficult-page gains justify added cost and delay?
Extend Parse, extract, classify, split and workflows [S19] Can operators diagnose and rerun upstream omissions?
Datalab Document API and Marker/Surya ecosystem [S32][S13] API versus self-hosting quality, operations and terms?
LandingAI ADE Parsing and fine-grained grounding [S21] Do citations precisely cover amounts and cells?
LlamaIndex / LlamaParse Parse, Extract, Classify, Split, Index [S22] Fit with existing RAG and versioning?
Nanonets Extraction and approval/review workflow APIs [S23] Reduction in manual handling and delivery time?
Mindee Configurable fields, coordinates and confidence [S24] Fit with required types and review controls?
Instabase Enterprise document apps and validation [S25] Organizational workflow and deployment fit?
Unstructured Document ETL and generative-AI ingestion [S26] Complete update, deletion and reindexing lifecycle?
Rossum Transactional-document rules and automation [S31] Appropriate review and release thresholds?

Compare Mistral Document AI as a specialized service, alongside incumbent cloud options. Textract models table relationships; Google Document AI offers OCR and layout paths.[S27][S28][S29][S35] They are not all “OCR startups.” Public case studies and vendor leaderboards are discovery signals, not your acceptance set.

11. Applications and defensible commercial value

As basic recognition becomes accessible, value moves toward hard-document coverage, evidence, efficient review and integration. Our analysis: APIs compete on adoption and reliability, platforms on exception handling and organizational delivery, vertical applications on schemas, distribution and verified outcomes. Product pages do not prove retention or economic moats.

Invoices require vendors, amounts, taxes and duplicates. Statements require debit/credit direction, continued transactions and balance reconciliation. Insurance packets require splitting and missing-document detection. Knowledge bases require hierarchy, order, updates and deletion. Accessibility requires usable reading order and language. Markdown sufficient for retrieval can be inadequate for financial posting.

Checkboxes, struck-out clauses, revisions and footnotes can alter meaning. Signature detection is not authentication. Specialized high-impact workflows require their own professional controls. Promise an observable result—reconcilable transactions or reviewable fields—rather than universal understanding.

12. Measure quality and cost with the right denominator

Character error rate is substitutions plus deletions plus insertions divided by reference length; it can exceed 100%. Declare Unicode, whitespace, punctuation and case normalization. CER is often a more useful starting point for Chinese than space-delimited WER. Changing 1080.00 to 1O80.00 is one character error but an unusable amount. Low CER does not imply reliable business fields.

S, D and I count substitutions, deletions and insertions; N_ref is reference length. For cost, N is input documents, r escalation fraction, h review fraction, c_b/c_a/c_h their base/escalation/review unit costs, F fixed cost and N_valid accepted documents.

Synthetic monthly cost: base $100, escalation $120, review $1,000, operations $380. These are teaching assumptions, not provider prices.
Synthetic monthly cost: base $100, escalation $120, review $1,000, operations $380. These are teaching assumptions, not provider prices. Open full-size diagram

Measure table structure and cell content, reading order, field accuracy, missingness, citation correctness and typed values. Report auto-release coverage together with errors among released documents. Recognition scores are not automatically calibrated field probabilities. Check held-out results by language, capture quality and type; support abstention. OmniDocBench supplies parsing evaluation tools, not a substitute for a domain acceptance set.[S30]

Synthetic monthly example: 10,000 single-page documents; $0.01 base processing each; 15% cloud escalation at $0.08; 5% review at $2; $380 fixed operations. Cost is $100+$120+$1,000+$380=$1,600. With 8,000 validated documents, cost is $0.20 each. Escalation and review may overlap and incur both costs. Failed attempts remain in the numerator. Inference price can be a small part of delivery cost. These are invented inputs, not vendor quotes.

13. A practical route for products like PageOCR

Define Basic as local recognition and searchable output: native extraction where useful, then compare PaddleOCR.js with Tesseract.js on actual target devices for scans. Use page queues, cancellation and isolated retries. Never silently route free users into paid cloud inference. Local processing still incurs model-download, hosting and device-compute costs.

For Pro, compare PP-StructureV3, Docling, MinerU and Marker on owned layout/table fixtures, then maintain a small complementary shortlist. Plus can add controlled VLM rereading, extraction and verification with explicit cloud or self-hosted costs. Edge hosting for the web UI does not establish that the model fits the same runtime.

Statement conversion is a promising vertical experiment: retain transaction evidence, separate debit/credit/balance, reconcile opening balance plus net movement to closing balance and export typed amounts/dates. Its value is less correction, easier verification and usable exports. Prove value on one format family before expanding languages and banks; training a foundation OCR model is unnecessary for this first test.

14. Minimal implementation and selection acceptance

The Python 3.11+ standard-library fixture uses synthetic OCR output, not image inference, a network service or a model benchmark. It implements NFC CER, evidence binding, coordinate checks, Decimal consistency and account-change blocking. A clean record becomes validated_candidate, never an authorized payment.

We also actually ran Tesseract 5.5.0 with English data on the original clean-print fixture below. It returned the four lines with the correct identifier and amounts; its blank line is preserved. This real-engine smoke test on one synthetic image does not establish scan, handwriting, multilingual or real-invoice accuracy.

ocr-invoice-smoke.png
tesseract ocr-invoice-smoke.png stdout -l eng --psm 6
INVOICE INV-42
Subtotal 1000.00 USD
Tax 80.00 USD

Total 1080.00 USD

Local validation fixture · Python 3.11+

ocr-evidence-gate.py
python3 ocr-evidence-gate.py

Expected output

checks=11 clean=validated_candidate ambiguous=review cer=0.142857
synthetic_cost=1600.00 cost_per_validated_document=0.20
Python · ocr-evidence-gate.py
"""Python 3.11+, standard library. Synthetic OCR output, no image inference/API.
The gate checks provenance and arithmetic, not document authenticity.
"""
from decimal import Decimal, InvalidOperation
from copy import deepcopy
import unicodedata

def distance(a, b):
    row = list(range(len(b) + 1))
    for i, x in enumerate(a, 1):
        nxt = [i]
        for j, y in enumerate(b, 1):
            nxt.append(min(nxt[-1] + 1, row[j] + 1, row[j-1] + (x != y)))
        row = nxt
    return row[-1]

def cer(reference, prediction):
    # NFC Unicode code points; whitespace and case remain significant.
    a, b = (unicodedata.normalize('NFC', x) for x in (reference, prediction))
    if not a:
        raise ValueError('CER requires a nonempty reference')
    return distance(a, b) / len(a)

def validate(record, evidence):
    reasons = []
    values = {}
    for name in ('subtotal', 'tax', 'total'):
        field = record.get(name, {})
        source = evidence.get(field.get('evidence_id'))
        if not source or field.get('raw') != source.get('text'):
            reasons.append(name + ':missing_or_changed_evidence')
            continue
        bbox = source.get('bbox', [])
        if (source.get('page', 0) < 1 or len(bbox) != 4
            or not all(isinstance(x, (int, float)) and 0 <= x <= 1 for x in bbox)
            or not (bbox[0] < bbox[2] and bbox[1] < bbox[3])):
            reasons.append(name + ':invalid_source_region')
        # Fixed fixture convention: dot decimal, USD, no grouping separators.
        try:
            value = Decimal(field['raw'])
            if not value.is_finite() or value < 0 or value.as_tuple().exponent < -2:
                raise InvalidOperation
            values[name] = value
        except (InvalidOperation, ValueError, TypeError):
            reasons.append(name + ':unresolved_numeric_text')
    if record.get('currency') != 'USD':
        reasons.append('currency:unsupported')
    if record.get('account_changed'):
        reasons.append('account_change:independent_verification_required')
    if len(values) == 3 and values['subtotal'] + values['tax'] != values['total']:
        reasons.append('amounts:inconsistent')
    return ('review' if reasons else 'validated_candidate'), reasons

E = {k: {'text': v, 'page': 1, 'bbox': [0.6, y, 0.9, y + .04]}
     for k, v, y in [('s', '1000.00', .6), ('t', '80.00', .7), ('g', '1080.00', .8)]}
R = {'currency': 'USD', 'account_changed': False,
     **{n: {'raw': E[k]['text'], 'evidence_id': k}
        for n, k in [('subtotal', 's'), ('tax', 't'), ('total', 'g')]}}

def main():
    assert validate(R, E)[0] == 'validated_candidate'
    wrong = deepcopy(R); wrong['total']['raw'] = '1090.00'
    assert validate(wrong, E)[0] == 'review'  # invented correction has no evidence
    ambiguous = deepcopy(R); ambiguous['total']['raw'] = '1O80.00'
    ambiguous_e = deepcopy(E); ambiguous_e['g']['text'] = '1O80.00'
    assert validate(ambiguous, ambiguous_e)[0] == 'review'  # never guess O -> 0
    bad_sum_e = deepcopy(E); bad_sum_e['g']['text'] = '1090.00'
    bad_sum = deepcopy(R); bad_sum['total']['raw'] = '1090.00'
    assert validate(bad_sum, bad_sum_e)[0] == 'review'  # evidence exists, sum fails
    missing = deepcopy(R); missing['total']['evidence_id'] = 'not-found'
    assert validate(missing, E)[0] == 'review'
    changed = deepcopy(R); changed['account_changed'] = True
    assert validate(changed, E)[0] == 'review'
    bad_box = deepcopy(E); bad_box['g']['bbox'] = [.9, .8, .6, .7]
    assert validate(R, bad_box)[0] == 'review'
    nonfinite = deepcopy(R); nonfinite['total']['raw'] = 'NaN'
    nonfinite_e = deepcopy(E); nonfinite_e['g']['text'] = 'NaN'
    assert validate(nonfinite, nonfinite_e)[0] == 'review'
    assert cer('1080.00', '1O80.00') == 1 / 7
    assert cer('café', 'cafe\u0301') == 0
    print('checks=11 clean=validated_candidate ambiguous=review cer=0.142857')
    print('synthetic_cost=1600.00 cost_per_validated_document=0.20')
    assert Decimal(10000) * Decimal('.01') + Decimal(10000) * Decimal('.15') * Decimal('.08') + Decimal(10000) * Decimal('.05') * Decimal('2') + Decimal('380') == Decimal('1600')
    # A real deployment also needs authentication, anti-tamper checks, taxes/rounding
    # rules, independent payment authority and immutable source versioning.
if __name__ == '__main__':
    main()

For real parsing, Docling's DocumentConverter can convert a local PDF before adaptation into your evidence format. The browser SDK operates on rendered page images. These documentation-based starting snippets were not run against downloaded models or paid APIs in this review; pin dependencies and weights before production.[S8][S11]

Documentation-based integration examples · not executed here

from docling.document_converter import DocumentConverter

# Install docling in an isolated environment; pin the tested version.
converted = DocumentConverter().convert("sample.pdf")
markdown = converted.document.export_to_markdown()
# Adapt structured document items and provenance separately for field review.
import { PaddleOCR } from "@paddleocr/paddleocr-js";

// Pass a rendered page image (Blob), not raw PDF bytes.
const engine = await PaddleOCR.create({
  lang: "ch", ocrVersion: "PP-OCRv5",
  ortOptions: { backend: "wasm" }
});
try {
  const [page] = await engine.predict(pageImageBlob);
  console.log(page.items);
} finally {
  engine.dispose();
}

Split evaluation by supplier/template, language, device and time to reduce leakage. Compare native extraction, OCR, parsing, VLM and hybrids under matched originals, budgets and quality criteria. Record cold starts, downloads, peak memory, p95 latency, false release and cost. Start with hundreds of pages covering critical failures, then scale sample size to risk; no universal page count guarantees reliability.

Include blank pages, faint decimals, rotation, columns, continued tables, mixed languages, handwriting, wrong text layers, duplicates, partial failures, forged evidence, account changes and malicious instructions. Exercises: explain why 99% character accuracy cannot prove amount correctness; design page-local retries; compare all-VLM with selective escalation at equal budget; choose review thresholds on held-out data and report coverage and errors. Choose the framework after demonstrating reliability on your documents.

Predict, test and keep evidence

Before revealing an answer, predict one result. After the exercise, record the discrepancy and a transfer test. Saved locally across language editions.

Open notebook / export / clear →

The mathematical review scope is recorded per lesson. It does not establish empirical paper reproduction; report suspected errors in your notes. Review scope

Primary sources and further reading

Sources checked November 16, 2026. Product capabilities are vendor-documented; framework recommendations are editorial judgments. No uniform vendor benchmark was run. The executable fixture uses synthetic OCR output.

  1. S1 · Tesseract documentation — neural OCRhttps://tesseract-ocr.github.io/tessdoc/ · 2026-11-16
  2. S2 · Graves et al., CTC — ICML 2006https://www.cs.toronto.edu/~graves/icml_2006.pdf · 2026-11-16
  3. S3 · Differentiable Binarization — AAAI 2020 / arXiv v2https://arxiv.org/abs/1911.08947v2 · 2026-11-16
  4. S4 · LayoutLMv3 — official implementation, 2022https://github.com/microsoft/unilm/tree/master/layoutlmv3 · 2026-11-16
  5. S5 · Donut — OCR-free document understanding, ECCV 2022https://github.com/clovaai/donut · 2026-11-16
  6. S6 · PaddleOCR 3.0 Technical Report — 2025https://arxiv.org/abs/2507.05595 · 2026-11-16
  7. S7 · PaddleOCR — official repositoryhttps://github.com/PaddlePaddle/PaddleOCR · 2026-11-16
  8. S8 · PaddleOCR.js — official browser deploymenthttps://github.com/PaddlePaddle/PaddleOCR/blob/main/docs/version3.x/inference_deployment/cross_platform/browser.en.md · 2026-11-16
  9. S9 · Tesseract.js — README and PDF limitationhttps://github.com/naptha/tesseract.js · 2026-11-16
  10. S10 · RapidOCR — runtime toolkithttps://github.com/RapidAI/RapidOCR · 2026-11-16
  11. S11 · Docling — conversion and separate model licenseshttps://github.com/docling-project/docling · 2026-11-16
  12. S12 · MinerU — official document parserhttps://github.com/opendatalab/MinerU · 2026-11-16
  13. S13 · Marker — modes, hybrid processing and licensinghttps://github.com/datalab-to/marker · 2026-11-16
  14. S14 · Surya — OCR and layouthttps://github.com/datalab-to/surya · 2026-11-16
  15. S15 · olmOCR — PDF linearization toolkithttps://github.com/allenai/olmocr · 2026-11-16
  16. S16 · DeepSeek-OCR — optical compression research, 2025https://arxiv.org/abs/2510.18234 · 2026-11-16
  17. S17 · DeepSeek-OCR 2 — Visual Causal Flow, 2026https://arxiv.org/abs/2601.20552 · 2026-11-16
  18. S18 · Reducto — product architecture overviewhttps://reducto.ai/ · 2026-11-16
  19. S19 · Extend — parsing and extraction platformhttps://docs.extend.ai/ · 2026-11-16
  20. S20 · Extend — extraction depends on parse evidencehttps://docs.extend.ai/extraction/overview · 2026-11-16
  21. S21 · LandingAI — ADE second generationhttps://landing.ai/blog/introducing-agentic-document-extraction-gen2 · 2026-11-16
  22. S22 · LlamaIndex — LlamaParse platformhttps://developers.llamaindex.ai/llamaparse/ · 2026-11-16
  23. S23 · Nanonets — document processing APIhttps://docs.nanonets.com/v4/reference/overview · 2026-11-16
  24. S24 · Mindee — extraction capabilitieshttps://docs.mindee.com/getting-started/key-features · 2026-11-16
  25. S25 · Instabase — validation rules and reviewhttps://docs.instabase.com/automate/validating-documents · 2026-11-16
  26. S26 · Unstructured — open-source document ETLhttps://github.com/Unstructured-IO/unstructured · 2026-11-16
  27. S27 · Mistral — OCR processorhttps://docs.mistral.ai/studio/document-processing/basic_ocr · 2026-11-16
  28. S28 · Amazon Textract — table structurehttps://docs.aws.amazon.com/textract/latest/dg/how-it-works-tables.html · 2026-11-16
  29. S29 · Google Document AI — OCRhttps://docs.cloud.google.com/document-ai/docs/enterprise-document-ocr · 2026-11-16
  30. S30 · OmniDocBench — benchmark and evaluation codehttps://github.com/opendatalab/OmniDocBench · 2026-11-16
  31. S31 · Rossum — automation criteriahttps://knowledge-base.rossum.ai/docs/guide-to-automation-process-in-rossum · 2026-11-16
  32. S32 · Datalab — document intelligence APIhttps://www.datalab.to/ · 2026-11-16
  33. S33 · Mozilla PDF.js — parsing and renderinghttps://mozilla.github.io/pdf.js/ · 2026-11-16
  34. S34 · Marker — model weight licensehttps://github.com/datalab-to/marker/blob/master/MODEL_LICENSE · 2026-11-16
  35. S35 · Google Document AI — layout parserhttps://docs.cloud.google.com/document-ai/docs/layout-parse-chunk · 2026-11-16

Related learning

RAG · Agent architecture