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.
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.
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.pngtesseract ocr-invoice-smoke.png stdout -l eng --psm 6INVOICE INV-42
Subtotal 1000.00 USD
Tax 80.00 USD
Total 1080.00 USDLocal validation fixture · Python 3.11+
ocr-evidence-gate.pypython3 ocr-evidence-gate.pyExpected output
checks=11 clean=validated_candidate ambiguous=review cer=0.142857
synthetic_cost=1600.00 cost_per_validated_document=0.20Python · 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.
- S1 · Tesseract documentation — neural OCRhttps://tesseract-ocr.github.io/tessdoc/ · 2026-11-16
- S2 · Graves et al., CTC — ICML 2006https://www.cs.toronto.edu/~graves/icml_2006.pdf · 2026-11-16
- S3 · Differentiable Binarization — AAAI 2020 / arXiv v2https://arxiv.org/abs/1911.08947v2 · 2026-11-16
- S4 · LayoutLMv3 — official implementation, 2022https://github.com/microsoft/unilm/tree/master/layoutlmv3 · 2026-11-16
- S5 · Donut — OCR-free document understanding, ECCV 2022https://github.com/clovaai/donut · 2026-11-16
- S6 · PaddleOCR 3.0 Technical Report — 2025https://arxiv.org/abs/2507.05595 · 2026-11-16
- S7 · PaddleOCR — official repositoryhttps://github.com/PaddlePaddle/PaddleOCR · 2026-11-16
- 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
- S9 · Tesseract.js — README and PDF limitationhttps://github.com/naptha/tesseract.js · 2026-11-16
- S10 · RapidOCR — runtime toolkithttps://github.com/RapidAI/RapidOCR · 2026-11-16
- S11 · Docling — conversion and separate model licenseshttps://github.com/docling-project/docling · 2026-11-16
- S12 · MinerU — official document parserhttps://github.com/opendatalab/MinerU · 2026-11-16
- S13 · Marker — modes, hybrid processing and licensinghttps://github.com/datalab-to/marker · 2026-11-16
- S14 · Surya — OCR and layouthttps://github.com/datalab-to/surya · 2026-11-16
- S15 · olmOCR — PDF linearization toolkithttps://github.com/allenai/olmocr · 2026-11-16
- S16 · DeepSeek-OCR — optical compression research, 2025https://arxiv.org/abs/2510.18234 · 2026-11-16
- S17 · DeepSeek-OCR 2 — Visual Causal Flow, 2026https://arxiv.org/abs/2601.20552 · 2026-11-16
- S18 · Reducto — product architecture overviewhttps://reducto.ai/ · 2026-11-16
- S19 · Extend — parsing and extraction platformhttps://docs.extend.ai/ · 2026-11-16
- S20 · Extend — extraction depends on parse evidencehttps://docs.extend.ai/extraction/overview · 2026-11-16
- S21 · LandingAI — ADE second generationhttps://landing.ai/blog/introducing-agentic-document-extraction-gen2 · 2026-11-16
- S22 · LlamaIndex — LlamaParse platformhttps://developers.llamaindex.ai/llamaparse/ · 2026-11-16
- S23 · Nanonets — document processing APIhttps://docs.nanonets.com/v4/reference/overview · 2026-11-16
- S24 · Mindee — extraction capabilitieshttps://docs.mindee.com/getting-started/key-features · 2026-11-16
- S25 · Instabase — validation rules and reviewhttps://docs.instabase.com/automate/validating-documents · 2026-11-16
- S26 · Unstructured — open-source document ETLhttps://github.com/Unstructured-IO/unstructured · 2026-11-16
- S27 · Mistral — OCR processorhttps://docs.mistral.ai/studio/document-processing/basic_ocr · 2026-11-16
- S28 · Amazon Textract — table structurehttps://docs.aws.amazon.com/textract/latest/dg/how-it-works-tables.html · 2026-11-16
- S29 · Google Document AI — OCRhttps://docs.cloud.google.com/document-ai/docs/enterprise-document-ocr · 2026-11-16
- S30 · OmniDocBench — benchmark and evaluation codehttps://github.com/opendatalab/OmniDocBench · 2026-11-16
- S31 · Rossum — automation criteriahttps://knowledge-base.rossum.ai/docs/guide-to-automation-process-in-rossum · 2026-11-16
- S32 · Datalab — document intelligence APIhttps://www.datalab.to/ · 2026-11-16
- S33 · Mozilla PDF.js — parsing and renderinghttps://mozilla.github.io/pdf.js/ · 2026-11-16
- S34 · Marker — model weight licensehttps://github.com/datalab-to/marker/blob/master/MODEL_LICENSE · 2026-11-16
- S35 · Google Document AI — layout parserhttps://docs.cloud.google.com/document-ai/docs/layout-parse-chunk · 2026-11-16