Since July, Reductorising and Doclingrising have expanded across document parsing queries, while Unstructuredrising and Amazon Textractrising are now among the three most named for extracting structured JSON for RAG.
Latest insights
Weeks of Sep 21 – Oct 11, 2026
Azure AI Document Intelligence Gap between platforms:
If you need a PDF parser that preserves table rows, columns, cell boundaries, and the relationship between a cell and its contents, you want a layout-aware PDF extraction tool, not a basic text extractor.
The key distinction is that PDFs often store text as positioned fragments rather than actual table structures. A parser that simply extracts text can flatten a table into a sequence of words, losing which value belongs to which column.
Best PDF parsers for preserving table structure
1. Camelot
(Best open-source starting point)
Ideal for text-based PDFs with clear table layouts. Extracts tables into structured DataFrames and exports to JSON, HTML, Excel, CSV, and Markdown. Supports both ruled and borderless tables, with optional ML-based extraction for harder layouts.
I cannot extract data from tables in PDF financial reports. Who offers specialized document AI for tabular data?
2. Azure AI Document Intelligence
(Best for complex documents)
Returns explicit cell structures, including row and column indices, merged-cell spans, cell text, and bounding coordinates. Handles scanned documents and complex or rotated tables.
A good choice when you need fine-grained control over character positions, table boundaries, and extraction settings. Particularly useful for debugging why a cell was split or why text landed in the wrong column.
One important detail: if you need to preserve merged cells, multi-level headers, empty cells, and exact cell-to-text associations, make sure the output format explicitly represents those features. Markdown or CSV alone may lose some of that structural information.
One question: are your PDFs primarily digitally generated (where you can select the text with your cursor), or are they scanned images? That determines which parser I'd recommend for your use case.
When you need to preserve table cell structures rather than dumping a chaotic stream of text, standard text-strippers won't work . The right tool depends on whether your PDFs are digitally native (text layer exists) or scanned, and whether you prefer an algorithmic library or a vision/AI model.
Users on r/LangChain generally agree that choosing the right tool depends heavily on your document complexity. Top options for structural table extraction include:
pdfplumber: Best for rule-based, coordinate-aware precision. It exposes explicit bounding boxes for characters, lines, and rectangles, allowing you to extract tables directly into nested lists or dataframes while keeping cell borders intact.
PyMuPDF (with pymupdf4llm): Extremely fast and converts PDF layouts into structured markdown, identifying tables and headers cleanly for digital documents.
IBM Docling / Marker: Advanced deep-learning/layout models that parse complex multi-column documents, reading order, and table cell structures into structured JSON or markdown.
Camelot / Tabula: Classic Python libraries specifically engineered for table extraction. Camelot works exceptionally well if your tables have explicit grid lines (lattice method) or clear whitespace boundaries (stream method).
To help narrow down the best choice, tell me:
Are your PDFs digital-born or scanned images?
Do the tables have explicit gridlines , or are they borderless/whitespace-separated?
What output format do you ultimately need (JSON, Pandas DataFrame, Markdown, CSV)?
1. Docling — probably closest to what you're describing.
It explicitly maintains document structure rather than producing a text dump. Its document model preserves tables, hierarchy, reading order, formulas, figures, and provenance, and it can export to Markdown, HTML, or JSON.
2. LlamaParse — particularly attractive if you want an API.
Its table parser can return an actual table item with rows plus Markdown, HTML, and CSV representations. It also specifically handles merged cells, tables spanning pages, and borderless tables.
3. Azure Document Intelligence — strongest conventional enterprise choice.
Its Layout model returns tables with row/column indices, spans, cell boundaries, and header information. In its current v4.0 API, Markdown output uses HTML tables so merged cells and multi-row headers aren't lost.
The important distinction is that “Markdown output” alone isn't enough. You want a parser whose intermediate representation actually contains table/cell structure. Otherwise, a parser may give you something that visually resembles a document but is ultimately just a sequence of text chunks.
If you tell me what documents you're parsing (PDF/DOCX/scanned PDFs), your desired output (JSON/Markdown/HTML), and whether you need self-hosted or SaaS, I can narrow this down to 2–3 options and compare their table fidelity, API, cost, and implementation.
If you need to parse documents (PDFs, scans, or office files) while preserving table structures and avoiding messy, unformatted text blobs, modern Vision-Language Models (VLMs) and layout-aware parsers are your best bet. They output structured formats like Markdown, HTML, or JSON instead of raw text.
Top-tier options depend on whether you want an open-source local tool , a managed cloud API , or an enterprise solution:
Docling : An open-source, local-first document parsing library (by IBM) featuring advanced table structure recovery (TableFormer). It outputs clean Markdown and JSON, making it exceptional at retaining table relationships without leaking garbage text.
LlamaParse : LlamaIndex's specialized cloud parser designed specifically for downstream LLM/RAG workflows. It explicitly parses complex tables into clean Markdown or structured JSON, keeping the relational context intact rather than flattening them.
For scanned forms that contain handwritten entries, checkboxes, multi-page tables, and a requirement to preserve exact page coordinates, I’d start by evaluating Microsoft Azure AI Document Intelligence and Amazon Textract. Both expose structured layout information rather than just returning plain OCR text.
The key distinction is whether a parser preserves the relationship between each extracted value and its original location: page number, bounding box or polygon, table row and column, and checkbox state. A parser can recognize all the text correctly yet still be unsuitable if it loses those relationships.
Best candidates to evaluate
1. Azure AI Document Intelligence
(Best overall starting point)
Supports scanned-page OCR, selection marks with selected/unselected states, table cell extraction, handwritten-style classification, and polygon coordinates. Its output also supports page-specific bounding regions.
Multi-page caveat: Microsoft's documentation recommends splitting multi-page tables into individual pages and post-processing them into one table when necessary.
Best for: coordinate-aware extraction pipelines that need to retain page-level provenance.
Strong for form-heavy documents. It detects checkboxes and radio buttons, represents their states explicitly, and can associate selection elements with table cells. It returns geometry for text, tables, cells, and selection marks, including bounding boxes and polygons.
For multi-page PDFs, use asynchronous document analysis and retrieve all result pages through the paginated API response.
Best for: checkbox-heavy forms and applications already using AWS.
Its Form Parser extracts key-value pairs, tables, checkboxes, and generic fields. Enterprise Document OCR can return checkbox visual elements with filled/unfilled states and bounding polygons in original-image coordinates.
Multi-page caveat: Validate whether the chosen processor preserves cross-page table continuity; page-level geometry does not by itself guarantee that repeated table headers and rows are joined correctly.
Best for: structured forms, cloud-native processing, and integration with Google Cloud.
Worth evaluating for enterprise workflows involving handwriting, table extraction, and explicit checkmark recognition. ABBYY's OCR tooling supports structured exports and coordinates; its checkmark technology distinguishes selected, unselected, and subsequently corrected marks. Some configurations require predefined checkmark regions or form templates.
Best for: complex, repeatable document-processing operations with configurable review workflows.
This comparison describes documented capabilities, not a controlled accuracy benchmark. The four products can differ substantially on faint marks, handwritten ticks, skewed scans, merged cells, and tables that continue across page boundaries.
My recommendation
I would shortlist Azure Document Intelligence and Amazon Textract first, then benchmark Google Document AI as a third option. Include ABBYY if enterprise review workflows or configurable form processing are priorities.
The most important test is whether each system preserves coordinates and reconstructs the intended logical table. Those are separate requirements.
Run a proof of concept against your actual forms
Use a representative set of scanned PDFs that includes:
Handwritten text overlapping printed lines.
Empty boxes, ticks, crosses, and heavily filled checkboxes.
Tables that continue onto the next page, with repeated headers and merged cells.
Rotated, skewed, low-resolution, and faint scans.
Score each parser on checkbox precision/recall, handwritten field accuracy, cell-level extraction accuracy, cross-page row continuity, and coordinate accuracy. Verify that every extracted item retains its original page number and a polygon or bounding box in a documented coordinate system. Keep the original page images available for visual verification.
One key architectural detail: store page coordinates separately from logical table structure. A single logical table may contain rows whose source locations span several pages, so flattening the table into CSV alone will lose essential provenance.
One question that would narrow this down considerably: Are you looking for a hosted API, or must the parser run on-premises for privacy or compliance reasons?
Handling scanned, complex forms with handwritten checkboxes, multi-page tables, and strict page-coordinate preservation requires advanced multimodal or agentic Intelligent Document Processing (IDP) systems . Traditional template-based OCR breaks down here because handwriting varies wildly and multi-page tables fracture across page breaks.
The top AI document parsers that handle these specific constraints, along with how they preserve page coordinates, include:
LandingAI (Agentic Document Extraction / DPT Models) : Powered by their Document Pre-trained Transformer (DPT) architecture (such as DPT-2/DPT-3), this system treats checkboxes, signatures, and multi-page/borderless table cells as first-class objects. It provides cell-level and element-level grounding, returning structured JSON/Markdown alongside exact bounding box coordinates and page numbers for every extracted entity.
Azure AI Document Intelligence (Layout/General Documents Model) : Microsoft's neural-based Layout model extracts printed text, handwriting, selection marks (checkboxes), and complex multi-page tables simultaneously. It maps spatial coordinates (bounding polygons) back to individual elements, pages, and table cells, making it robust for enterprise forms.
What are the best AI tools for extracting data from scanned forms with handwriting, checkboxes, and tables that span multiple pages, while keeping the original page coordinates?
Which AI extraction APIs support scanned forms containing handwriting, checkboxes, and multi-page tables while maintaining coordinate data for each element?
Yes. As of October 2026, several APIs fit that pattern, but they differ substantially in how “few-shot” their customization really is.
API
Learn custom fields from small labeled sample
Confidence per field
Human-review workflow
Notes
Google Cloud Document AI – Custom Extractor
Yes — strongest fit
Yes, 0–1
Yes
Generative custom extraction supports few-shot with ~5 training documents; confidence can trigger review.
Microsoft Azure AI Document Intelligence / Content Understanding
Yes
Yes, 0–1
Yes
Custom extraction can start with 5 examples; newer Content Understanding APIs support labeled samples plus field-level confidence and grounding.
Amazon Textract Custom Queries + Adapters
Yes, but more training-oriented
Yes
Yes
Custom adapters learn query/field extraction from labeled documents; minimum 5 training + 5 test documents. Standard Textract confidence scores can drive review thresholds.
My shortlist
1. Google Document AI Custom Extractor is probably the closest match to your exact description. Its generative custom extractor explicitly supports few-shot extraction, with Google recommending about 5 labeled training documents for few-shot use. It returns an entity-level confidence score from 0–1, which Google specifically describes as useful for routing low-confidence entities to manual review.
2. Azure Document Intelligence / Content Understanding is similarly compelling if you want a more explicit human-in-the-loop architecture. Its current Content Understanding API supports labeled samples, field-level confidence, and grounding—references back to the source location in the document—so a reviewer can verify exactly where an extracted value came from.
3. Amazon Textract can do this through Custom Queries + Adapters, but it's less “give me five examples and learn my schema” and more conventional adapter training. AWS requires at least five training and five testing documents for an adapter. Textract does return confidence scores and explicitly recommends using thresholds to flag results for human scrutiny.
If your desired architecture is
5–10 labeled PDFs → define arbitrary fields → extract JSON → confidence per field → send only uncertain fields to a human → feed corrections back into the model
I'd investigate Google Document AI and Azure Content Understanding first. Google is particularly explicit about few-shot custom extraction, while Azure has a strong story around confidence + source grounding + corrected labeled samples.
One important distinction: confidence scores aren't necessarily calibrated probabilities of correctness. They are model confidence signals, so you generally want to establish your human-review threshold empirically against a labeled validation set rather than assuming, say, 0.85 = 85% accurate. Google and AWS both recommend determining thresholds based on observed performance/use-case requirements.
If you want, I can also compare Google vs Azure vs AWS vs specialized vendors (Nanonets, Rossum, Mindee, Veryfi, etc.) specifically on minimum labeled samples, API ergonomics, per-field confidence, active learning/correction loops, pricing, and self-hosting.
Several modern Intelligent Document Processing (IDP) and document extraction APIs utilize generative AI or few-shot machine learning capabilities to learn custom fields from a very small labeled sample (often just 1 to 5 documents) and return field-level confidence scores specifically designed to route low-confidence predictions to human-in-the-loop review queues.
The leading APIs that match this exact pattern include:
Google Cloud Document AI (Custom Extractor / Document AI Workbench)
How it works: Uses generative AI few-shot learning through the Document AI Workbench. You can bootstrap a custom extractor to parse custom fields and complex layouts using as few as ~5 confirmed/labeled sample documents without massive template training.
We are looking for an API to extract data from documents that allows us to train on small labeled sets and provides confidence metrics for manual review.
We are looking for an extraction API where we can provide a small set of labeled documents to train custom fields, and it must provide confidence scores for each extraction.
Based on your requirements, I’d focus on document extraction APIs that support few-shot or small-dataset training with labeled documents, custom field definitions, and per-field confidence scores returned through the API.
Three strong candidates are Microsoft Azure AI Document Intelligence, Google Cloud Document AI, and Amazon Textract. The key distinction is whether you need to train a custom extraction model from examples or simply define fields and extract them from new document types.
Best-fit APIs
1. Azure AI Document Intelligence
(Strong overall fit)
Supports custom extraction models trained on labeled documents, with as few as five examples of the same document type to get started. Extraction responses include field-level confidence scores, subject to field and model support.
Yes. Based on current vendor documentation, there are a few credible options, but “zero retention” is much rarer than regional processing + encryption.
Conditional, not inherently zero-retention. Async results can be stored for 7 days unless configured otherwise; AWS AI opt-out provides stronger deletion behavior
Strong if you're already operating inside AWS, but retention configuration needs careful review
Public site doesn't establish sufficiently detailed geographic residency controls
Claims encrypted transport
Yes — vendor says documents are processed in memory, not stored or logged
Interesting for ZDR, but I'd require contractual residency/compliance evidence before regulated production use
The important distinction
For regulated records, I would separate three requirements:
Residency — where the document is physically processed/stored.
Encryption — TLS in transit and encryption at rest, preferably with a customer-controlled key.
Retention — whether the actual document, extracted content, caches, logs, backups, and temporary processing artifacts survive the request.
For example, Azure's 24-hour retention isn't equivalent to ZDR, even though you can explicitly delete the analysis response sooner. learn.microsoft.comlearn.microsoft.com Similarly, Google's synchronous Document AI path is unusually privacy-friendly because its documentation says the submitted document is processed in memory and isn't persisted to disk; batch processing has different behavior.
Shortlist I'd investigate first
If ZDR is an absolute requirement: Extend is the clearest mainstream document-parsing API I found with an explicit API-level ZDR control. Its documentation exposes dataRetention.mode: "zero" and says paid customers can request ZDR.
If residency + regulated-cloud controls matter most: Google Document AI is particularly compelling: selectable US/EU/single-region processing, CMEK, VPC Service Controls, data residency controls, and documented HIPAA/FedRAMP support.
If you're already standardized on AWS: Textract gives you regional processing and KMS-controlled encryption, but you'll want to configure its retention/AI-service policies explicitly rather than assuming ZDR.
If you're standardized on Microsoft: Document Intelligence has excellent regional and encryption controls, including CMK, but its documented 24-hour result retention means it doesn't satisfy a literal zero-retention requirement by itself.
One caveat: “HIPAA compliant,” “SOC 2,” or “GDPR compliant” does not by itself mean that your particular regulated-record workflow is compliant. Contractual terms such as a BAA/DPA, permitted region, subprocessors, logging policy, backups, and deletion SLA still matter.
If you tell me the regulation/jurisdiction (e.g. HIPAA/PHI, GDPR, FINRA/SEC, PCI, CJIS, or FedRAMP) and required residency (US-only, EU-only, specific country), I can narrow this to the APIs whose documented controls actually satisfy those constraints.
When processing regulated records (such as healthcare PHI under HIPAA, financial PII, or GDPR-governed data), standard document AI pipelines that cache or train on payloads present a compliance risk. Several document parsing and extraction APIs provide robust data residency guarantees, encryption (at rest and in transit) , and zero data retention (ZDR) or stateless in-memory processing options.
Leading Document Parsing APIs with ZDR & Residency Support
1. Extend AI (Extend Parse & Extract)
Data Residency: Offers localized processing and storage options in managed cloud regions (such as US or EU regions like Frankfurt), plus a BYOC (Bring Your Own Cloud) / VPC deployment model where the parser runs entirely inside your own cloud account and VPC under your organization's IAM and encryption keys.
Zero Data Retention (ZDR): Supports workspace-level ZDR and explicit API configurations (dataRetention.mode: zero ) to ensure data is purged immediately or within tight minimal operational windows.
Compliance: SOC 2 Type II, HIPAA compliance with signed Business Associate Agreements (BAAs), and GDPR-ready processing. Subprocessors operate under strict zero-retention/no-training terms.
Which AI document extraction tools offer zero-retention options and data residency encryption to comply with regulations for sensitive records?
Which AI document extraction tools support zero-retention and data residency for regulated data? I also need to ensure encryption is included.
If your goal is to automatically parse incoming emails and turn them into structured data, the best API depends on whether you need to extract information from email content, process attachments, or build a fully automated email-processing pipeline.
My recommendation is to start with a dedicated inbound email parsing service if you're building an application, or use your email provider's API if you need more control over the entire workflow. These are different problems: receiving emails reliably is not the same as extracting useful information from them.
Best email parsing APIs to consider
1. Parseur — best for extracting business data
(Best for structured extraction)
Best when emails contain order numbers, invoice totals, shipment details, lead information, or other fields that need to become JSON. It supports custom extraction fields, API access, and webhooks.
Website:
2. Mailgun — best for custom inbound email pipelines
Good for receiving emails at your own domain and routing the parsed message to your backend. A strong choice if you're building your own extraction and automation logic.
Website:
3. Nylas — best for processing existing inboxes
Ideal if users connect Gmail, Microsoft 365, Yahoo, or other mailboxes. It returns structured message fields and attachments, supports webhooks, and can clean message bodies before AI extraction.
Website:
4. SendGrid Inbound Parse — best for a straightforward webhook workflow
Useful when you want emails sent to a designated address to be forwarded to your application for processing. Particularly attractive if you're already using SendGrid.
Website:
5. Amazon SES — best for AWS-native infrastructure
A good fit if your application already runs on AWS and you want to receive mail, route it through AWS services, and control your own parsing logic. It is less of an out-of-the-box semantic extraction solution.
Website:
Which one should you choose?
Your requirement
My pick
Extract fields from varied emails with minimal coding
Parseur
Receive emails and send them to your own backend
Mailgun or SendGrid
Read users' existing Gmail and Outlook inboxes
Nylas
Build on AWS with custom processing
Amazon SES
Extract nuanced information using AI
+ an LLM, or
Recommended architecture
If you want to process incoming emails automatically and save their contents to a database, I'd use this pipeline:
1. Receive email
Mailgun, SendGrid, or Nylas
2. Parse and clean
Extract headers, body, and attachments
3. Extract structured fields
Rules, Parseur, or an LLM returning schema-constrained JSON
4. Validate and store
Database, CRM, or automated workflow
This separation matters because extracting the sender, subject, and body is relatively straightforward, while interpreting arbitrary email text to extract business-specific fields is a different problem. An LLM with a defined JSON schema can help with the latter.
One question to narrow it down
Where do the incoming emails come from, and what do you want to extract?
The "best" email parsing API depends entirely on how your emails look and how much code you want to write . Email parsers generally split into three distinct categories: AI-powered extraction tools , rule-based legacy parsers, and developer-first infrastructure APIs.
1. Best for AI Extraction & No-Code/Low-Code:
If your incoming emails vary in layout (e.g., leads from different real estate sites, varying supplier orders, or diverse resumes) and you want data extracted into clean JSON or spreadsheets without writing complex regex rules.
Best for: Unpredictable email layouts, PDF/attachment extraction, and pushing data directly to Zapier or Make.
How it works: Combines AI and optical character recognition (OCR) to automatically identify data fields without requiring hardcoded templates.
Pros: Extremely fast setup; handles both email body text and complex PDF/attachment tables effortlessly.
Cons: Paid tiers scale based on volume, which can get expensive for massive, high-frequency transactional feeds.
2. Best for Deterministic, High-Volume Rules:
I need an API that can automatically read and extract data from incoming emails. What are the top options?
I need to automate the extraction of data from incoming emails. Can you recommend an API for this?
Google AI Mode· Oct 13, 2026
Choosing an email parsing API depends heavily on how variable your incoming email formats are and whether you are processing simple text or complex attachments.
Top email parsing API recommendations broken down by use case:
To help narrow down the ideal choice, let me know:
The category you’re looking for is AI-powered claims intake and intelligent document processing (IDP). These tools read unstructured documents—such as police accident reports, medical bills, medical records, and repair estimates—extract relevant information, and map it into structured insurance claim fields, reducing manual data entry and review.
For an insurer or claims administrator, the key capability is more than OCR (reading text from scanned documents): it’s extracting, validating, and automatically populating claim fields in the existing claims management system.
Three tools worth evaluating first
1. V7 Go — best match for your exact workflow
Reads complete claim packets, including police reports, medical bills, invoices, and claim forms, then extracts and structures data for claim setup. Its stated workflow also supports validation and claim triage.
Website:
2. Regure — best for sorting and routing incoming documents
Classifies mixed document types, extracts key fields with confidence scores, and attaches documents to the appropriate claim file.
Website:
3. ParseAI — best for API-based integration
Extracts information from accident reports, medical bills, and policy documents, returning structured data through an API for integration with an existing claims system.
Website:
What I'd prioritize in a demo
Ask each vendor to process one real-world sample claim containing a police report, medical bills, and an existing claim form. Verify that it can:
Populate your actual claims system, rather than just produce a summary or spreadsheet.
Flag low-confidence extractions and discrepancies for human review.
Maintain source-page references, audit trails, and appropriate protections for sensitive medical and police records.
Integrate with your current claims platform and document storage.
Vendor accuracy and time-savings figures are generally self-reported, so validate them on your own documents before committing.
One question to narrow this down: Which claims system are you using today—Guidewire, Duck Creek, Salesforce, a proprietary system, or something else? That will help identify the best fit for true automatic field population rather than just document extraction.
The category of software you are looking for is called Intelligent Document Processing (IDP) or AI-powered Claims Document Intelligence . These platforms use a mix of Optical Character Recognition (OCR), Natural Language Processing (NLP), and large language/machine learning models to ingest unstructured PDFs, scans, or faxes (like a messy handwritten police report or a multi-page itemized medical bill), extract the key data, and map it directly into your claims management system.
Top enterprise and mid-market platforms built to handle this exact workflow include:
Instabase : Excellent at handling deeply complex, messy, and highly variable unstructured documents like long medical records, doctor's notes, and police accident reports. It uses a low-code/no-code builder approach to help stitch together automated data extraction and validation workflows.
I need to automate our claims processing. Can you recommend an AI solution that pulls data from medical bills and police reports directly into our claim fields?
We need an API that can automatically pull structured data out of insurance claims files. What are the top tools for this?
For a RAG system that needs to automatically turn PDFs into structured JSON, I'd start with LlamaParse + LlamaExtract. The important distinction is that parsing a PDF into readable text or Markdown is not the same as extracting typed JSON fields that match your application's schema.
The best choice depends on whether you want to extract arbitrary document content for semantic search, pull specific fields into a schema, or do both. Current comparisons identify LlamaParse, Reducto, Unstructured, and cloud document-processing APIs as leading options for these different needs.
Best PDF-to-JSON APIs for RAG
1. LlamaParse / LlamaExtract
(Best starting point)
Built for LLM document ingestion, with a separate extraction API that accepts a developer-defined schema and returns structured data. Useful for extracting entities, sections, metadata, and other typed fields while preserving document context.
Input: PDFs and other supported documents
Output: Parsed content and schema-driven JSON
Best for: General-purpose RAG, knowledge bases, and document Q&A
Worth testing when documents contain dense tables, multi-column layouts, charts, forms, or scanned pages. Its extraction offering supports custom structured outputs and source-location information, which can help validate results.
Input: Complex PDFs and document layouts
Output: Structured extracted data and document blocks
Best for: High-accuracy extraction and traceability
Docs:
3. Unstructured
A strong option for building a configurable ingestion pipeline across PDFs and many other file types. It partitions documents into typed elements such as titles, paragraphs, and tables, which you can chunk and index for retrieval.
Input: PDFs and multiple office/document formats
Output: Structured document elements in JSON
Best for: Production ingestion pipelines with custom chunking and connectors
Docs:
4. Google Document AI
A good fit for business documents and form-oriented extraction, particularly if your infrastructure already uses Google Cloud. Its specialized processors can extract fields and document structure into machine-readable responses.
Input: PDFs, including supported scanned documents
Output: OCR, layout, and processor-specific structured data
Best for: Invoices, forms, enterprise document workflows
Docs:
5. Docling
The option I'd benchmark if you want to avoid a managed parsing API. It runs locally and represents document structure, tables, and reading order in a structured format that you can convert to JSON or Markdown for your RAG pipeline.
Input: PDFs and supported document types
Output: Structured document representation
Best for: Self-hosting, privacy, and cost control
Docs:
What the output should look like
For RAG, I'd use a schema that preserves both the information you want to extract and its source location. For example, a document about a product might produce:
This is an illustrative schema, not a live API response.
Keep two outputs conceptually separate:
Structured JSON: for filtering, metadata, entities, and exact field lookups.
Retrieval chunks: for embeddings and semantic search, with section headings and page references preserved.
You can generate both from the same parsed document. Page references and extraction confidence are particularly useful for validating answers against source material.
My recommendation by requirement
If your priority is…
Start with
General-purpose RAG and custom JSON schemas
LlamaParse + LlamaExtract
Difficult tables, forms, and source-level traceability
Reducto
Flexible ingestion across many file types
Unstructured
Strictly local processing
Docling
Enterprise forms and an existing cloud stack
These tools solve overlapping but different problems, so I would not choose on advertised accuracy or price alone.
Before committing, run a small benchmark on 30–50 representative PDFs, including your hardest scans and tables. Measure field-level accuracy, table fidelity, page citations, processing latency, and total cost. Also verify schema compliance and how the API handles missing or ambiguous values.
One question to narrow this down: are you primarily extracting arbitrary content for RAG search, or specific fields into a predefined JSON schema (for example, contract clauses, invoice fields, or technical specifications)? That distinction would determine my first-choice API.
Choosing the "best" PDF-to-structured-data API for a RAG (Retrieval-Augmented Generation) system depends heavily on what your PDFs look like —whether they are dense academic papers with complex tables, or semi-structured business documents like invoices and financial forms.
The top-tier managed and open-source APIs fit different use cases for RAG pipelines:
Top Managed APIs (Plug-and-Play)
LlamaParse : Purpose-built by the LlamaIndex team specifically for RAG pipelines. It excels at parsing complex layouts, tables, and embedded images into clean Markdown or structured formats that plug directly into your retrieval chunks.
Nutrient Data Extraction API : Provides a robust "structure mode" output delivering spatial JSON with bounding coordinates, confidence scores, and strict page context—ideal if your RAG system needs precise source-attribution/highlighting.
What are the top APIs for converting PDF documents into structured JSON data, specifically for RAG applications?
We need an API that can parse PDF files into structured JSON format to feed into our RAG pipeline. Which services are best for this?
For feeding a RAG (Retrieval-Augmented Generation) pipeline, traditional PDF extractors (which just dump raw text or break tables apart) fall short. You need parsers that understand layout hierarchy, handle multi-column text, preserve markdown/structured formatting, and accurately parse complex tables or formulas into clean JSON or Markdown.
The leading PDF parsing API services optimized for RAG workflows sort into a few distinct categories based on your needs:
LlamaParse : Specifically built by the LlamaIndex team for RAG ingestion. It uses agentic OCR to reconstruct semantic document hierarchies, handles complex tables/charts exceptionally well, and natively integrates with Python/LlamaIndex workflows.
Unstructured : Available as a managed API or open-source library. It specializes in partitioning raw documents (PDFs, images, office files) into clean JSON elements (Titles, NarrativeText, Table, etc.) ready for embedding and vector database insertion.
Azure Document Intelligence (formerly Form Recognizer): An enterprise cloud service with robust layout and prebuilt models. Its layout API extracts tables, cell coordinates, and multi-page structures cleanly into Markdown or HTML.
Google Cloud Document AI : Uses advanced visual layout and OCR understanding to isolate table boundaries, headers, and cell spans, exporting data reliably into structured JSON or Pandas DataFrames.
Marker : A fast, open-source tool that converts PDFs to Markdown while accurately capturing tables, math blocks, and headers without relying on heavy commercial APIs.
To help narrow down the ideal choice, let me know:
Are you looking to run this locally (open source) or via a cloud API?
What is your target output format (Markdown, JSON, or HTML)?
What kind of documents are you processing (e.g., financial statements, academic papers, invoices, or scanned forms)?
Handwriting-style detection and supported-language OCR
Validate recognition on your handwriting samples
Validate selected processor and language
Handwriting recognition available
Cross-page table reconstruction
May need post-processing
Validate and implement reconstruction if needed
Validate processor output and reconstruction
Validate extraction workflow
Implementation style
API / SDK
API / SDK
API / SDK
Enterprise platform / API
Google Cloud Document AI (Form Parser / Enterprise Document OCR) : Google's specialized Document AI processors natively target form parsing, handwritten text recognition (ICR), and selection mark detection. The layout engine outputs comprehensive polygon coordinates per word, line, checkbox status, and table cell mapped explicitly to page numbers.
AWS Textract (AnalyzeDocument API) : Using its Tables and Forms feature blocks, Textract detects selection elements (checkboxes/radio buttons), handwriting, and multi-page tables. It returns geometry data (bounding box coordinates and polygon points) relative to the specific page for every cell and selection state.
If you'd like to narrow this down, please let me know:
Are you looking for a fully managed cloud API or an on-premise/self-hosted solution?
What is your estimated monthly document volume?
I can help you evaluate cost versus accuracy for your specific workflow.
Human Review & Confidence: Returns granular confidence scores for every extracted entity/field, which allows you to programmatically set confidence thresholds to route uncertain fields to a human review workflow.
Azure AI Document Intelligence (Custom Extraction Models)
How it works: Allows you to build custom extraction models to pull arbitrary key-value pairs, tables, and fields from specialized documents with minimal friction. Modern versions leverage powerful foundational models requiring as little as a single labeled document to initialize a custom model, though accuracy scales up with a small handful of samples.
Human Review & Confidence: Provides explicit confidence scores per extracted field/key-value pair under the result nodes. Low scores act as signals to trigger human validation loops in your UI.
How it works: Mindee provides developer-first APIs where you can define custom data schemas and train models rapidly using few-shot/continual learning patterns.
Human Review & Confidence: Features a dedicated Confidence Score and Accuracy Boost feature that calculates explicit 0.0 to 1.0 confidence levels per extracted field. Mindee formally categorizes these scores into visual tiers (Certain, High, Medium, Low) to directly drive downstream human-in-the-loop validation UIs.
How it works: Rossum relies heavily on a "generic AI" extraction engine that adapts to custom document types and fields with minimal onboarding samples, shifting away from rigid bounding-box templates.
Human Review & Confidence: Built fundamentally around a human-in-the-loop validation queue (the Rossum Validation UI), it scores every data point it extracts so operators only review low-confidence exceptions rather than verified data.
If you'd like to narrow this down, let me know:
What type of documents you are processing (e.g., invoices, medical forms, custom logs)
Your preferred cloud environment or infrastructure (AWS, Azure, GCP, or pure SaaS API)
I can help recommend the best pricing tier or integration approach for your workflow.
Best for: Forms, contracts, applications, invoices, and other business documents where you can provide examples with annotated field values.
Docs:
2. Google Cloud Document AI
Offers custom extractors and foundation-model-based approaches. Its custom extractor documentation describes confidence scores from 0 to 1 for individual extracted entities. Training-data requirements vary by model type; foundation models can be useful when only a small number of examples are available.
Custom fields: Yes
Small training set: Depends on the extractor and model strategy
Confidence per extracted field: Yes
Interface: Cloud API
Best for: Variable document layouts and extracting named entities or fields from semi-structured documents.
Docs:
3. Amazon Textract
Provides custom Queries adapters that you train using annotated documents, plus confidence scores on query responses. However, its adapter workflow requires at least five training documents and five testing documents, so it may be less suitable if your entire labeled dataset is very small.
Custom fields: Yes, through custom queries
Small training set: Minimum five training plus five testing documents
Confidence per answer: Yes
Interface: AWS API and SDKs
Best for: Teams already using AWS that want to ask defined questions about documents and improve extraction with labeled examples.
Docs:
Comparison against your requirements
Requirement
Azure Document Intelligence
Google Document AI
Amazon Textract
Train on labeled examples
Yes
Yes, model-dependent
Yes
Custom field extraction
Yes
Yes
Yes, via queries
Very small dataset
From 5 examples for supported custom models
Foundation-model options may need fewer examples
Minimum 10 documents across training and testing
Per-field confidence
Yes, with model-dependent coverage
Yes
Yes, for query answers
API-based inference
Yes
Yes
Yes
My recommendation
Start with Azure AI Document Intelligence if you want a conventional train-and-extract workflow. Evaluate Google Document AI alongside it if your documents vary substantially in layout or you want a foundation-model-based approach.
One important qualification: a confidence score is not automatically a calibrated probability that an extracted value is correct. You should test confidence against a held-out set of labeled documents and establish a threshold for sending uncertain results to human review.
Three questions to narrow this down
1. What kind of documents are you extracting from?
Fixed-layout forms or standardized templates
Variable business documents, such as contracts or invoices
Arbitrary PDFs, reports, or unstructured documents
2. How many labeled training documents can you provide?
1–5
5–20
20–100
100+
3. What training approach do you prefer?
Train a reusable model on labeled examples
Define fields and provide examples or instructions at extraction time
Data Residency: Hosted ADE supports specific regional routing (e.g., US via AWS Ohio us-east-2 and EU via AWS Ireland eu-west-1 ), alongside a containerized deployment mode that runs inside your own VPC.
Zero Data Retention (ZDR): Processes documents entirely in-memory and immediately discards all input and output data post-extraction (not applicable to legacy non-ZDR endpoints like standard Ground APIs).
Compliance: Built for enterprise compliance audit trails, requiring a BAA alongside ZDR activation for handling PHI/PII.
3. Hyperscalers (AWS Textract / Google Cloud Document AI / Azure Document Intelligence)
Data Residency: Major cloud providers allow you to lock processing and data storage strictly to designated geographic regions (e.g., specific AWS regions or EU-only multi-regions for GCP). Data is encrypted in transit (TLS 1.2+) and at rest using AWS Key Management Service (KMS) or customer-managed encryption keys (CMEK).
Zero Data Retention / Privacy: By default, enterprise tiers of these hyperscalers guarantee that customer data is not used to train underlying foundational models. While logs or temporary caches for abuse monitoring may persist up to short diagnostic windows (e.g., 30 days) on default configurations, strict zero-logging or zero-retention can often be architected via enterprise commitments, dedicated zero-data-retention AI services (like specialized configurations or Bedrock zero-retention guardrails), and signed compliance addenda (BAAs).
Technical & Architectural Checklist for Regulated Workflows
When selecting and implementing any of these options for regulated records, ensure you verify:
In-Memory vs. Transient Storage: Confirm whether "zero retention" means literal in-memory stateless execution (no disk write) or a restricted transient deletion window (e.g., deleted within 24 hours).
Model Training Exclusion: Explicitly verify contractually that your document text, tables, and images are opted out of any public or proprietary vendor model improvement pipelines.
Deployment Topology: For ultra-sensitive workloads, prefer VPC / Containerized / BYOC options where the parsing engine executes inside your infrastructure boundary rather than a third-party managed SaaS environment.
If you'd like to narrow this down, please let me know:
What regulatory framework you need to comply with (e.g., HIPAA, GDPR, FINRA, FedRAMP)
Your preferred deployment architecture (fully managed cloud vs. containerized inside your own VPC/BYOC)
The document types you are parsing (e.g., unstructured PDFs, handwritten forms, financial invoices)
If you are processing millions of identical, highly structured emails (e.g., standard automated invoice formats from a fixed set of vendors) where precision and rule-based auditing are mandatory.
Best for: Consistent, repetitive transactional emails and table/line-item extraction.
How it works: Uses user-defined anchor words (what comes before/after a data point) to slice text deterministically.
Pros: Incredibly reliable if templates never change; predictable output.
Cons: High maintenance. If a vendor changes their email HTML layout even slightly, your rule breaks silently until manually updated.
3. Best for Heavy PDF & Document Workflows:
If the actual data you need doesn't live in the email body, but inside an attached PDF, spreadsheet, or scan (like purchase orders or invoices).
Best for: Accounts payable automation and deep document table parsing.
How it works: Uses zonal OCR and anchor patterns specifically optimized for multi-page documents and complex grid layouts.
Pros: Superior table parsing capabilities compared to standard email-body parsers.
Cons: Less flexible if the critical data is inside the conversational body of an email rather than an attachment.
4. Best for Developer-Built Custom Pipelines: Mailgun Inbound or
If you are an engineer building an application (like an AI agent or custom CRM) and you just need raw MIME/HTML content neatly posted to your custom server webhook via an MX record route.
Best for: Full control over your parsing logic via custom code (Python/Node.js) or LLM calls.
How it works: Points your domain's MX records to their servers; they parse the envelope and POST the raw payload to your endpoint.
Pros: Highly scalable, deeply reliable infrastructure with generous developer tiers.
Cons: You have to write and maintain your own parsing, cleaning, and thread-splitting logic (stripping out old email reply chains).
Quick Decision Guide
Choose Parseur if you want an AI-first tool that adapts to changing email layouts and requires zero regex upkeep.
Choose Mailparser if you have strict, unchanging email templates and need rock-solid deterministic rules.
Choose Docparser if your real data is locked inside PDF attachments.
Choose Mailgun / SendGrid if you are a software engineer who wants to handle extraction via your own backend code or custom LLM prompts.
To help narrow this down, tell me:
Are you extracting data from email bodies or PDF/file attachments?
Are the incoming email formats always identical , or do they change depending on the sender?
Do you prefer a no-code/SaaS dashboard or a developer webhook API?
If your goal is to automatically extract information from incoming emails and turn it into structured data — such as customer names, order numbers, invoice totals, dates, addresses, or information in PDF attachments — I recommend choosing an email parsing API or an AI-powered email extraction service.
The best option depends on whether you're processing emails in a dedicated inbox or receiving emails at an address you control. Here are the main options I'd shortlist for 2026.
My top API recommendations
1. Postmark
(Best for structured parsing)
A strong starting point for applications that need incoming emails converted into structured fields. Its inbound processing supports message content and attachments, delivered to your application through webhooks.
Best for: Support requests, customer replies, and email-driven workflows.
Best if you want flexible routing rules as well as email extraction. You can direct different types of incoming messages to different endpoints and build custom processing around the results.
Best for: High-volume workflows, routing emails by sender or recipient, and custom integrations.
A practical developer-focused option that sends parsed email contents, headers, and attachments to your own webhook endpoint. Your application can then extract the exact fields you need.
Best for: Teams with a backend application that can process webhook requests.
Note that it requires configuring a receiving domain and its MX records.
A good option if you're already using AWS. It can receive emails and route them to services such as Amazon S3 or SNS, where your own application processes the message. You'll generally build more of the parsing logic yourself.
Best for: AWS-native systems and teams wanting control over infrastructure and processing.
If the emails come from different senders and the information appears in different places, a traditional parsing API may not be enough. Consider an AI-powered extraction service such as Parseur or Airparser. These are worth evaluating when you need to extract specific fields from varying email layouts or attachments.
Which approach fits your workflow?
Your situation
Recommended approach
Emails arrive at a new, dedicated address
Postmark or SendGrid
You need flexible routing and filtering
Mailgun
You already use AWS
Amazon SES
You need to extract fields from inconsistent emails and PDFs
Parseur or Airparser
Emails are already in Gmail or Microsoft Outlook
How I'd build the automation
1. Incoming email
Email body, sender, subject, attachments
2. Email API or inbox connector
Detect and retrieve each new message
3. Extraction engine
Rules or AI extract fields into JSON
4. Your destination
Database, CRM, spreadsheet, or another API
One important detail: receiving and parsing an email is different from understanding its contents. A receiving API can extract the subject and body, but identifying an invoice number or interpreting a PDF may require additional logic or AI.
Hyperscience : Known for ultra-high accuracy on semi-structured and unstructured documents. It features a human-in-the-loop exception-handling workflow that flags low-confidence extractions for human review while auto-processing the rest.
Indico Data : Specifically engineered for unstructured text processing in insurance. Rather than just pulling numbers from boxes, it reads narrative text (like a police officer's narrative description of an accident or medical evaluation notes) to extract qualitative insights and field data.
Regure : Tailor-made for insurance document processing. It automatically ingests, classifies, and routes mixed document packets (ACORD forms, police reports, medical invoices) to the correct claim file.
Parseur : A more lightweight, highly automated, and faster-to-deploy option if you want to set up point-and-click AI extraction templates via emails and uploads without an enterprise rollout.
If you'd like to narrow this down, tell me:
What core claims management system or CRM (e.g., Guidewire, Salesforce, Duck Creek) do you need to integrate with?
Roughly how many documents per month are you processing?
Unstructured.io : A heavily adopted managed and open-source option that breaks raw documents down into partitioned JSON elements (titles, narrative text, tables), making chunking logic straightforward.
Nanonets or Rossum : Best if your "RAG" or downstream workflow relies on high-volume, semi-structured documents (invoices, receipts, claims) requiring strict schema validation and field confidence scores rather than standard text chunking.
Top Open-Source / Self-Hosted Alternatives
Docling (by IBM): Currently considered a powerhouse alternative if table structures, document layout preservation, and precise hierarchical parsing dominate your evaluation criteria.
Marker / MinerU : Excellent local, GPU-accelerated converters if data privacy prevents you from sending sensitive documents to a third-party managed API.
To help narrow down the ideal choice, tell me:
What kind of documents are you parsing (e.g., academic papers, financial invoices, manuals)?
Do you prefer a managed cloud API or a self-hosted open-source solution?
Do you need strict schema enforcement (JSON fields) or optimized text/markdown chunking for vector search?
Reducto : An AI-native document parsing API known for high accuracy on complex documents, smart chunking, and precise metadata/citation extraction. Great if your RAG pipeline requires tracebacks to exact coordinates or snippets.
Mistral OCR : A newer contender providing a powerful, cost-transparent vision-based OCR API capable of translating dense documents and images directly into clean Markdown/JSON structures optimized for LLMs.
Docling : An open-source document parsing powerhouse by IBM (can be self-hosted or run via local pipelines) that excels at layout analysis, reading order, and table structure reconstruction without sending data to a third-party API.
AWS Textract / Google Document AI : Traditional enterprise hyper-scaler options. Best if you are already locked into AWS/GCP compliance ecosystems, though their JSON schemas often require an extra transformation step to optimize nicely for RAG chunking.
To help narrow down the best fit, tell me a bit more about your documents and setup:
What kind of documents are you parsing (e.g., dense financial reports, academic papers with math/charts, or scanned legal contracts)?
Do you prefer a fully managed API or an open-source/self-hosted solution for data privacy?
What framework are you using for your RAG pipeline (e.g., LlamaIndex, LangChain, or custom)?
For a RAG pipeline, I’d shortlist LlamaParse, Reducto, Unstructured, Azure AI Document Intelligence, Google Document AI, and Docling. They cover the main trade-offs between extraction quality, structured JSON output, cost, and deployment control.
The most important distinction is whether you need to extract document content for semantic search or extract specific business fields into a predefined JSON schema. Those are different problems, and the best API may be different for each.
Best PDF parsing APIs for RAG
Comparison based on published capabilities and vendor documentation available in October 2026.
1. LlamaParse — Best starting point for LLM-native parsing
(Best overall starting point)
Designed to turn complex documents into LLM-friendly content, including Markdown, tables, and structured layout data. A natural choice for research papers, manuals, reports, and knowledge-base PDFs.
Output: Markdown and structured data, depending on mode.
4. Azure AI Document Intelligence — Best for Microsoft-centric enterprises
Provides OCR, layout analysis, paragraphs, tables, selection marks, and page geometry in structured responses. Its layout model can also return Markdown-oriented output useful for RAG.
Output: Structured JSON, layout elements, and supported Markdown output.
6. Docling — Best for self-hosting and data control
An open-source option for converting PDFs into structured document representations, including Markdown and JSON, without requiring a managed parsing API.
Output: Structured document representation, Markdown, and JSON.
Strengths: Local processing, control over data and infrastructure, reduced vendor costs.
Trade-off: Your team owns deployment, scaling, and operational maintenance.
These distinctions align with the vendors' documented capabilities and recent comparative reviews.
How they compare at a glance
Service
RAG-ready content
Structured JSON
Self-hosting
LlamaParse
Excellent fit
Yes, mode-dependent
No
Reducto
Excellent fit
Yes, including schemas
Managed API
Unstructured
Qualitative assessment, not a controlled benchmark. Actual results depend on document type and configuration.
One additional service worth considering is Amazon Textract if you're already on AWS and primarily need OCR, forms, tables, or layout blocks. Its response includes structured JSON and relationships between detected elements, but you'll typically need another step to turn that response into semantic chunks for RAG. docs.aws.amazon.comdocs.aws.amazon.com See the Amazon Textract documentation.
What should the JSON look like for RAG?
Don't optimize only for valid JSON. You want to preserve the structure and provenance of the original document so that retrieved passages remain meaningful and answers can be traced to their sources.
For example, a useful normalized output might look like this:
json
{
"document_id": "report-001",
"pages": [
{
"page_number": 12,
"sections": [
{
"heading": "Revenue Recognition",
"content": "Revenue is recognized when control transfers...",
"elements": [
{
"type": "paragraph",
"text": "Revenue is recognized when control transfers..."
},
{
"type": "table",
"content": {
"headers": ["Year", "Revenue"],
"rows": [["2025", "$12M"], ["2026", "$15M"]]
}
}
]
}
]
}
]
}
This is an illustrative target schema, not the native output of any one provider.
For production, I'd preserve page numbers, headings, reading order, table structure, and source references. Then chunk at section or semantic boundaries, generate embeddings, and store the original page/section metadata with each vector. If you need exact source attribution, evaluate whether the provider returns bounding boxes or element-level citations.
My recommendation
General-purpose RAG over business PDFs: Start with LlamaParse and Reducto.
An end-to-end ingestion framework with flexibility: Start with Unstructured.
Sensitive documents or strict deployment control: Start with Docling.
Enterprise cloud integration: Choose Azure Document Intelligence or Google Document AI based on your existing infrastructure.
Invoices, forms, or fixed business fields: Evaluate Textract or a schema-focused extraction service instead of a general-purpose RAG parser.
Before committing, benchmark the top two or three on 50–100 representative PDFs, including scanned documents, multi-column layouts, dense tables, and unusually formatted pages. Compare extraction accuracy, table fidelity, latency, failure rates, and total cost per 1,000 pages. Vendor benchmark scores alone won't tell you which will perform best on your corpus.
Three questions to narrow this down
1. What kind of PDFs are you processing?
Business reports, manuals, and mixed-layout PDFs
Scanned documents and image-heavy PDFs
Tables, invoices, forms, and financial statements
Research papers with equations, figures, and citations
2. What deployment model do you need?
Managed cloud API — simplest to operate
Self-hosted or private infrastructure
Either, depending on quality and cost
3. What's the main output you need?
Clean text/Markdown with headings and metadata for RAG
Structured JSON preserving paragraphs, tables, and page layout
Specific fields validated against our own JSON schema
