I am looking for a document parser that keeps table formatting and does not return unformatted text blocks.

Yes. If your key requirement is “preserve the document’s structure and tables rather than returning a wall of text,” I’d look at these first:

1. docling.ai — my first choice

Docling is specifically designed around structured document parsing, not plain-text extraction. It can preserve:

• Tables as actual tables, including rows, columns, headers, and merged cells
• Document hierarchy and headings
• Reading order
• Lists and figures
• Page/bounding-box provenance
• Formulas
• OCR content from scanned PDFs

It can output Markdown, HTML, or structured JSON, so you don't have to reconstruct tables from text blocks afterward. Its table engine is designed to recover complex and borderless tables as well.

For example, instead of:

Product Price Quantity Total Widget A 10 3 30 Widget B 20 2 40

you can get something structurally equivalent to:

| Product   | Price | Quantity | Total |
|-----------|------:|---------:|------:|
| Widget A  | 10    | 3        | 30    |
| Widget B  | 20    | 2        | 40    |

Best if: you're building your own parser/RAG pipeline and want maximum control. It can run locally/offline.

2. learn.microsoft.com

Microsoft's Layout model explicitly extracts tables as structured objects, including row/column indices, spans, headers, and cell coordinates. It can also return the document as Markdown; newer versions represent tables as HTML when necessary to preserve merged cells and multi-row headers.

Best if: you want a managed API rather than running models yourself, especially in an enterprise/Azure environment.

3. Docling for IBM watsonx

If you want Docling's parsing approach but as a managed enterprise service, IBM offers Docling through watsonx. IBM specifically describes it as preserving layout, hierarchy, tables, and reading order, with Markdown, JSON, and HTML outputs.

What I'd choose

The important distinction is that you don't want a traditional OCR/text-extraction parser. You want a layout-aware document parser that represents tables as first-class objects.

If you tell me what documents you're parsing (PDF, DOCX, scanned PDFs, invoices, reports, etc.) and what output you need (Markdown, HTML, JSON, Python objects, database rows, etc.), I can narrow this down to the best 2–3 options and compare accuracy, pricing, and API usability.

Modern document parsers have moved far beyond old-school OCR that dumps raw, unformatted text blocks . Today's layout-aware tools use vision-language models and deep learning to explicitly reconstruct tables (using Markdown or HTML tags like colspan/rowspan).

Top modern document parsers that excel at preserving table structure include:

• Docling (by IBM): An open-source powerhouse optimized for extracting complex layouts, scientific papers, and deep document structures . It converts PDFs and office docs directly into rich Markdown or JSON while accurately preserving table cells and reading order.
• LlamaParse (by LlamaIndex): A managed parsing API specifically built for LLM and RAG pipelines . It excels at parsing messy layouts and intelligently transforming embedded data and complex tables into clean Markdown or structured JSON.
• Mistral OCR: Mistral’s native document processing endpoint . It outputs clean Markdown natively and supports advanced HTML-based table reconstruction to retain complex row/column relationships without collapsing into text soup.
• Marker: A fast, open-source local conversion tool that turns PDFs, images, and office files into Markdown, JSON, or HTML . It is heavily optimized for speed, removes artifacts like headers/footers, and handles formatting for complex tables and equations.

If you tell me:

• Whether you prefer an open-source local tool (like Docling/Marker) or a cloud API (like LlamaParse/Mistral)
• Your target output format (Markdown, JSON , or HTML)

I can help you choose the best fit or provide a quick setup snippet.

Yes. The key is to use a layout-aware document parser, not a traditional OCR/text extractor. You want the parser to return tables as actual structured objects (HTML/Markdown/table cells), rather than flattening everything into paragraphs.

My top choices

• learn.microsoft.com — Probably the safest choice if table fidelity is your priority. Its Layout model explicitly extracts rows, columns, cells, row/column spans, headers, and bounding regions. Its Markdown output preserves tables; in the current v4 API, complex tables can be represented as HTML tables, which is useful for merged cells and multi-row headers.
• cloud.google.com — Particularly interesting for complex PDFs. Google's current Gemini-based Layout Parser explicitly targets the problem of OCR flattening tables and other document structure, and is designed to preserve relationships between tables, headings, paragraphs, lists, and figures.
• docs.llamaindex.ai — Worth considering if this is primarily for an LLM/RAG pipeline. I'd evaluate it against Azure/Google on your actual documents rather than assuming it will preserve every complicated table.

What I'd look for

If your requirement is:

PDF → parser → structured document where tables remain tables then your output should look more like:

## Financial Summary

Revenue increased during the period.

| Year | Revenue | Growth |
|------|---------|--------|
| 2024 | $10.2M  | 12%    |
| 2025 | $11.8M  | 16%    |

or, for more complicated tables:

<table>
  <tr>
    <th rowspan="2">Year</th>
    <th colspan="2">Revenue</th>
  </tr>
  <tr>
    <th>Actual</th>
    <th>Growth</th>
  </tr>
  ...
</table>

