Best PDF to Markdown Converters, Tested on Real PDFs (2026)

We ran five open-source PDF to Markdown converters on the same five PDFs, on one Mac, with default settings: Docling, PyMuPDF4LLM, Marker, MinerU and MarkItDown. The test set covers a two-column research paper, a dense government table, a scanned page, a tax form and a 60-page report.

Short version of what we measured. Docling produced the most accurate tables and handled the scan, and it was also the slowest. PyMuPDF4LLM got the paper’s tables right in about 1.5 seconds, but returned nothing for the scanned page until we installed an OCR engine, and it is AGPL-licensed. Marker and MinerU read the scan well, and each broke the dense table in a different way. MarkItDown was the fastest by a wide margin and kept every line of the form, but it has no OCR and it scrambled the two-column paper.

Disclosure: Parsebridge, which publishes this blog, sells a hosted Docling API. We describe how we tested so you can rerun it, and we quote the output, including where Docling got things wrong.

Results

Per-document times, in seconds, from the second of two runs. “Cold” is a fresh process converting a one-page PDF, including imports and model loading, with models already downloaded. The other columns are warm conversions in the same process.

MinerU’s per-document times come from its own log; its cold figure is the wall time of one CLI call on the form page, which alone took 57 to 59 seconds of model time in every run.

How we tested

The PDFs. Each one stresses one thing, and all of them can be quoted here:

The machine. Mac mini, Apple M4 (4 performance and 6 efficiency cores), 16 GB RAM, macOS 26.6, Python 3.12.15. Each tool had its own virtual environment. Nothing else heavy ran during the timed passes. We ran every tool twice and report the second run. The 60-page times in the first table are the range across both runs, which differed by 2 to 13% per tool. Shorter conversions varied more: MinerU took 36 seconds on the paper in the first run and 24 in the second, and MarkItDown’s first cold start took 2.3 seconds.

Settings. Every tool ran with its documented defaults:

• Docling: DocumentConverter() with no options. OCR is on by default and the auto engine picked RapidOCR on PyTorch, because neither ocrmac, onnxruntime nor EasyOCR was installed. Models ran on the Apple GPU (MPS). TableFormer ran in its default accurate mode.
• PyMuPDF4LLM: to_markdown() with no options. pip install pymupdf4llm also installs pymupdf-layout, but no OCR engine. We ran the scanned page a second time with rapidocr_onnxruntime installed.
• Marker: PdfConverter with default config, which picks fast mode on CPU and Apple Silicon. Marker 2 needs a llama.cpp server for its Surya OCR model on this hardware; we used the llama-server binary from llama.cpp release b11572.
• MinerU: mineru-kit parse with no tier flag. It selected the standard tier, which combines small layout models with a 1.2B VLM run through llama.cpp.
• MarkItDown: MarkItDown().convert() with no plugins.

What we checked. For every output file we checked whether tables came out as Markdown tables with each value in the right cell, whether text followed the reading order of the page, whether headings became Markdown headings, and whether the scanned page produced text. Every judgment below comes from reading the saved output against the PDF page. The snippets are verbatim; long table rows are cut after a few columns and padding spaces are collapsed.

Parsebridge. Parsebridge runs Docling inside docling-serve 1.32.0, which bundles Docling 2.124. We had no API key, so we sent the four one-page PDFs through the free PDF to Markdown converter, which converts the first page of an upload. The scanned page came back identical to the local Docling run, and Table 1 on page 4 of the paper came back cell for cell. On the EIA table the cell values matched, including the merged degree-day row; the year and quarter headers came back as two separate rows, where Docling 2.138 combines them into labels like 2025 - Q1. We did not compare its timings, because they include the upload and the network.

Docling

Docling is an MIT-licensed document converter that started at IBM Research and is hosted by the LF AI & Data Foundation. It runs a layout model over each page, rebuilds tables with its TableFormer model, and runs OCR on regions without usable text. It reads PDF, DOCX, PPTX, XLSX, HTML, images and more, and exports Markdown, HTML, lossless JSON and DocTags. It needs Python 3.10 or newer.

pip install docling

from docling.document_converter import DocumentConverter

markdown = DocumentConverter().convert("table.pdf").document.export_to_markdown()

Measured. On the EIA table Docling kept all 15 columns, flattened the two header rows into one, and kept every two-line row label together with its values:

| | 2025 - Q1 | 2025 - Q2 | 2025 - Q3 | ...
| Energy Production | | | | ...
| Crude Oil Production (a) (million barrels per day) ........................ | 13.32 | 13.58 | 13.82 | ...

Its one error on that page was the last two rows, heating and cooling degree-days, merged into a single row with two numbers per cell:

