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

Yes. If your requirement is “preserve the document’s structure, especially tables, rather than giving me a pile of text chunks,” I’d look at these:

1. docling.ai — strong fit

Docling is specifically designed around document structure rather than plain-text extraction. It detects tables, reading order, headings, figures, formulas, etc., and can output HTML, Markdown, JSON, or its structured DocLang format.

Most importantly for your requirement, its table model preserves rows, columns, merged cells, and cell spans. HTML and JSON retain the table structure; Markdown can flatten merged cells because Markdown itself doesn't support rowspan/colspan.

I'd choose Docling if:

• You want an open-source/self-hosted parser.
• You need PDFs/DOCX/PPTX/etc.
• Tables need to remain actual structured tables.
• You want to feed the result into an LLM/RAG system without destroying layout.

2. learn.microsoft.com

Microsoft's Document Intelligence Layout model explicitly extracts tables as structured objects, including row/column spans, cell coordinates, and header information. Its current v4 output can represent tables as HTML, which is particularly useful for merged cells and multi-row headers.

This is a good option if you want a managed API rather than running the parser yourself.

What I would avoid

If your parser's primary output looks like:

Customer     Amount     Date
Acme Inc     $4,500     01/12/26
Globex       $2,300     01/15/26

and then hands that entire thing to you as a generic text/content block, it's probably the wrong abstraction for your use case.

Instead, you want something closer to:

{
  "type": "table",
  "rows": [
    ["Customer", "Amount", "Date"],
    ["Acme Inc", "$4,500", "01/12/26"],
    ["Globex", "$2,300", "01/15/26"]
  ]
}

or, even better for complex documents, a document tree containing paragraphs, headings, tables, cells, figures, and their relationships/provenance.

If you tell me what you're parsing (PDFs, DOCX, scanned PDFs, invoices, financial reports, etc.) and whether you need Python/local vs. an API, I can narrow this down to 2–3 parsers and compare their actual table output.

If you need to parse documents (like PDFs, scans, or office files) while strictly preserving table structure and avoiding raw, unformatted text dumps, several modern layout-aware parsers excel at this.

Top options range from open-source local libraries to robust managed cloud APIs:

• Docling (Open-Source / Local): Developed by IBM, Docling is widely praised in the community for parsing complex layouts, multi-column text, and extracting tables cleanly into structured Markdown or JSON without losing contextual hierarchy.
• LlamaParse (Cloud API): Built specifically with LLMs and RAG pipelines in mind by LlamaIndex. It explicitly parses tables into Markdown grid structures instead of flattening them into messy text strings.
• Reducto (Cloud API): Highly specialized for layout-aware document processing. Instead of a basic OCR text transcript, it returns a structured JSON hierarchy mapping out explicit types for text, tables, figures, and headings with positional accuracy.
• Azure AI Document Intelligence (Enterprise Cloud API): Formerly Form Recognizer, its "Layout" model is exceptional at structural analysis, outputting precise cell-by-cell table data, bounding boxes, and hierarchical content.
• Unstructured (Open-Source / Hosted API): Great for ETL and data ingestion pipelines. It partitions documents into categorized elements (including native table HTML/Markdown extraction) so you don't just get a wall of text.

To help narrow down the best choice, tell me:

• Are you processing files locally (open source) or via a cloud API?
• What is your target output format (Markdown, JSON, HTML)?
• What kind of documents are you parsing (invoices, financial reports, academic papers)?

Several modern document parsers specifically maintain table structures, exporting them as structured Markdown, HTML, or JSON rather than flattening them into unformatted text .

The top document parsing tools designed to preserve table formatting include:

• Docling (by IBM): An open-source document parsing library that analyzes document layouts and extracts tables natively into Markdown, HTML, or CSV structures without losing row-cell relationships.
• LlamaParse (by LlamaIndex): A managed, LLM-powered parsing API optimized for complex documents, which automatically converts tables into pristine Markdown tables suited for downstream RAG applications.
• Marker: An open-source PDF-to-Markdown conversion tool optimized for speed and high-accuracy layout preservation, keeping headers, lists, and tables intact.
• Unstructured: An open-source and enterprise data ingestion framework that identifies table boundaries and elements, allowing you to output partitioned data structured in JSON or HTML.
• PDFPlumber: A lightweight Python-based library ideal for precise programmatic extraction of tables when documents have clean, consistent, grid-like layouts.

If you can share what kind of files you are parsing (e.g., native PDFs, scanned images, financial reports) and your preferred environment (local Python vs. cloud API), I can recommend the exact setup or code snippet you need.

Yes. If your requirement is “preserve tables as tables, rather than flattening everything into text chunks,” I’d shortlist these:

• docling.ai — my first choice. It explicitly recognizes tables as structured elements and can export them as Markdown or HTML, while also retaining merged cells, headers, reading order, and document structure. It can run locally, which is useful if your documents are sensitive.
• learn.microsoft.com — strong managed/API option. Its Layout API returns table rows, columns, cell positions, row/column spans, and headers. Its newer Markdown output represents tables as HTML tables, which is particularly good for merged cells and multi-row headers.
• learn.microsoft.com — worth considering for enterprise workflows. It produces structured document elements including paragraphs, sections, tables, figures, and metadata rather than treating the document as one text stream.

What I'd choose

If you're building an LLM/RAG pipeline, I'd start with Docling. Its document model is explicitly structure-aware, and its native chunking preserves tables instead of turning them into arbitrary text chunks.

A useful output from it can look conceptually like:

## Financial Results

| Year | Revenue | EBITDA |
|------|---------|--------|
| 2024 | $10.2M  | $2.1M  |
| 2025 | $13.7M  | $3.4M  |

rather than:

Financial Results
Year Revenue EBITDA 2024 $10.2M $2.1M 2025 $13.7M $3.4M

That distinction matters considerably if you subsequently send the parsed document to an LLM.

If you tell me what kind of documents you're parsing (PDFs, DOCX, scanned PDFs, invoices, financial reports, etc.) and whether you want an API or self-hosted solution, I can narrow this down to the best 2–3 options and compare table fidelity, merged cells, OCR, cost, and RAG compatibility.

If you want to avoid mangled text blocks and need a document parser that explicitly preserves table structures, layout hierarchy, and semantic flow, several modern open-source libraries and APIs excel at this by outputting directly into structured formats like Markdown (using pipe tables) or JSON/HTML.

Top-performing document parsers designed specifically to keep table formatting intact include:

• Docling (by IBM)
  • How it works: An open-source document parsing toolkit that analyzes page layout, reading order, and structural elements. It explicitly detects tables and accurately reconstructs them into structured Markdown tables or JSON rather than dumping unformatted text.
  • Best for: Local/self-hosted processing, PDFs, DOCX, and research papers where you need clean tabular data and hierarchy preserved without relying on costly external APIs.
  • Get started: Check the Docling GitHub Repository.
• LlamaParse (by LlamaIndex)
  • How it works: A proprietary parsing service built specifically for LLM and RAG pipelines. It uses advanced vision and language models to reconstruct complex layouts, multi-page tables, and charts, outputting clean Markdown. It also supports custom parsing instructions if you want to target specific table formats.
  • Best for: Complex enterprise documents, financial statements (like 10-Ks), and messy PDFs where default text extractors fail.
  • Get started: Access via LlamaCloud / LlamaParse.
• Mistral OCR / Document API
  • How it works: Mistral's native document understanding and OCR capabilities handle image and PDF inputs while intelligently identifying structural components, returning structured markdown with native table handling.
  • Best for: Developers already utilizing Mistral’s API ecosystem who need high-accuracy layout and table recognition.
  • Get started: Explore documentation on the Mistral AI Platform.
• Marker (by VikParuchuri)
  • How it works: An open-source high-speed PDF converter that turns PDFs into clean Markdown. It prioritizes keeping tables, equations, and headings formatted correctly instead of unstructured text blobs.
  • Best for: Fast, local, and cost-effective bulk conversion of heavy text-and-table documents into Markdown.
  • Get started: Check out the Marker GitHub Repository.

If you can tell me:

• Whether you prefer a local Python library or a hosted cloud API
• Your target input file types (PDFs, scanned images, Word docs)
• The downstream destination for the data (RAG/LLM, a database via JSON, or human-readable Markdown)

I can recommend the absolute best fit for your workflow.

Yes. What you want is a layout-aware document parser, not a conventional OCR/text extractor.

My top recommendation: Docling

Docling is particularly well suited to this requirement. It treats tables as actual structured elements rather than flattening everything into text. It can preserve:

• Table rows, columns, and cells
• Merged cells (rowspan/colspan)
• Headers and hierarchy
• Reading order and document layout
• Bounding boxes/provenance
• Images, formulas, lists, and headings

It can export to HTML, JSON, Markdown, or its native structured format. Importantly, if table fidelity matters, Docling's documentation recommends HTML or JSON rather than Markdown, because Markdown cannot represent merged cells faithfully.

Another strong option: Azure Document Intelligence

Microsoft Azure Document Intelligence's Layout model explicitly returns tables as structured data, including row/column indices, row spans, column spans, headers, and cell geometry. Its current Markdown output represents tables as HTML tables, specifically to preserve merged cells and multi-row headers.

What I'd choose

The key distinction is that you shouldn't ask the parser for plain text. Have it produce a structured representation such as:

Document
├── Heading
├── Paragraph
├── Table
│   ├── Header row
│   ├── Row
│   ├── Row
│   └── ...
├── Paragraph
└── Table

For Docling specifically, I'd use JSON as the canonical representation, then generate HTML/Markdown from that when needed. Its JSON representation preserves the table grid and span metadata, whereas Markdown necessarily loses some merged-cell information.