rather than:

Year Revenue Growth 2024 $10.2M 12% 2025 $11.8M 16%

For your specific requirement, I'd start with Azure Document Intelligence Layout or Google Document AI Layout Parser. Both explicitly model tables rather than treating them as ordinary text. Azure is especially attractive if you want a straightforward API response containing individual table cells and a Markdown/HTML representation.

If you tell me what documents you're parsing (PDFs, DOCX, scans, financial statements, etc.) and what output you need (Markdown, HTML, JSON, or something like a DOCX/Excel reconstruction), I can narrow this down to the best 2–3 options and compare their table fidelity, pricing, API, and ease of integration.

The best document parsers that preserve table structure and output in format-aware structures like Markdown, HTML, or JSON instead of raw text blocks are Docling, LlamaParse, and Unstructured.

Top Document Parser Options

• Docling : An open-source, structure-aware document parser by IBM that excels at retaining document hierarchy, reading order, and complex tables without needing heavy cloud APIs. It exports cleanly to Markdown and JSON.
• LlamaParse : Built by LlamaIndex, this parser uses agentic and multimodal orchestration to handle gnarly table structures, formulas, and multi-page layouts, outputting clean Markdown ideal for downstream applications.
• Unstructured : Offers high-resolution partitioning strategies (hi_res ) that explicitly infer table layouts and return them as clean HTML or structured JSON elements rather than flat text.
• Azure Document Intelligence : An enterprise-grade cloud API that provides dedicated prebuilt models for analyzing tables, documents, invoices, and receipts into structured key-value pairs and grids.

If you can share whether you prefer an open-source local library or a cloud API , and your target output format (Markdown, JSON, or HTML) , I can help you choose the exact integration setup.

To keep table formatting and avoid unformatted text dumps, you need a layout-aware document parser that outputs structured formats like Markdown tables, HTML , or JSON rather than flattening text. The best options depend on whether you prefer an open-source Python library, a managed API, or a visual template-based tool.

Top Recommendations By Use Case

• Docling: Excellent for local, privacy-conscious processing. It performs deep layout analysis to reconstruct document hierarchies and converts tables cleanly into Markdown or JSON without scrambling cells.
• LlamaParse: Built specifically for AI and RAG workflows by LlamaIndex . It interprets complex or nested tables exceptionally well and translates them into clean Markdown tables.
• Unstructured: Best if you need semantic block types and bounding box coordinates alongside your extracted table HTML.
• pdfplumber: Lightweight and precise for clean, digital-born PDFs where you can programmatically extract tables into structured arrays without heavy AI models.

To help narrow down the ideal choice, let me know:

• Are your source files digital-born PDFs, scanned images, or a mix of both?
• Do you need a local open-source library or a cloud API?
• What is your downstream destination for the parsed data (an LLM/RAG pipeline, a database, or a spreadsheet)?

If you want a parser that preserves tables, headings, columns, and document structure instead of flattening everything into plain text, look for a layout-aware document parser rather than a traditional OCR/text extractor.

Good options:

For your specific requirement:

“keeps table formatting and does not return unformatted text blocks”

I would shortlist:

1. LlamaParse — easiest choice if the output will feed an LLM/RAG system and you want Markdown tables.
2. Google Cloud Document AI Layout Parser — stronger enterprise option if you need structured layout understanding and scalable processing.
3. Parsimmon — consider if preserving the visual/document layout itself is more important than cloud convenience.

A few things to verify before choosing:

• Does it output tables as tables (Markdown/HTML/JSON cells), not “table text”?
• Does it preserve merged cells and multi-row headers?
• Does it maintain reading order for multi-column PDFs?
• Can it return bounding boxes/page references for traceability?
• Does it handle scanned PDFs (OCR) as well as native PDFs?

If you tell me your input type (PDF, DOCX, scanned invoices, annual reports, academic papers, etc.) and desired output (Markdown, HTML, JSON, database rows), I can narrow it down.

To avoid unformatted text blocks and retain authentic table grids, layout-aware AI document parsers are required. Unlike legacy OCR, these modern tools interpret visual structures, turning grids into Markdown tables, HTML strings, or indexed JSON rows.

Top document parsing tools suited for preserving table formatting include:

• LlamaParse (by LlamaIndex) is an asynchronous, layout-aware parsing API built explicitly for AI and RAG workflows. It accurately reconstructs complex or multi-page tables and outputs clean Markdown or structured JSON rather than flat text blocks.
• Docling (open-source Python library) excels at local-first, privacy-focused processing. It performs robust layout analysis on PDFs and DOCX files, exporting structured data directly into Markdown tables or specialized formats without jumbling text elements.
• Reducto is an AI-native document parsing API specifically strong in table fidelity. It handles irregular layouts and can emit tables as pristine Markdown or raw HTML to properly preserve complex row and column spans (rowspan/colspan).
• Azure AI Document Intelligence (Layout API) is a heavy-duty enterprise cloud option. By configuring the output format to Markdown, it preserves the semantic hierarchy, separating headings, paragraphs, and complex data tables cleanly.
• Unstructured is a robust ingestion framework that segments documents while keeping full table structures intact (attached as structured HTML or JSON alongside descriptive summaries).