| U.S. Heating Degree-Days ................... U.S. Cooling Degree-Days .................... | 2,104 53 | 436 464 | 55 902 | ...

On the paper it followed both columns in order, turned all 16 section titles into headings, and produced Tables 1 and 4 cell for cell, including the checkmarks. The scanned page came out with all its text and the item table; “Total:” and “CHF 42.00” ended up as two separate paragraphs. On the W-4 it kept the checkboxes as - [ ] list items, but put the Step 3 and Step 4 headings next to each other and placed the “Exempt from withholding” label inside Step 4.

Docling was the slowest tool on the 60-page report, at about four seconds per page. The default OCR setting also runs on bitmap regions, and the report has 16 pages of charts. Our Docling OCR guide covers how those defaults work and how to change them, and getting started with Docling in Python covers table and pipeline options.

Suits pipelines where table cells must be right, mixed born-digital and scanned input, and teams that need a permissive license. It needs PyTorch and about 0.5 GB of model weights, so plan for a long-running container. If you would rather not run it, Parsebridge runs Docling as an API (see below).

PyMuPDF4LLM

PyMuPDF4LLM is Artifex’s Markdown layer on top of PyMuPDF. Version 1.28.2 installs pymupdf-layout, a layout model that runs on the CPU, and outputs Markdown, JSON or plain text. It is dual-licensed under the AGPL-3.0 or a commercial license from Artifex. OCR runs automatically on pages that need it, but only if Tesseract or RapidOCR is installed; neither comes with the package.

pip install pymupdf4llm

import pymupdf4llm

markdown = pymupdf4llm.to_markdown("paper.pdf")

Measured. PyMuPDF4LLM converted the 10-page paper in 1.5 seconds with headings at the right levels and Tables 1 and 4 cell for cell. Reading order was correct until the last page, where it put the top of the right column, including section 9.3, before section 9.2 from the bottom of the left column. It also left page numbers in the text as stray lines. On the EIA table the body rows were right, but the year labels were split across the quarter columns:

||**Q1**|**Q2**<br>**202**|**Q3**<br>**5**|**Q4**|**Q1**|**Q2**<br>**202**|**Q3**<br>**6**|...

The last two rows of that table were also broken, with the thousands separators of one row pushed into the next. On the W-4 it wrapped the whole page in a two-column table and cut words across cells (“Department of the Tr” and “easury”).

With default dependencies the scanned page returned an empty string. After pip install rapidocr_onnxruntime it returned all the text and a correct table in under a second, with some words run together:

# SAMPLE ORDER

SyntheticOCRtestfixture-norealcustomerdata

Suits born-digital PDFs at volume, where you want structure and speed without a GPU, and where the AGPL or a commercial license works for you. Install an OCR engine if any of your PDFs are scans.

Marker

Marker is Datalab’s converter. The code is Apache 2.0; the model weights use a modified OpenRAIL-M license that is free for research, personal use and startups under $5M in funding or revenue. Marker 2 runs OCR, table fallback and, in balanced mode, layout through a Surya VLM served by a local inference server: vLLM in Docker on NVIDIA GPUs, llama.cpp’s llama-server on CPU and Apple Silicon. It defaults to fast mode on CPU and MPS and balanced mode on GPU.

pip install marker-pdf
brew install llama.cpp   # or a llama-server binary from the llama.cpp releases
marker_single paper.pdf --output_dir out

Measured. Marker needed one extra install step, a llama.cpp binary. After that, Surya started the server on demand. In fast mode the born-digital table and form took under a second each, while the scanned page, which goes through the VLM, took about 15 seconds and came back fully correct, with **Total: CHF 42.00** kept on one line.

On the EIA table every number landed in the right cell, including the two degree-day rows that tripped Docling and PyMuPDF4LLM. But the year header row was missing and the row labels lost their series names, which Marker collected into a single line under the table:

| (million barrels per day) ........................ | 13.32 | 13.58 | 13.82 | ...
| (billion cubic feet per day) ..................... | 105.5 | 106.9 | 108.3 | ...
| Energy Production Crude Oil Production (a) Dry Natural Gas Production Coal Production Energy Consumption ...

On the paper, Table 4 was correct, while Table 1 lost most of its header text and turned its checkmarks into X. The references and the appendix were collapsed into one long list item, and heading levels varied between #, ### and ####. On the W-4 the top half was clean, and Steps 3 and 4 became a table with the side labels mixed into the sentences.

Suits teams that self-host, fit under the license threshold or will buy a Datalab license, and have many scanned pages. On a GPU, balanced mode is the default; we did not test it.

MinerU

