# PDF to Markdown benchmark: PDFluent on opendataloader-bench

Source: https://pdfluent.com/benchmarks/opendataloader-bench/

In its default auto tier, PDFluent 1.5.0 scores 0.9288 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.

pip install pdfluent==1.5.0

[Install PDFluent](https://pdfluent.com/docs/python/)Reproduce this result

Last updated 3 Nov 2026 · PDFluent measured 17 Nov 2026 (auto and fast, SDK 1.5.0) · leaderboard read 3 Nov 2026

SDK 1.4.0 · opendataloader-bench · 200 documents · measured 11 Nov 2026

## SDK 1.4.0 against SDK 1.3.0 on opendataloader-bench*

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.

- The scores are measured on the benchmark's own 200 documents.
- One run, no confidence interval.
- Both rows keep page headers and footers, because the benchmark's ground truth counts them as content.
- The table structure score depends on the platform, so the comparison is Mac against Mac.

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 score cards below are SDK 1.5.0 (A79, A80). The laptop measurement and the speeds are SDK 1.3.0 (A66) and keep their own date and footnote; to reproduce a row, install the version that was measured.

opendataloader-bench · 200 documents · two PDFluent tiers

## PDFluent 1.5.0 scores

Two rows, one per extraction tier, each scored on all 200 documents of the benchmark.

PDFluent 1.5.0 auto auto · default in 1.3.0

0.9288*

Overall score, default tier: layout and table models, OCR for pages without a text layer.

Reading order

0.9463

Table structure

0.9140

Heading hierarchy

0.8789

PDFluent 1.5.0 fast fast · no models

0.8870*

Overall score, fast tier: the engine alone, no models installed.

Reading order

0.9147

Table structure

0.7213

Heading hierarchy

0.8601

Harness

[opendataloader-bench](https://github.com/opendataloader-project/opendataloader-bench/tree/7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109) at commit `7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109`, its own evaluator

Documents

all 200

Machine

Google Cloud n2-standard-8, CPU only, Linux; table scores differ slightly by platform, see the laptop measurement below

Measured

PDFluent 17 Nov 2026 (auto and fast, SDK 1.5.0); leaderboard README read 3 Nov 2026

Who measured

PDFluent rows: measured by us. The 12 other engines: the published figures from the benchmark's README, not re-run by us.

Status

SDK 1.3.0 results submitted to the benchmark repository, [PR #37](https://github.com/opendataloader-project/opendataloader-bench/pull/37) (scores) and [PR #38](https://github.com/opendataloader-project/opendataloader-bench/pull/38) (per-document predictions), not on its public leaderboard yet. The steps to reproduce both rows are on the [opendataloader-bench page](https://pdfluent.com/benchmarks/opendataloader-bench/#reproduce).

Reproduced from the PyPI wheel on a laptop†

| 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 |

- † Second measurement, reproduced from the PyPI wheel (pdfluent 1.3.0) on a laptop: Apple M1 Pro, macOS 26.5, Python 3.13, harness at commit 7af1d8f, all 200 documents, keep_furniture=True, measured 2 Nov 2026.
- Median of three timed runs after a warm-up. These are the figures in the submission (PR #37).
- Table structure differs from the Linux run above by platform; every number here belongs to this machine.
- Seconds per document are for this laptop only. They are not compared with the speeds in the benchmark's README, which come from other machines.

*Measured with the benchmark's own harness and evaluator, opendataloader-bench at commit [7af1d8f](https://github.com/opendataloader-project/opendataloader-bench/tree/7af1d8f).

SDK 1.3.0 results submitted to the benchmark repository, [PR #37](https://github.com/opendataloader-project/opendataloader-bench/pull/37) (scores) and [PR #38](https://github.com/opendataloader-project/opendataloader-bench/pull/38) (per-document predictions), not on its public leaderboard yet. The steps to reproduce both rows are on the [opendataloader-bench page](https://pdfluent.com/benchmarks/opendataloader-bench/#reproduce).

- The scores are measured on the benchmark's own 200 documents.
- One run, no confidence interval.
- Both PDFluent rows keep page headers and footers (keep_furniture=True), because the benchmark's ground truth counts them as content.
- The table structure score depends on the platform; PDFluent 1.5.0 was measured on macOS arm64, both rows.
- Competitor scores are the published figures from the benchmark's README, not re-run by us.

Table 1 · 12 engines from the README at 7af1d8f plus PDFluent

## Published leaderboard

Every engine in the benchmark's README, with its published scores and speed, and the two PDFluent rows, which are not on the leaderboard. 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.5.0 auto not on the leaderboard | 0.9288 | 0.9463 | 0.9140 | 0.8789 |  | AGPL-3.0-only or the PDFluent Commercial Licence, at your option |
| opendataloader [hybrid] | 0.907 | 0.934 | 0.928 | 0.821 | 0.463 s/page as published, Apple M4 | Apache-2.0 |
| PDFluent 1.5.0 fast not on the leaderboard | 0.8870 | 0.9147 | 0.7213 | 0.8601 |  | AGPL-3.0-only or the PDFluent Commercial Licence, at your option |
| nutrient | 0.885 | 0.925 | 0.708 | 0.819 | 0.008 s/page as published, Apple M4 | Commercial |
| docling | 0.882 | 0.898 | 0.887 | 0.824 | 0.762 s/page as published, Apple M4 | MIT |
| marker | 0.861 | 0.890 | 0.808 | 0.796 | 53.932 s/page as published, Apple M4 | GPL-3.0 |
| unstructured [hi_res] | 0.841 | 0.904 | 0.588 | 0.749 | 3.008 s/page as published, Apple M4 | Apache-2.0 |
| edgeparse | 0.837 | 0.894 | 0.717 | 0.706 | 0.036 s/page as published, Apple M4 | Apache-2.0 |
| opendataloader | 0.831 | 0.902 | 0.489 | 0.739 | 0.015 s/page as published, Apple M4 | Apache-2.0 |
| mineru | 0.831 | 0.857 | 0.873 | 0.743 | 5.962 s/page as published, Apple M4 | AGPL-3.0 |
| pymupdf4llm | 0.732 | 0.885 | 0.401 | 0.412 | 0.091 s/page as published, Apple M4 | AGPL-3.0 |
| unstructured | 0.686 | 0.882 | 0.000 | 0.388 | 0.077 s/page as published, Apple M4 | Apache-2.0 |
| markitdown | 0.589 | 0.844 | 0.273 | 0.000 | 0.114 s/page as published, Apple M4 | MIT |
| liteparse | 0.576 | 0.866 | 0.000 | 0.000 | 1.061 s/page as published, Apple M4 | Apache-2.0 |

A79, A80, 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 (A79, A80); 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](https://github.com/opendataloader-project/opendataloader-bench/tree/7af1d8f); PDFluent: [PR #37](https://github.com/opendataloader-project/opendataloader-bench/pull/37) (scores) and [PR #38](https://github.com/opendataloader-project/opendataloader-bench/pull/38) (per-document predictions).

Table 2 · open pull requests to opendataloader-bench

## Submitted, not yet on the leaderboard

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.7 kordoc-plain-ocr | 0.9711 | 0.9751 | 0.9828 | 0.9579 | 0.458 | Apple M5 | [#35](https://github.com/opendataloader-project/opendataloader-bench/pull/35), 27 Sep 2026 |
| kordoc 4.15.7 kordoc-ocr | 0.9598 | 0.9598 | 0.9790 | 0.9489 | 0.447 | Apple M5 | [#35](https://github.com/opendataloader-project/opendataloader-bench/pull/35), 27 Sep 2026 |
| kordoc 4.15.7 kordoc-plain | 0.9491 | 0.9540 | 0.9395 | 0.9425 | 0.032 | Apple M5 | [#35](https://github.com/opendataloader-project/opendataloader-bench/pull/35), 27 Sep 2026 |
| kordoc 4.15.7 kordoc (defaults) | 0.9371 | 0.9380 | 0.9357 | 0.9326 | 0.035 | Apple M5 | [#35](https://github.com/opendataloader-project/opendataloader-bench/pull/35), 27 Sep 2026 |
| LM-Kit One 2026.9.8 lm-kit-ocr (text layer + OCR) | 0.9630 | 0.9718 | 0.9577 | 0.9487 | 0.0243 | Apple M4 Max | [#34](https://github.com/opendataloader-project/opendataloader-bench/pull/34), 25 Sep 2026 |
| LM-Kit One 2026.9.8 lm-kit (text layer, no OCR) | 0.9478 | 0.9545 | 0.9342 | 0.9389 | 0.0041 | Apple M4 Max | [#34](https://github.com/opendataloader-project/opendataloader-bench/pull/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](https://github.com/opendataloader-project/opendataloader-bench/pull/33), 22 Sep 2026 |
| liteparse 2.10.1 liteparse | 0.8732 | 0.9127 | 0.6929 | 0.8114 | 0.0039 | Apple M2 Max | [#28](https://github.com/opendataloader-project/opendataloader-bench/pull/28), 18 Jun 2026 Figures 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 SDK 1.3.0 submission, [PR #37](https://github.com/opendataloader-project/opendataloader-bench/pull/37) (scores) and [PR #38](https://github.com/opendataloader-project/opendataloader-bench/pull/38) (per-document predictions), is in table 1. Source: [open pull requests of opendataloader-bench](https://github.com/opendataloader-project/opendataloader-bench/pulls).

Per measure · 0 to 1 · higher is better

## Where PDFluent stands on each measure

In its default auto tier, PDFluent 1.5.0 scores 0.9288 overall on all 200 documents: 0.9463 on reading order, 0.9140 on table structure and 0.8789 on heading hierarchy.

Overall 0 to 1 · higher is better

PDFluent 1.5.0 auto 0.9288

opendataloader [hybrid] 0.907

PDFluent 1.5.0 fast 0.8870

nutrient 0.885

docling 0.882

marker 0.861

unstructured [hi_res] 0.841

edgeparse 0.837

opendataloader 0.831

mineru 0.831

pymupdf4llm 0.732

unstructured 0.686

markitdown 0.589

liteparse 0.576

In the auto tier, PDFluent scores 0.9288 on overall.

In the fast tier, with no models, it scores 0.8870.

Reading order (NID) 0 to 1 · higher is better

PDFluent 1.5.0 auto 0.9463

opendataloader [hybrid] 0.934

nutrient 0.925

PDFluent 1.5.0 fast 0.9147

unstructured [hi_res] 0.904

opendataloader 0.902

docling 0.898

edgeparse 0.894

marker 0.890

pymupdf4llm 0.885

unstructured 0.882

liteparse 0.866

mineru 0.857

markitdown 0.844

In the auto tier, PDFluent scores 0.9463 on reading order.

In the fast tier, with no models, it scores 0.9147.

Table structure (TEDS) 0 to 1 · higher is better

opendataloader [hybrid] 0.928

PDFluent 1.5.0 auto 0.9140

docling 0.887

mineru 0.873

marker 0.808

PDFluent 1.5.0 fast 0.7213

edgeparse 0.717

nutrient 0.708

unstructured [hi_res] 0.588

opendataloader 0.489

pymupdf4llm 0.401

markitdown 0.273

unstructured 0.000

liteparse 0.000

In the auto tier, PDFluent scores 0.9140 on table structure.

In the fast tier, with no models, it scores 0.7213.

Heading hierarchy (MHS) 0 to 1 · higher is better

PDFluent 1.5.0 auto 0.8789

PDFluent 1.5.0 fast 0.8601

docling 0.824

opendataloader [hybrid] 0.821

nutrient 0.819

marker 0.796

unstructured [hi_res] 0.749

mineru 0.743

opendataloader 0.739

edgeparse 0.706

pymupdf4llm 0.412

unstructured 0.388

markitdown 0.000

liteparse 0.000

In the auto tier, PDFluent scores 0.8789 on heading hierarchy.

In the fast tier, with no models, it scores 0.8601.

A79, A80, A65, A64 · opendataloader-bench @ 7af1d8f · 200 documents · PDFluent measured 17 Nov 2026 (auto and fast, SDK 1.5.0) · leaderboard README read 3 Nov 2026 · PDFluent four decimals as submitted, others three as published. Caveats.

opendataloader-bench

## What do NID, TEDS and MHS measure?

NID scores reading order, TEDS scores table structure and MHS scores heading hierarchy, each from 0 to 1 against the benchmark's ground truth.

### Overall

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.

### Reading order (NID)

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))`

### Table structure (TEDS)

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)`

### Heading hierarchy (MHS)

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.

Choosing a PDF parser

## Which PDF parser fits which job?

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.8789. |
| 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) SDK 1.3.0 in 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.8870. |
| 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.

opendataloader-bench

## How to reproduce the PDFluent score

Run the benchmark's own harness at the same commit, convert each PDF with the call below and score the output with its evaluator.

1. Check out the harness at commit `7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109` and install it as its README describes: shell `*git clone https://github.com/opendataloader-project/opendataloader-bench**cd opendataloader-bench**git checkout 7af1d8f4d0c09f51ea1a5c6ba5f66e993286d109**git lfs install && git lfs pull**uv sync*`
2. Install PDFluent and its models once: shell `*pip install pdfluent==1.5.0**pdfluent models install layout tables*` OCR of scanned pages in the auto row needs Tesseract installed on the machine and on PATH; the fast row needs neither the models nor Tesseract.
3. Convert every PDF. Auto row, recipe `auto+kf`: `extract_markdown(path, quality="auto", keep_furniture=True)`. Fast row, recipe `fast+kf`: `extract_markdown(path, quality="fast", keep_furniture=True)`.
4. Write the Markdown where the harness keeps predictions (`prediction/<engine>/markdown`) and run its evaluator, for example `uv run src/evaluator.py --engine <engine>`.

### Expected scores

| Row | Overall | Reading order | Table structure | Heading hierarchy |
| --- | --- | --- | --- | --- |
| auto+kf | 0.9288 | 0.9463 | 0.9140 | 0.8789 |
| fast+kf | 0.8870 | 0.9147 | 0.7213 | 0.8601 |

Measured 17 Nov 2026 (auto and fast, SDK 1.5.0) on Apple M1 Pro (macOS 26.5), macOS arm64 wheel built from the 1.5.0 release candidate, 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](https://github.com/pdfluent/pdfluent-bench) hold the exact configuration of both rows. More on the calls in the [extraction guide](https://pdfluent.com/how-to/extraction/).

The submission adds both rows to the harness as `pdfluent-auto` and `pdfluent-fast`. On the branch of [PR #37](https://github.com/opendataloader-project/opendataloader-bench/pull/37) the run is:

shell

```
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 --force
```

opendataloader-bench

## What this result does not say

It is one benchmark of 200 documents and one run, with these limits.

- The scores are measured on the benchmark's own 200 documents.
- One run, no confidence interval.
- Both PDFluent rows keep page headers and footers (keep_furniture=True), because the benchmark's ground truth counts them as content.
- The table structure score depends on the platform; PDFluent 1.5.0 was measured on macOS arm64, both rows.
- Competitor scores are the published figures from the benchmark's README, not re-run by us.
- There is no confidence interval: each score is one run.
- Not on its public leaderboard. SDK 1.3.0 results were submitted to the benchmark repository, PR #37 and #38.

More results

## Other PDFluent benchmarks

19 measures · held-out half

### Highest average score across 19 extraction measures*, against Docling 2.126.0 and pymupdf4llm 1.28.2.

Balanced tier + table model · opt-in · Preview

*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 measures

Release post

### What changed in SDK 1.3.0

The auto tier, OCR for pages without a text layer, heading levels, and the upgrade notes.

Read the 1.3.0 post

Comparisons

### PDFluent next to named tools

- [PDFluent vs Docling](https://pdfluent.com/comparison/vs-docling/)
- [PDFluent vs pymupdf4llm](https://pdfluent.com/comparison/vs-pymupdf4llm/)
- [PDFluent vs Nutrient](https://pdfluent.com/comparison/vs-nutrient/)
- [Extraction benchmark vs Docling](https://pdfluent.com/benchmarks/text-extraction-vs-docling/)

opendataloader-bench

## Questions about this benchmark

### What is opendataloader-bench?

opendataloader-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.

### Which PDF parser scores highest on opendataloader-bench?

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.5.0 in its auto tier scored 0.9288 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.

### What is the best PDF to Markdown converter for RAG?

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.5.0 in the auto tier scores 0.9463 on reading order, 0.9140 on table structure and 0.8789 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.

### How accurate is PDF table extraction on opendataloader-bench?

Table structure (TEDS) on the published leaderboard (README read 3 Nov 2026) runs from 0.000 to 0.928, and PDFluent 1.5.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.

### Which PDF parsers are free for commercial use?

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.

### How do I reproduce the benchmark?

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.5.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.

### What do NID, TEDS and MHS measure?

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.

### Is PDFluent on the public leaderboard?

No. PDFluent is not on the leaderboard. The SDK 1.3.0 results were 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.

### Does PDFluent need models?

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.5.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.

### How does auto differ from fast?

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.9288 overall. Fast runs no model and was the default up to SDK 1.2; on the same benchmark it scores 0.8870 overall. To keep the 1.2 behaviour after upgrading, pass quality="fast".

### Is PDFluent free for commercial use?

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.

### Why do both PDFluent rows use keep_furniture=True?

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.

SDK 1.5.0

## Get started with PDFluent

Install the Python package, install the models once, and call `extract_markdown`.

pip install pdfluent==1.5.0

[Read the docs](https://pdfluent.com/docs/)[Extraction guide](https://pdfluent.com/how-to/extraction/)[All benchmarks](https://pdfluent.com/benchmarks/)[The SDK](https://pdfluent.com/sdk/)

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.