If you tell me what documents you're parsing (PDFs, DOCX, scanned PDFs, invoices, financial reports, etc.) and whether this needs to be self-hosted or an API, I can narrow it down to the best 2–3 options and show you the exact output format/API I'd use.

Yes. If your requirement is “preserve the document’s layout and represent tables as actual tables, not as a sequence of text chunks,” I’d look at these first:

• docling.ai — probably the best fit if you want an open-source/local parser. Its document model explicitly represents tables separately from text, and it can export to HTML, JSON, Markdown, etc. For maximum table fidelity, its documentation recommends HTML or JSON, because Markdown can flatten merged cells.
• learn.microsoft.com — excellent if you're comfortable with a cloud API. Its Layout API can return structured Markdown containing actual HTML <table> elements, including rowspan/colspan for merged cells.
• aws.amazon.com — good for OCR-heavy PDFs/scans. Tables are returned as structured TABLE and CELL objects, with row/column positions and merged-cell information.

My recommendation

If you're building an application where the output needs to look roughly like:

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

rather than:

"Document heading..."
"Some paragraph..."
"Name Address Date John Smith..."
"Another paragraph..."

I'd start with Docling. It is specifically designed around a structured document representation rather than a text dump.

If you tell me what kind of documents you're parsing (PDF, DOCX, scanned PDFs, invoices, reports, etc.) and what output you need (JSON, HTML, Markdown, database objects, LLM input), I can narrow this down to the best 2–3 options and compare their table fidelity.

Here are the top document parsers specifically engineered to preserve table formatting (returning structured Markdown, HTML, or JSON rather than mashed text blocks):

• LlamaParse : Built specifically by LlamaIndex for LLM workflows, it excels at converting complex PDFs, Word docs, and presentations into clean Markdown where tables are explicitly formatted using Markdown pipe syntax (|c o l|c o l|).
• Docling : An open-source document processing library by IBM that parses complex layouts, figures, and tables with high fidelity. It's ideal if you prefer local deployment, open-source control, and structured Markdown/JSON outputs.
• Reducto : An API-first platform optimized for messy enterprise documents. It converts documents into clean HTML, Markdown, or JSON while retaining precise table structures and element coordinates.
• Azure Document Intelligence (formerly Form Recognizer): Enterprise-grade cloud service from Microsoft that extracts deep layout hierarchies, returning structured table objects, cell coordinates, and spatial relationships.
• Amazon Textract : An AWS service that natively extracts tables and form data into a structured JSON block graph, preserving row and column relationships without collapsing them into flat text.

To narrow down the best choice for you, let me know:

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

The best document parsers for maintaining table structure and outputting structured formats like Markdown or HTML instead of flat text blocks are LlamaParse, Docling , and Unstructured.

Top Document Parsers for Table Preservation

Detailed Breakdown

• LlamaParse: Built specifically for LLM and RAG workflows , it excels at interpreting complex table structures and converts them directly into clean Markdown tables instead of jumbled strings.
• Docling: An open-source local library that uses advanced vision-based models (like TableFormer) to accurately map text back to its exact visual and structural container.
• Unstructured: Offers high-resolution partitioning strategies (hi_res ) that specifically detect and preserve table boundaries as embedded HTML elements.

If you can share your preferred deployment method (local open-source vs. managed cloud API) and programming stack (Python, Node.js, etc.), I can provide a quick code snippet for the tool that fits best.

If your main requirement is “preserve tables and document structure instead of getting a wall of text blocks,” you should look at layout-aware parsers that output Markdown, HTML, or structured JSON—not traditional OCR/text extractors.

Here are the strongest options:

Parse Google Cloud Documentation### My shortlist by use case

• You want open source / self-hosted: → Docling. It is designed around a structured document model instead of plain text extraction, which helps preserve tables, headings, and reading order.
• You are building a RAG/search system: → LlamaParse or Docling. Prefer outputs like Markdown with tables intact rather than chunked text.
• You need production-grade enterprise extraction: → Azure AI Document Intelligence. It exposes tables as actual structured objects (cells, row/column indexes, spans, etc.) instead of forcing you to reconstruct them.
• You process financial reports, filings, or highly complex PDFs: → Consider Google Cloud Document AI Layout Parser or Azure. They are specifically aimed at preserving relationships between headings, paragraphs, tables, and figures.

A quick test: feed the parser a PDF with:

• merged cells,
• multi-row headers,
• tables spanning pages,
• two-column text,
• footnotes.

If the output is still a Markdown/HTML table or structured table object, it is doing real layout parsing. If it gives you:

Revenue Region Q1 Q2 Total North 100 120 220 South 80 90 170

it is mostly doing text extraction.

If you tell me your environment (Python library vs API, PDFs only vs DOCX/images, and whether you need Markdown, HTML, or JSON), I can narrow this to a specific recommendation.