MinerU is OpenDataLab’s parser. Since version 3.1.0 (April 18, 2026) it uses the MinerU Open Source License, which is Apache 2.0 plus conditions: a separate commercial license above 100 million monthly active users or $20 million in monthly revenue, and visible attribution if you offer an online service built on it. Version 4 organizes parsing into four tiers, flash, basic, standard and advanced. On this Mac it chose standard, which ran a 1.2B VLM through llama.cpp and downloaded 2 GB of models.

uv pip install -U "mineru>=4.0,<5"
mineru-kit parse paper.pdf -o out

Measured. On the paper MinerU followed both columns in order, made the title # and every section ##, and got Table 1 right. The Table 2 header came out with characters from two lines interleaved (InTvoetsatligTaatbelde†s). It writes tables with merged cells as HTML <table> blocks, so Table 4 was correct HTML with rowspan attributes, and figures were embedded in the Markdown as base64 images.

The EIA table was its weakest result. The header was correct HTML, but the whole body went into one cell:

<td colspan="13">Energy Production Crude Oil Production (a) (million barrels per day) ........................ 13.32 13.58 13.82 13.91 ...

The scanned page came out complete with a correct table. The W-4 took 57 to 59 seconds, came out as a mix of HTML and Markdown tables, and was missing the “Form W-4” title and the “Employee’s Withholding Certificate” heading.

Suits papers and reports with scanned pages, where HTML tables and embedded images are acceptable downstream and the license conditions fit.

MarkItDown

MarkItDown is Microsoft’s MIT-licensed converter for many file types, including PDF, Word, PowerPoint, Excel, HTML, images, audio, EPUB and ZIP archives. Its PDF converter uses pdfminer.six and pdfplumber and does no OCR. OCR is available through the markitdown-ocr plugin, which calls an LLM vision model, or through Azure Document Intelligence. Its README says the output “may not be the best option for high-fidelity document conversions for human consumption.”

pip install 'markitdown[pdf]'
markitdown paper.pdf -o paper.md

Measured. MarkItDown was the fastest tool on every file: 0.4 seconds for the paper and 4.5 seconds for the 60-page report, with a 182 MB install and no model downloads. On the W-4 it returned every line of text in reading order, as plain text without headings or checkbox markup.

On the two-column paper, lines from both columns were merged, many words lost their spaces, and some prose lines were turned into tables:

Abstract
| Recently, | significant progress | has been made | applying |     |     |     |     |
| --------- | -------------------- | ------------- | -------- | --- | --- | --- | --- |
machinelearningtotheproblemoftablestructureinference

On the one-page EIA table it listed all the row labels first and then every number on its own line, so values could not be matched to rows. In the full 60-page report the same table came out as one text line per row, because MarkItDown switches to pdfplumber for the whole document once it detects a table-like page. The scanned page returned an empty string.

Suits quick text extraction from simple, single-column PDFs, and pipelines that already use MarkItDown for Office files and only need the words from PDFs.

Parsebridge

Parsebridge is our hosted Docling API. It takes PDFs up to 50 MB, runs Docling with TableFormer in accurate mode, turns OCR on when it detects scanned pages, and returns Markdown. New accounts get 50 free pages once, and paid plans are $17 a month for 5,000 pages, $79 for 60,000 and $259 for 300,000. The free PDF to Markdown converter converts the first page of a PDF up to 10 MB without an account, five times per hour. Its output on our test pages is described under How we tested.

Not tested

We did not run hosted or account-based services, so we make no quality claims about them: LlamaParse, the Datalab API, Mistral OCR, Azure Document Intelligence, Google Document AI, Adobe PDF Services, and browser-based converters such as CloudConvert. We also did not test Marker’s balanced mode or --use_llm option, MinerU’s other tiers, Docling’s VLM pipeline, or MarkItDown’s OCR plugin. Our comparison of LlamaParse, Docling and Marker covers pricing and licensing for the hosted options.

How to pick

• Tables have to be right, or your PDFs mix born-digital and scanned pages: Docling, self-hosted or through a hosted Docling API.
• Born-digital PDFs at volume, on CPUs: PyMuPDF4LLM, if the AGPL or a commercial license fits. Add Tesseract or RapidOCR for scans.
• Many scanned pages, self-hosted, under $5M: Marker, ideally on a GPU.
• Papers and scanned reports, with HTML tables acceptable downstream: MinerU.
• Plain text from simple PDFs, fast, in a pipeline that already handles Office files: MarkItDown.

Five PDFs cannot rank these tools for your documents. Pick three or four pages that represent your worst cases, run two or three candidates on them, and read the output. To see Docling’s Markdown for one of your own PDFs without installing anything, upload it to the free PDF to Markdown converter.