In its default auto tier, PDFluent 1.4.0 scores 0.9282 overall on opendataloader-bench, a public PDF to Markdown benchmark of 200 documents.* The score was measured with the benchmark's own harness and evaluator and submitted to the benchmark repository; PDFluent is not on its public leaderboard yet.
On opendataloader-bench, SDK 1.4.0 in its default auto tier scores 0.9282 overall*, 0.9463 on reading order, 0.9140 on table structure and 0.8767 on heading hierarchy, on all 200 documents, with the benchmark's own harness and evaluator. The same harness and settings gave SDK 1.3.0 0.9154, 0.9359, 0.8695 and 0.8678.
| Row | Overall | Reading order | Table structure | Heading hierarchy |
|---|---|---|---|---|
| PDFluent 1.4.0 auto | 0.9282 | 0.9463 | 0.9140 | 0.8767 |
| PDFluent 1.3.0 auto | 0.9154 | 0.9359 | 0.8695 | 0.8678 |
*Measured 11 Nov 2026 on the final macOS arm64 release wheel (Apple M1 Pro, macOS 26.5), quality="auto" with keep_furniture=True and the layout, table and formula models installed. Table structure counts 42 documents, heading hierarchy 107, reading order and overall 200.
Known issue: on the olmOCR-bench headers and footers category, SDK 1.4.0 quality="auto" scores 0.0013 lower than SDK 1.3.0 (one run, 6 November 2026). The other seven categories are equal or higher. keep_furniture=True keeps page headers and footers on every tier.
The sections below describe SDK 1.3.0 with their own dates and footnotes; to reproduce those rows, install the version that was measured.
Two rows, one per extraction tier, each scored on all 200 documents of the benchmark.
Overall score, default tier: layout and table models, OCR for pages without a text layer.
Overall score, fast tier: the engine alone, no models installed.
7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109, its own evaluatorSubmitted to the benchmark repository, PR #37 (scores) and PR #38 (per-document predictions), not on its public leaderboard yet. The steps to reproduce both rows are on the opendataloader-bench page.
| Row | Overall | Reading order | Table structure | Heading hierarchy | Seconds per document |
|---|---|---|---|---|---|
| PDFluent 1.3.0 auto | 0.9154 | 0.9359 | 0.8695 | 0.8678 | 2.6619 |
| PDFluent 1.3.0 fast | 0.8573 | 0.8998 | 0.6316 | 0.8147 | 0.0091 |
*Measured with the benchmark's own harness and evaluator, opendataloader-bench at commit 7af1d8f.
Submitted to the benchmark repository, PR #37 (scores) and PR #38 (per-document predictions), not on its public leaderboard yet. The steps to reproduce both rows are on the opendataloader-bench page.
Every engine in the benchmark's README, with its published scores and speed, and the two PDFluent rows, which are submitted and not on the leaderboard yet. Sorted by overall.
Sorted by one measure: reading order · table structure · heading hierarchy. Licence as the README states it (A67); PDFluent: the SDK licence.
| Engine | Overall | Reading order | Table structure | Heading hierarchy | Speed (s) | Licence |
|---|---|---|---|---|---|---|
| PDFluent 1.4.0 autosubmitted, PR #37 | 0.9282 | 0.9463 | 0.9140 | 0.8767 | s/doc, Apple M1 Pro | AGPL-3.0-only or the PDFluent Commercial Licence, at your option |
| opendataloader [hybrid] | 0.907 | 0.934 | 0.928 | 0.821 | 0.463s/page as published, Apple M4 | Apache-2.0 |
| PDFluent 1.4.0 fastsubmitted, PR #37 | 0.8869 | 0.9145 | 0.7213 | 0.8601 | s/doc, Apple M1 Pro | AGPL-3.0-only or the PDFluent Commercial Licence, at your option |
| nutrient | 0.885 | 0.925 | 0.708 | 0.819 | 0.008s/page as published, Apple M4 | Commercial |
| docling | 0.882 | 0.898 | 0.887 | 0.824 | 0.762s/page as published, Apple M4 | MIT |
| marker | 0.861 | 0.890 | 0.808 | 0.796 | 53.932s/page as published, Apple M4 | GPL-3.0 |
| unstructured [hi_res] | 0.841 | 0.904 | 0.588 | 0.749 | 3.008s/page as published, Apple M4 | Apache-2.0 |
| edgeparse | 0.837 | 0.894 | 0.717 | 0.706 | 0.036s/page as published, Apple M4 | Apache-2.0 |
| opendataloader | 0.831 | 0.902 | 0.489 | 0.739 | 0.015s/page as published, Apple M4 | Apache-2.0 |
| mineru | 0.831 | 0.857 | 0.873 | 0.743 | 5.962s/page as published, Apple M4 | AGPL-3.0 |
| pymupdf4llm | 0.732 | 0.885 | 0.401 | 0.412 | 0.091s/page as published, Apple M4 | AGPL-3.0 |
| unstructured | 0.686 | 0.882 | 0.000 | 0.388 | 0.077s/page as published, Apple M4 | Apache-2.0 |
| markitdown | 0.589 | 0.844 | 0.273 | 0.000 | 0.114s/page as published, Apple M4 | MIT |
| liteparse | 0.576 | 0.866 | 0.000 | 0.000 | 1.061s/page as published, Apple M4 | Apache-2.0 |
A77, A78, A65, A66, A71 · opendataloader-bench README at commit 7af1d8f, read 3 Nov 2026 · leaderboard speeds as published (column "Speed (s/page)"; each engine's summary.json names an Apple M4 and the values equal its seconds per document) · PDFluent scores macOS arm64, Apple M1 Pro (A77, A78); speeds 1.3.0, Apple M1 Pro (A66). The leaderboard speeds were measured on an Apple M4, the PDFluent speeds on an Apple M1 Pro, and the submissions on the hardware each pull request states. The speeds are not comparable, and no speed comparison is made in the text. Source: opendataloader-bench at 7af1d8f; PDFluent: PR #37 (scores) and PR #38 (per-document predictions).
4 other open pull requests add 8 configurations of 4 engines to the benchmark. None of them is on the leaderboard yet. The figures and the hardware are as each pull request states them, read 3 Nov 2026.
| Engine and configuration | Overall | Reading order | Table structure | Heading hierarchy | s/doc | Hardware | Pull request |
|---|---|---|---|---|---|---|---|
| kordoc 4.15.7kordoc-plain-ocr | 0.9711 | 0.9751 | 0.9828 | 0.9579 | 0.458 | Apple M5 | #35, 27 Sep 2026 |
| kordoc 4.15.7kordoc-ocr | 0.9598 | 0.9598 | 0.9790 | 0.9489 | 0.447 | Apple M5 | #35, 27 Sep 2026 |
| kordoc 4.15.7kordoc-plain | 0.9491 | 0.9540 | 0.9395 | 0.9425 | 0.032 | Apple M5 | #35, 27 Sep 2026 |
| kordoc 4.15.7kordoc (defaults) | 0.9371 | 0.9380 | 0.9357 | 0.9326 | 0.035 | Apple M5 | #35, 27 Sep 2026 |
| LM-Kit One 2026.9.8lm-kit-ocr (text layer + OCR) | 0.9630 | 0.9718 | 0.9577 | 0.9487 | 0.0243 | Apple M4 Max | #34, 25 Sep 2026 |
| LM-Kit One 2026.9.8lm-kit (text layer, no OCR) | 0.9478 | 0.9545 | 0.9342 | 0.9389 | 0.0041 | Apple M4 Max | #34, 25 Sep 2026 |
| folio (version not stated)folio | 0.924 | 0.947 | 0.894 | 0.879 | 0.039 | 4-core Xeon 2.1 GHz | #33, 22 Sep 2026 |
| liteparse 2.10.1liteparse | 0.8732 | 0.9127 | 0.6929 | 0.8114 | 0.0039 | Apple M2 Max | #28, 18 Jun 2026Figures not stated in the PR text; from the PR's committed prediction/liteparse/evaluation.json, rounded to four decimals. |
A71 · figures and hardware as each pull request gives them, read 3 Nov 2026 · open pull requests to opendataloader-bench, not on its leaderboard yet. Each row is the submitter's own run on the hardware it names, not re-run by us. PDFluent's own submission, PR #37 (scores) and PR #38 (per-document predictions), is in table 1. Source: open pull requests of opendataloader-bench.
In its default auto tier, PDFluent 1.4.0 scores 0.9282 overall on all 200 documents: 0.9463 on reading order, 0.9140 on table structure and 0.8767 on heading hierarchy.
In the auto tier, PDFluent scores 0.9282 on overall.
In the fast tier, with no models, it scores 0.8869.
In the auto tier, PDFluent scores 0.9463 on reading order.
In the fast tier, with no models, it scores 0.9145.
In the auto tier, PDFluent scores 0.9140 on table structure.
In the fast tier, with no models, it scores 0.7213.
In the auto tier, PDFluent scores 0.8767 on heading hierarchy.
In the fast tier, with no models, it scores 0.8601.
NID scores reading order, TEDS scores table structure and MHS scores heading hierarchy, each from 0 to 1 against the benchmark's ground truth.
The benchmark's own overall score: the mean over the documents of each document's combined score, as its evaluator computes it.
One number for a first comparison. The three measures below tell you where it comes from.
Normalized indel distance between the extracted text and the ground truth: how much of the text comes out, in the right order.
Reading order matters for RAG chunking: a chunk whose sentences come out of order retrieves and reads badly.
NID = 1 − distance / (len(gt) + len(pred))
Tree edit distance similarity between each extracted table and the true one, counting rows, columns, spans and cell text.
Tables matter for invoices, financial statements and reports, where a row has to stay a row and a cell has to stay in its column.
TEDS = 1 − EditDist(T_gt, T_pred) / max(|T_gt|, |T_pred|, 1)
How closely the Markdown headings and their levels match the document's own outline.
Heading levels decide where a section-aware splitter can cut a document and which section title a chunk carries.
MHS = 1 − EditDist(H_gt, H_pred) / max(|H_gt|, |H_pred|, 1)
Formulas as the benchmark's README gives them (section 3, Metrics). Documents without a table or headings in the ground truth are left out of that measure's mean.
Pick the measure that matches your documents, then read that column of the leaderboard, not only the overall score.
| Job | What matters | PDFluent tier | PDFluent on this benchmark |
|---|---|---|---|
| RAG pipeline | Reading order (NID) and heading hierarchy (MHS): chunks in order, cut at sections | auto | Reading order: 0.9463. Headings: 0.8767. |
| Invoices, statements, reports | Table structure (TEDS) | auto, with the table model | Table structure: 0.9140. |
| Speed-sensitive batch | Time per page on your hardware | fast, no models | Not compared with other engines. On a laptop (Apple M1 Pro, macOS 26.5, Python 3.13) the fast tier takes 0.0091 seconds per document; see the laptop measurement. |
| No model downloads | The text layer only: the package, with no models and no Tesseract | fast | Overall: 0.8869. |
| Commercial licence needed | The licence column of the leaderboard | either tier | AGPL-3.0-only or the PDFluent Commercial Licence, at your option. |
Scores from the leaderboard table above. Licences of other engines as their README states them; check each project's own terms before you ship.
Run the benchmark's own harness at the same commit, convert each PDF with the call below and score the output with its evaluator.
7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109 and install it as its README describes:git clone https://github.com/opendataloader-project/opendataloader-bench
cd opendataloader-bench
git checkout 7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109
git lfs install && git lfs pull
uv syncpip install pdfluent==1.4.0
pdfluent models install layout tablesauto+kf: extract_markdown(path, quality="auto", keep_furniture=True). Fast row, recipe fast+kf: extract_markdown(path, quality="fast", keep_furniture=True).prediction/<engine>/markdown) and run its evaluator, for example uv run src/evaluator.py --engine <engine>.| Row | Overall | Reading order | Table structure | Heading hierarchy |
|---|---|---|---|---|
| auto+kf | 0.9282 | 0.9463 | 0.9140 | 0.8767 |
| fast+kf | 0.8869 | 0.9145 | 0.7213 | 0.8601 |
Measured 11 Nov 2026 (auto and fast, SDK 1.4.0) on Apple M1 Pro (macOS 26.5), final macOS arm64 release wheel, one run. Scores on other platforms can differ slightly, most on table structure.
The harness at this commit has no PDFluent engine of its own. The recipe files auto+kf and fast+kf in pdfluent-bench hold the exact configuration of both rows. More on the calls in the extraction guide.
The submission adds both rows to the harness as pdfluent-auto and pdfluent-fast. On the branch of PR #37 the run is:
uv sync --extra pdfluent
python -m pdfluent models install layout tables
uv run src/run.py --engine pdfluent-auto --force
uv run src/run.py --engine pdfluent-fast --forceIt is one benchmark of 200 documents and one run, with these limits.
*Balanced tier with the table model (Preview), on our own held-out half of four public datasets, 17 Oct 2026. Average 0.721 for PDFluent, 0.693 for pymupdf4llm and 0.672 for Docling, over FinTabNet, PubTables-1M, DocLayNet and ParseBench. The table model was trained on the source datasets of PubTables-1M and FinTabNet, and most of those held-out pages are in their training split. On the 13 measures without that overlap the ranking is the same (0.650, 0.642, 0.610). Details: blog post SDK 1.2.0 and the benchmarks page.
All 19 measuresThe auto tier, OCR for pages without a text layer, heading levels, and the upgrade notes.
Read the 1.3.0 postopendataloader-bench is a public benchmark on GitHub that scores PDF to Markdown engines on 200 PDFs. It converts each PDF with each engine and scores the output with its own evaluator on reading order (NID), table structure (TEDS) and heading hierarchy (MHS), plus an overall score. Its README publishes a leaderboard of 12 engines.
On the benchmark's published leaderboard, its README read 3 Nov 2026, the top listed engine is opendataloader [hybrid] at 0.907 overall. PDFluent 1.4.0 in its auto tier scored 0.9282 with the benchmark's own harness and evaluator; it is submitted (PR #37) and not on the leaderboard yet. Other engines also have submissions open that are not on the leaderboard yet; the table of submitted results on this page gives each one's own figures and hardware. The leaderboard is updated by the benchmark's maintainers, so its README has the current table.
The best one for RAG is the one that keeps reading order and heading levels right on your own documents, so test a sample of yours. Reading order decides whether a chunk keeps its sentences in order, and heading levels decide where a section-aware splitter can cut; on documents with many tables, table structure matters too. On opendataloader-bench, PDFluent 1.4.0 in the auto tier scores 0.9463 on reading order, 0.9140 on table structure and 0.8767 on heading hierarchy; the two tables on this page have every published and submitted engine's numbers. Licence and whether you can install models and Tesseract are the other two factors.
Table structure (TEDS) on the published leaderboard (README read 3 Nov 2026) runs from 0.000 to 0.928, and PDFluent 1.4.0 scores 0.9140 in the auto tier. The two top published values are opendataloader [hybrid] at 0.928 and docling at 0.887 PDFluent's fast tier, which runs no table model, scores 0.7213. A TEDS of 1 means every row, column, span and cell text matches the true table; the submissions not yet on the leaderboard give their own TEDS in the second table.
By the licences the benchmark's README states, opendataloader [hybrid], docling, unstructured [hi_res], edgeparse, opendataloader, unstructured, markitdown and liteparse are under Apache-2.0 or MIT. The same README lists marker, mineru and pymupdf4llm under GPL-3.0 or AGPL-3.0, and nutrient as Commercial. The PDFluent SDK is licensed AGPL-3.0-only or the PDFluent Commercial Licence, at your option. This is not legal advice; check each project's own terms before you ship.
Check out opendataloader-bench at commit 7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109, install PDFluent and its models, convert each PDF with extract_markdown and score the output with the benchmark's evaluator. Install PDFluent with pip install pdfluent==1.4.0, the models with pdfluent models install layout tables, and Tesseract on the machine for OCR of scanned pages. Use extract_markdown(path, quality="auto", keep_furniture=True) for the auto row and write the Markdown where the harness expects predictions. The recipe files auto+kf and fast+kf in pdfluent-bench hold the exact configuration of both rows, and the branch of PR #37 adds both rows to the harness.
NID measures reading order, TEDS measures table structure and MHS measures heading hierarchy, each from 0 to 1 with higher better. NID (normalized indel distance) counts how much of the text comes out, in the right order. TEDS (tree edit distance similarity) compares rows, columns, spans and cell text against the true table. MHS compares the Markdown headings and their levels with the document's outline.
Not yet. PDFluent is submitted to the benchmark repository: PR #37 with the scores and PR #38 with the per-document predictions, both opened 2 Nov 2026. The PDFluent scores on this page were measured with the benchmark's own harness and evaluator on its 200 documents, at commit 7af1d8f. The other engines are the figures the benchmark publishes in its README; we did not re-run them.
Only the auto tier does: you install its models once with pdfluent models install layout tables, and without them auto falls back to the fast tier and says so. The auto tier, the default from SDK 1.4.0, uses a layout model, a table model and a heading-level model, and runs OCR on pages without a text layer; that OCR needs Tesseract installed on the machine. The fast tier needs neither: it reads the PDF's text layer with the engine alone.
Auto reads each document with the layout and table models, gives headings their level and sends pages without a text layer to OCR; on opendataloader-bench it scores 0.9282 overall. Fast runs no model and was the default up to SDK 1.2; on the same benchmark it scores 0.8869 overall. To keep the 1.2 behaviour after upgrading, pass quality="fast".
The PDFluent desktop editor is free for everyone, including commercial use. The SDK, which is what this benchmark measures, is licensed AGPL-3.0-only or the PDFluent Commercial Licence, at your option.
Because the benchmark's ground truth counts page headers and footers as content. PDFluent drops them by default, which this benchmark would score as missing text, so both rows keep them. Outside this benchmark the default is unchanged.
Install the Python package, install the models once, and call extract_markdown.
PyMuPDF and MuPDF are trademarks of Artifex Software, Inc. PDFluent is an independent product of Innovation Trigger B.V. and is not affiliated with or endorsed by Artifex.