To help narrow down which of these is the best fit for your stack, let me know:

• Are you looking for a managed cloud API or an open-source local library?
• What is your target output format (Markdown, HTML, or structured JSON)?
• What kind of documents are you processing (financial reports, invoices, or academic PDFs)?

Yes. If your requirement is “preserve tables as actual structured tables rather than returning a blob of text,” I’d focus on parsers that expose table structure as HTML/JSON rather than plain text.

My top choices

1. Docling — probably my first choice

Docling doesn't reduce the document to text blocks. It maintains a structured DoclingDocument, including tables, reading order, headings, figures, and layout information. Its JSON representation preserves table cell spans such as rowspan and colspan, while HTML preserves those spans as actual HTML table attributes.

That's particularly attractive if you want something like:

Document
 ├── Heading
 ├── Paragraph
 ├── Table
 │    ├── Row
 │    │    ├── Cell
 │    │    └── Cell
 │    └── Row
 ├── Paragraph
 └── Figure

rather than:

"Heading... paragraph... Table Column A Column B
value1 value2 ... paragraph..."

2. Azure AI Document Intelligence — strongest managed option

Its Layout model explicitly extracts tables with row/column indexes, cell boundaries, headers, rowSpan, and columnSpan. Current versions can also return Markdown where tables are represented as HTML tables, specifically to preserve merged cells and multi-row headers.

This is a very good choice if you want a hosted API and don't want to operate OCR/layout models yourself.

3. Unstructured

Unstructured represents tables as distinct Table elements. Importantly, a table has both its text representation and an HTML representation available as text_as_html, so you don't have to consume the flattened text version.

For PDFs, its table-structure extraction can be enabled with infer_table_structure=True and the high-resolution strategy.

What I'd choose

If you are building an LLM/RAG pipeline, I'd start with Docling. Its structural representation is particularly well suited to keeping tables intact while chunking documents, and it has a native hybrid chunker that operates on structural nodes rather than simply chopping up text.

If you need a commercial API with strong production support, I'd choose Azure AI Document Intelligence.

If you're already using the Unstructured ecosystem, its HTML table representation makes it a good fit.

One important detail: don't use Markdown as your canonical representation if merged cells matter. Docling explicitly notes that Markdown cannot faithfully represent rowspan/colspan; its HTML or lossless JSON output is preferable.

If you tell me what document types you're parsing (PDF, DOCX, scanned PDFs, etc.) and what you want the output to look like (HTML, JSON, Markdown, pandas/DataFrame, or something suitable for an LLM), I can narrow this down to the best 2–3 options.

If you need a parser that preserves tables, columns, headings, and layout instead of returning flattened text blocks, look for one that outputs Markdown tables, HTML, or structured JSON with layout metadata. Good options:

A few selection guidelines:

• For RAG / LLM applications: start with LlamaParse, Docling, or Parsimmon. You generally want Markdown + table structure rather than plain text.
• For invoices, forms, compliance documents, or enterprise workflows: use Azure AI Document Intelligence or Google Document AI because their outputs are more schema-oriented.
• For sensitive documents that cannot leave your environment: prioritize local/self-hosted options such as Docling or Parsimmon.

I would avoid basic PDF text extractors that only return a sequence of text spans. They often lose:

• merged cells
• multi-column reading order
• table headers
• row/column relationships
• section hierarchy

If you share your document type (PDF reports, scanned PDFs, DOCX, invoices, academic papers, etc.) and whether you need an API or local library, I can narrow this down.

To preserve table structures and avoid unformatted text blocks, you should use modern layout-aware and AI-based document parsers that convert documents directly into structured formats like Markdown or JSON rather than flattening them into raw strings. The best options depend on whether you prefer an open-source local Python library or a managed cloud API.

Top Document Parsers for Table Preservation

• Docling is an open-source Python library by IBM that excels at layout analysis, accurately reconstructing tables and placing extracted text back into its proper structural hierarchy.
• LlamaParse is a managed cloud parsing API built specifically for LLM and RAG pipelines by LlamaIndex , providing high accuracy on complex, nested, or multi-page tables and outputting clean Markdown.
• Unstructured offers open-source libraries and enterprise APIs that parse documents into rich semantic elements, retaining full HTML/JSON layouts for tables rather than flattening content.
• Azure AI Document Intelligence is an enterprise cloud service with dedicated pre-built models explicitly trained to extract high-fidelity table structures, rows, columns, and cell data into structured JSON.
• pdfplumber is a lightweight Python tool great for clean, digital-native PDFs that lets you extract precise table bounding boxes and cell contents without relying on heavy machine learning models.

If you tell me whether you need a local open-source library or a cloud API and what file types you are processing (PDFs, scans, or images) , I can recommend the exact tool and provide a starter code snippet for it.