Skip to content
CrawlfolioSourced research on web data for AI
Menu

Your RAG pipeline needs to read PDFs, and some of them are ugly: scans, tables with merged cells, two-column papers, forms. The choice is between an open-source parser you run and a hosted API you pay per page, and the right answer depends on what your worst pages look like, what licence your product can live with, and how much data may leave your servers.

Below are per-1,000-page prices from nine price pages, a licence table built from the repositories, a table of who ran each benchmark, and a 20-page test you can run on your own worst pages.

Short on time?

Short on time? Here's my take.

Self-hosted default
Docling
MIT-licensed code with OCR for scans, table structure, formulas and Markdown or JSON output in one package. Check the licences of the models it pulls in.
Scanned pages, no big-cloud account
Mistral OCR 3
$2 per 1,000 pages, the lowest per-page price I found outside the three big clouds. OCR 4.1 is $4. Azure Read, Google OCR and Textract list $1.50 if you already run there.
Hard tables and mixed layouts, hosted
Reducto r-1
$10 per 1,000 pages with $150 of free usage to test on. Its parsing runs from $1 (r-1 mini) to $10 per 1,000; the $20 figure you may see is its Extract product.
Runner-up for hard pages
LlamaParse Agentic
$15 per 1,000 pages, with 10,000 free credits every month (1,000 Agentic pages). Its Cost Optimizer sends simple pages to a cheaper tier.
Born-digital, text-only PDFs
pypdf
BSD-3-Clause and free. It reads the text layer only: by its own docs it's not OCR software and sees tables as positioned text.
Already on Azure or Google Cloud
Azure Layout or Google Layout Parser
$10 per 1,000 pages each, inside the account and contracts you already have. Textract's Tables feature is $15.
PDFs found during a web crawl
Firecrawl
1 credit per PDF page, with OCR for scans: $0.99 per 1,000 pages on its $99 Standard plan.

Prices verified . These picks rest on price, licence and documentation. I found no independent accuracy benchmark, and none of these tools were run for this page.

The right PDF parser for RAG depends on your worst pages. Born-digital pages with a simple layout need only pypdf; tables and multi-column layouts need a layout parser such as Docling (self-hosted) or Reducto r-1 (hosted); scans need OCR, such as Mistral OCR 3 at $2 per 1,000 pages. Run a 20-page test before you pay.

This page sits in the crawl API hub. It covers turning PDFs into Markdown or JSON for an LLM; for web pages, website to markdown for LLMs compares the HTML converters.

What counts as your worst page? #

The page where a plain text extractor gives you nothing, or gives you the right words in the wrong order. Those are the pages that decide which parser you need, so find them before you read a single benchmark.

pypdf’s own documentation explains why. It says pypdf “is not OCR software” and “will also never be able to extract text from images”, that “tables are just absolutely positioned text”, and that a PDF has “no information what the header, footer, page numbers, tables, and paragraphs are” (pypdf docs). Every hard page type falls out of those four lines.

Worst-page type What goes wrong What you need
Scanned or image-only pages No text layer, so a text extractor returns nothing OCR
Tables with merged cells or multi-row headers Cells come out as loose numbers; headers get flattened Table-structure recognition
Multi-column layouts and floating figures Columns interleave; captions land mid-paragraph Layout analysis and reading order
Formulas Symbols come out as fragments A formula-aware model
Forms and key-value pages Labels and values drift apart Form or key-value extraction
Long reports with headers and footers Repeated running heads pollute every chunk Header and footer detection

These categories come from the tools’ own docs and the benchmarks below: olmOCR-Bench tests old scans, tables, math and multi-column pages, Marker and MinerU list formulas and tables, and the cloud OCR services price form extraction separately (olmOCR, Marker, MinerU, Textract).

To find yours, run a text-layer extractor over a sample of your corpus and sort the pages into three piles. Empty output means a scan. Words in a jumbled order mean columns or floating figures, and runs of numbers with no structure mean a table.

Three kinds of PDF parser, and where each breaks #

Text-layer extractors, layout and OCR pipelines you run yourself, and hosted parse APIs. Each one breaks somewhere different, which is why the worst-page sort comes first.

Text-layer extractors read the text a PDF already contains. pypdf (BSD 3-Clause) and pdfminer.six (MIT, with “Automatic layout analysis” but no OCR) are free and fast, and PyMuPDF is AGPL-3.0 (pypdf licence, pdfminer.six, PyMuPDF). They break on scans, and they hand you tables as positioned text.

Layout and OCR pipelines add models that find tables, columns, headings and formulas, and OCR scanned pages. They run on your hardware, so your documents never leave it. They break on setup cost, hardware and, in a few cases, licence terms.

  • Docling handles OCR for scans, table structure and formulas, can use vision-language models such as GraniteDocling, and outputs Markdown, HTML, DocTags or JSON. Its repository has 70.7k stars (Docling).
  • Marker handles tables, forms and equations, and has a --use_llm option that brings an LLM into the parse (Marker).
  • MinerU describes version 4.2 as improving cross-page table merging and inline formula recognition, with vision-language backends. Its basic ONNX mode runs on a CPU in about 2 GB of RAM; the standard and advanced PyTorch modes need a GPU with 8 GB or more of VRAM (MinerU).
  • Unstructured offers strategies: fast is rule-based and “not recommended for image-based file types”, hi_res uses a layout model, ocr_only is for image-based files, and auto picks one (Unstructured docs).
  • olmOCR, from AI2, is a 7B vision-language model that needs a GPU (olmOCR).
  • OpenDataLoader is an Apache-2.0 parser with a hybrid mode that calls an optional LLM (OpenDataLoader).

Hosted parse APIs take your PDF and return structured output, billed per page: LlamaParse, Reducto, Mistral OCR, Azure Document Intelligence, Google Document AI, AWS Textract and Firecrawl. They break on two things: your documents leave your servers, and the per-page price multiplies with volume.

The only independent comparison I found that ran the tools is small: one engineer, who discloses AI assistance, reports detailed results for three documents. In it, Docling rated “Excellent” on nested headers, Marker flattened a multi-row table header, and MarkItDown returned almost nothing on a scan because it doesn’t OCR by default (Danilchenko). That’s one person’s sample, but it lines up with the categories above: a converter without OCR fails the scan pile every time.

If you’re choosing open-source tools for the crawl side of the pipeline as well, open-source LLM crawlers covers those.

Close-up of light grey-pink blocks with a rough, speckled face laid in staggered courses with narrow pale joints
Blocks with different faces laid in one course: text-layer extractors, layout-aware pipelines and hosted APIs each handle a different kind of page. Photo: simon / Unsplash · Unsplash License

Which licences are safe in a commercial product? #

Most of them, with three catches: PyMuPDF’s AGPL, Marker’s model weights and MinerU’s conditions. I read each licence in the repository, because two ranking pages get them wrong.

Tool Licence, from the repository The commercial catch
pypdf BSD 3-Clause None, but no OCR
pdfminer.six MIT None, but no OCR
PyMuPDF and pymupdf4llm GNU AGPL v3 A closed-source product needs a commercial licence from Artifex
Docling MIT (code); models keep their own licences Check the licence of each model it downloads
Marker Apache 2.0 code since v2; weights under a modified AI Pubs Open Rail-M Weights are free only for research, personal use and startups under $5M funding or revenue
MinerU MinerU Open Source License (Apache 2.0 plus conditions) Commercial licence above 100M monthly users or USD 20M monthly revenue; online services must credit MinerU
Unstructured (open source) Apache-2.0 Telemetry is on by default
OpenDataLoader Apache-2.0 Hybrid mode calls an optional LLM
olmOCR Apache 2.0 Needs a GPU for its 7B model

Sources, verified 2026-11-16: pypdf, pdfminer.six, PyMuPDF, Docling, Marker, MinerU licence, Unstructured, OpenDataLoader, olmOCR.

The details behind the catches:

  • PyMuPDF is “Free for open-source projects” under the AGPL v3, and Artifex sells commercial licences (PyMuPDF). If your product is closed source and you ship or serve it, budget for that licence or pick another extractor.
  • Marker’s code is Apache 2.0, “free to use, including commercially”, but the weights are “free for research, personal use, and startups under $5M funding/revenue” (Marker). Version 1.x of the code was GPL-3.0 (Danilchenko).
  • MinerU requires a commercial licence if your group’s “monthly active users (MAU) exceed 100 million” or “total monthly revenue exceeds USD 20 million”, online services must “clearly and prominently indicate” that they use MinerU, and a breach ends the licence (MinerU licence).
  • Unstructured’s telemetry can be switched off with DO_NOT_TRACK or SCARF_NO_ANALYTICS (Unstructured).

Now the errors. fast.io calls Docling “Fully open-source (Apache 2.0 license)”, but the repository says “The Docling codebase is under MIT license” (fast.io, Docling). Both are permissive, so it won’t sink you, but it’s a sign the page wasn’t checked against the source.

The bigger one is the opendataloader-bench leaderboard, which still lists Marker as GPL-3.0 and MinerU as AGPL-3.0 (opendataloader-bench). Both labels are out of date against today’s repositories, and in MinerU’s case the old label hides the conditions that actually apply now.

What do hosted PDF parsers cost per 1,000 pages? #

From under $1 to $50, depending on the vendor and how hard the page is. I put every option on a per-1,000-pages basis, verified 2026-11-16; where a vendor bills credits, the dollar figure is my arithmetic.

Option Per 1,000 pages Free allowance Notes
Reducto r-1 mini $1 $150 of free usage Parse only
LlamaParse Fast $1.50 10,000 credits a month 1 credit a page, for plain text
Azure Read $1.50 500 pages a month (F0 tier)
Google Enterprise Document OCR $1.50 First 1,000 pages at $0
Textract Detect Document Text $1.50 Free tier for 3 months, new customers US West (Oregon) price
Mistral OCR 3 $2 Not stated $3 with annotations; lower cached rate
Mistral OCR 4.1 $4 Not stated Lower cached rate
LlamaParse Cost-effective $4.50 Shared 10,000 credits 3 credits a page, simple tables
Reducto r-1 $10 $150 of free usage 20% off in batch
Azure Layout $10 Same rate for all prebuilt models
Google Layout Parser $10 Includes initial chunking
LlamaParse Agentic $15 Shared 10,000 credits 10 credits a page
Textract Tables $15 Layout is free with Tables
Google Form Parser $30
LlamaParse Agentic Plus $37.50 Shared 10,000 credits 25 credits a page
Textract Forms $50
Firecrawl, PDF in a crawl $0.99 (Standard) to $3.80 (Hobby) 1,000 credits a month 1 credit a page
olmOCR, self-hosted Under $0.20, by its makers’ claim Not applicable Your GPU

Sources, verified 2026-11-16: LlamaIndex pricing, LlamaParse credits, Reducto, Mistral pricing, Mistral OCR 3 card, Azure, Google, Textract, Firecrawl, olmOCR. The Azure and Google pages were read through r.jina.ai; the Azure figures match Microsoft’s Retail Prices API for East US.

How the less obvious rows work:

  • LlamaParse charges 1, 3, 10 or 25 credits a page for Fast, Cost-effective, Agentic and Agentic Plus, plus 3 for layout extraction. Pay-as-you-go is $0 with 10,000 free credits a month, then $1.50 per 1,000 credits, so Agentic is 10 × $1.50 = $15 per 1,000 pages. The Pro plan is $500 a month with 400,000 credits and $1.25 per 1,000 after that (LlamaIndex pricing, credits).
  • LlamaParse’s cache helps when you iterate: “Parsed files are cached for 48 hours”, and re-parsing in that window is free (credits).
  • Reducto’s parse prices are $1 (r-1 mini) and $10 (r-1) per 1,000 pages. The $20 and $40 figures on the same page are Extract and Deep Extract, which pull fields rather than parse whole pages. Growth and Enterprise are custom-priced, with zero data retention and VPC or on-premise options (Reducto).
  • Mistral OCR 3 is the model mistral-ocr-2512, released December 18, 2025. Its card says OCR 4 is newer and OCR 3 “remains available” (model card).
  • Textract’s free tier gives new customers 1,000 or 100 pages a month, depending on the feature, for three months. Queries are $15 per 1,000 pages (Textract).
  • olmOCR’s makers say it runs for “less than $200 USD per million pages” (olmOCR). That’s their estimate on their assumptions, not a quote you can buy.

If what you actually need is fields from the document (an invoice total, a contract date) rather than parsed text for retrieval, that’s an extraction job, and LLM structured data extraction covers the options.

What would 10,000 pages a month cost? #

Between $20 and $150 on the hosted per-page options, before any volume deal. My arithmetic on list prices, verified 2026-11-16:

Option Monthly bill at 10,000 pages Working
Mistral OCR 3 $20 10 × $2
LlamaParse Cost-effective $30 30,000 credits − 10,000 free = 20,000 × $1.50 per 1,000
Mistral OCR 4.1 $40 10 × $4
Reducto r-1 $100 10 × $10; the first month fits inside the $150 free usage
Azure Layout $100 10 × $10
Google Layout Parser $100 10 × $10
LlamaParse Agentic $135 100,000 credits − 10,000 free = 90,000 × $1.50 per 1,000
Textract Tables $150 10 × $15
Firecrawl Standard Inside the $99 plan 10,000 of its 100,000 monthly credits
olmOCR, self-hosted Under $2, plus your GPU The makers’ own claim

The spread is 7.5 times between the cheapest and the dearest hosted row. That’s why I’d route only the worst page class to a $10-to-$15 tier and send everything else somewhere cheaper.

Can you trust PDF parsing benchmarks? #

Use them for method, not for a verdict. Every PDF parsing benchmark I found is run by a company or lab that makes one of the tools it scores, and the numbers don’t reconcile across runs.

Here’s who runs each one, what it scores and what to watch for:

Benchmark Run by Size What it scores What to watch
opendataloader-bench The OpenDataLoader project, which makes the parser it ranks first 200 PDFs with ground truth Reading order (NID), tables (TEDS), headings (MHS), speed Its own hybrid mode ranks first; licence labels are stale; no versions or hardware shown
Nutrient’s run of it Nutrient, which sells a PDF SDK Same 200 PDFs, on an Apple M3 Ultra Same Its own licence-key tier ranks first and isn’t on the public board
olmOCR-Bench AI2, which makes olmOCR “over 7,000 test cases across 1,400 documents” Unit tests on old scans, tables, math, multi-column Its own model sits second
OmniDocBench OpenDataLab, which makes MinerU 1,651 pages, 10 document types Text edit distance, table TEDS, formula CDM Dataset is “for research purposes only and not for commercial use”
OmniParseBench, in the Marker README Datalab, which makes Marker 2,937 pages, 16,288 tests Self-reported Maker’s own
RD-TableBench Reducto 1,000 hand-labelled complex tables Table similarity Results shown as an image; undated

Here’s what each leaderboard says, with the caveat attached. On the public opendataloader-bench board, OpenDataLoader’s hybrid mode scores 0.907, then Nutrient 0.885, Docling 0.882, Marker 0.861, Unstructured hi_res 0.841, MinerU 0.831, pymupdf4llm 0.732 and MarkItDown 0.589 (opendataloader-bench). OpenDataLoader’s standard mode, without the LLM, scores 0.831, and its site claims “#1 in benchmarks” on the strength of the hybrid mode (OpenDataLoader).

Nutrient’s own run of the same 200 PDFs gives its licence-key tier 0.93, Docling 2.110.0 0.89 and pypdf 0.58. It concedes that “Docling 2.110.0 has the best table structure score among the tools that don’t require a license key” (Nutrient).

On olmOCR-Bench, Chandra OCR 0.1.0 scores 83.1, olmOCR v0.4.0 82.4, PaddleOCR-VL 80.0, Marker 1.10.1 76.1, MinerU 2.5.4 75.2 and the Mistral OCR API 72.0 (olmOCR). RD-TableBench compares Reducto with Azure, Textract, GPT-4o, Google Document AI, Unstructured, Chunkr and LlamaParse, using Levenshtein and Needleman-Wunsch scoring, but the write-up shows the results only as an image and points to a Hugging Face demo for the data, which I didn’t open (RD-TableBench).

Speeds are where the numbers stop lining up, and Docling vs Marker shows it best. Docling is 0.882 at 0.762 seconds a page on the public board and 0.89 at 0.549 seconds in Nutrient’s run.

Marker takes 53.9 seconds a page on the public board, while its README claims 23.6 pages a second in fast mode on a CPU, against 1.4 for Docling on a CPU (Marker). Different modes and hardware explain some of that, but I can’t reconcile it from the public pages.

Vendor READMEs mix test sets too. Unstructured’s compares its open-source library on 1,000+ pages with its hosted Transform product on 224 (Unstructured).

The three ranking pages I read add little. Nutrient ranks itself first; fast.io says it tested “50 PDFs across five categories” with no numbers, and cites a 40% failure figure for multi-column layouts to arXiv “2501.12345”, an ID that looks like a placeholder and that I couldn’t verify (fast.io). Nanonets dates from September 2024, tested one 700-page filing with 10 or 11 questions, and puts itself first (Nanonets).

So I don’t rank on accuracy. The most useful thing to borrow is olmOCR-Bench’s method: small, checkable unit tests per page, which is exactly what the test plan below uses.

A pale wall of diagonal grooved panels meeting a finely perforated panel at a sharp corner, the two patterns running at different angles in soft light
Two surfaces whose patterns don't line up at the seam, much like benchmark scores from different runs that can't be reconciled from the public pages. Photo: Oleg Laptev / Unsplash · Unsplash License

What about PDFs you find during a crawl? #

Let the crawler parse them if they’re ordinary, and download the hard ones for your own parser. Firecrawl’s document parsing handles PDFs “Priced at 1 credit per-page”, with OCR for scanned PDFs (Firecrawl docs).

On Firecrawl’s Standard plan ($99 for 100,000 credits) that’s $0.99 per 1,000 PDF pages, or $3.80 on Hobby ($19 for 5,000), and the free plan gives 1,000 credits a month with no card. Asking for JSON output adds 4 credits a page (Firecrawl pricing, verified 2026-11-16). Plan-by-plan detail is in my Firecrawl pricing breakdown.

The trade-off is control. I couldn’t confirm which parser modes Firecrawl offers for PDFs or its page limit per document, so if your crawl turns up dense financial tables or scanned forms, save the file and send it through whichever parser passed your worst-page test. The rest of the crawl-to-index pipeline, including permissions and refresh, is in web scraping for RAG.

Test each parser on your 20 worst pages #

Twenty pages, five types, three to five facts per page, checked by hand. It costs cents on the hosted free allowances and tells you more about your corpus than any leaderboard.

The worst-page test

  1. Pick 20 pages from your own corpus: 4 scans, 4 complex tables, 4 multi-column pages, 4 with formulas, 4 forms. Swap a type out if you never see it, and add more of the type you see most.
  2. Write the answer key by hand: 3 to 5 checks per page, in the style of olmOCR-Bench’s unit tests, such as “this sentence is present”, “cell B3 equals 4,210”, “paragraph A comes before paragraph B” or “the heading reads X”.
  3. Run each parser on the same 20 pages: Docling locally, plus two hosted options inside their free allowances.
  4. Score each page: facts found, table cells that match, reading order passed, headings kept, seconds per page.
  5. Run a retrieval check: write 1 or 2 questions per page, chunk and index each parser’s output the way you will in production, and see whether the chunk that answers each question comes back.
  6. Decide: the cheapest parser that clears your bar on the worst page class wins that class. Route only that class to the expensive tier.

Copy these columns into a sheet, one row per page per parser:

page_id,worst_class,tool,tier_or_mode,facts_expected,facts_found,table_cells_ok,reading_order_ok,headings_ok,seconds_per_page,usd_per_1k,retrieval_hit,notes

What the hosted half of the test costs (my arithmetic on list prices, verified 2026-11-16):

Option 20 pages costs
LlamaParse Agentic Plus 500 credits (20 × 25), inside the 10,000 free a month
Reducto r-1 $0.20, inside the $150 free usage
Azure Layout or Google Layout Parser $0.20
Textract Tables $0.30
Mistral OCR 4.1 $0.08 ($0.04 on OCR 3)

The retrieval check matters most for RAG. A parser can score well on facts and still split a table across two chunks so that neither one answers the question. If your chunker is part of the pipeline, test the two together.

Use your own pages, and keep them inside your normal data rules: uploading a confidential document to a hosted free tier is still sending it to a third party.

If you’re also picking a scraping API for the HTML side of the pipeline, the same approach (your own pages, a hand-written answer key, a score per page) is in how to test a web scraping API.

Close-up of off-white canvas with a tight, even woven texture and a few tiny brown flecks scattered across it
Seen up close, even a plain surface shows every stray fleck, which is why checking 20 hard pages by hand tells you more than a single summary score. Photo: Annie Spratt / Unsplash · Unsplash License

A decision flow you can follow #

Start at the top and stop at the first line that fits your worst pages.

Which parser, in six steps

  1. Your worst pages have a text layer and a simple layout? Use pypdf (BSD) or pdfminer.six (MIT). Done.
  2. Tables or multi-column layouts matter, and data may leave your servers? Go hosted: Reducto r-1 or LlamaParse Agentic. If you’re already on Azure or Google Cloud, Azure Layout or Google Layout Parser.
  3. Same pages, but data must stay in-house? Docling (MIT) first. Try MinerU or Marker if formulas dominate, after checking their licence thresholds.
  4. Mostly scans? Mistral OCR hosted (OCR 3 at $2 per 1,000 pages, 4.1 at $4), or olmOCR on your own GPU.
  5. Shipping a closed-source product? Avoid PyMuPDF and pymupdf4llm (AGPL) unless you buy Artifex’s licence.
  6. A mixed corpus? Route only the worst class to the expensive tier. LlamaParse’s Cost Optimizer does this inside one vendor, sending simple pages to a cheaper tier.

LlamaParse’s own tier guide maps neatly onto this flow. Fast is for plain text, Cost-effective for simple tables, Agentic for “most real-world PDFs with tables, scanned pages, multi-column layouts”, and Agentic Plus for “the hardest documents” (LlamaParse tiers).

Which PDF parser should you pick for RAG? #

Docling if you can self-host, Mistral OCR 3 for scans outside the big clouds, and Reducto r-1 for hard tables if a hosted API is fine. Here’s how I’d choose by situation, on price, licence and documentation. No independent accuracy data separates the leaders, so the 20-page test is what settles the close calls.

You can self-host and want one default: Docling. MIT-licensed code, OCR, table structure and formulas in one package, and Markdown or JSON output for your chunker (Docling). It also sits near the top of both opendataloader-bench runs, but I’d treat that as a bonus, since parser makers ran both.

Mostly scanned pages and no big-cloud account: Mistral OCR 3 at $2 per 1,000 pages, or OCR 4.1 at $4 if your test shows the newer model is worth double (Mistral pricing). If you already run on Azure, Google Cloud or AWS, their text OCR lists $1.50.

Hard tables and mixed layouts, hosted: Reducto r-1 at $10 per 1,000 pages, with $150 of free usage, which covers 15,000 pages of testing and early use (Reducto). As a LlamaParse alternative, it’s cheaper per page than Agentic, and it offers zero data retention and VPC deployment on its custom plans.

Runner-up for hard pages: LlamaParse Agentic at $15 per 1,000 pages. I’d pick it over Reducto if you want a free allowance that renews (10,000 credits, or 1,000 Agentic pages, every month) or the Cost Optimizer to send easy pages to cheaper tiers (LlamaIndex pricing, tiers).

Born-digital, text-only PDFs: pypdf. It’s BSD-licensed, free and needs no model, and its own docs are honest about what it can’t do (pypdf docs).

Already inside Azure or Google Cloud: Azure Layout or Google Layout Parser at $10 per 1,000 pages, so documents stay inside an account and contract you already have. On AWS, Textract Tables is $15.

PDFs that turn up during a crawl: Firecrawl at 1 credit per PDF page, with the hard ones saved for your main parser.

If I were building this tomorrow, I’d pull my 20 worst pages and run Docling locally, Mistral OCR 3 on the scans, and Reducto r-1 or LlamaParse Agentic on the tables, all inside their free allowances. I’d score facts and table cells by hand, run the retrieval check, and pay for the hosted tier only on the page class Docling failed.

FAQ

Is Docling free for commercial use?

The code is. Docling's repository says 'The Docling codebase is under MIT license', which allows commercial use. The models it uses keep the licences of their original packages, so check those too. One ranking page calls Docling Apache 2.0; the repository says MIT.

Can I use Marker commercially?

The code, yes: since version 2.0 it's Apache 2.0, 'free to use, including commercially'. The model weights are under a modified AI Pubs Open Rail-M licence that's free for research, personal use and startups under $5M in funding or revenue. Above that you need a licence from Datalab. Version 1.x of the code was GPL-3.0.

Is PyMuPDF free for commercial use?

Under the GNU AGPL v3, which its repository describes as free for open-source projects. A closed-source product needs a commercial licence from Artifex. pymupdf4llm, the markdown add-on, is listed as AGPL-3.0 too.

What does LlamaParse cost per page?

It bills credits per page: 1 for Fast, 3 for Cost-effective, 10 for Agentic and 25 for Agentic Plus, plus 3 for layout extraction. Pay-as-you-go includes 10,000 free credits a month, then $1.50 per 1,000 credits, so Agentic works out to $15 per 1,000 pages (my arithmetic, verified November 16, 2026).

What's the cheapest OCR API for scanned PDFs?

Of the ones I priced on November 16, 2026, Azure Read, Google's Enterprise Document OCR and AWS Textract's Detect Document Text all list $1.50 per 1,000 pages. Mistral OCR 3 is $2 per 1,000 and the cheapest I found outside the three big clouds. Mistral OCR 4.1 is $4.

Is there an independent PDF parsing benchmark?

None that I found. olmOCR-Bench is run by AI2, which makes olmOCR; OmniDocBench by OpenDataLab, which makes MinerU; opendataloader-bench by the OpenDataLoader project; OmniParseBench by Datalab, which makes Marker; and RD-TableBench by Reducto. They're open and useful for method, but each was built by a tool maker.

Do I need OCR if my PDFs are digital?

Not for the text: a text-layer extractor such as pypdf reads it directly. But pypdf's own docs say tables are just absolutely positioned text and PDFs carry no information about headers, footers or paragraphs, so tables and multi-column reading order still need a layout parser.

Sources

31 sources, accessed to .

Official pricing, docs, changelogs and status pages 15

  1. pypdf docs: extracting text pypdf.readthedocs.io · accessed
  2. Unstructured docs: partitioning strategies docs.unstructured.io · accessed
  3. OpenDataLoader home page opendataloader.org · accessed
  4. LlamaIndex pricing llamaindex.ai · accessed
  5. LlamaParse docs: credits per page developers.llamaindex.ai · accessed
  6. LlamaParse docs: parsing tiers developers.llamaindex.ai · accessed
  7. Reducto pricing reducto.ai · accessed
  8. Mistral API pricing (OCR 4.1 and OCR 3) docs.mistral.ai · accessed
  9. Mistral OCR 3 model card docs.mistral.ai · accessed
  10. Azure AI Document Intelligence pricing (read via r.jina.ai) azure.microsoft.com · accessed
  11. Azure Retail Prices API: Document Intelligence meters, East US prices.azure.com · accessed
  12. Google Document AI pricing (read via r.jina.ai) cloud.google.com · accessed
  13. Amazon Textract pricing aws.amazon.com · accessed
  14. Firecrawl docs: document parsing docs.firecrawl.dev · accessed
  15. Firecrawl pricing firecrawl.dev · accessed

GitHub code, issues and releases 11

  1. pypdf LICENSE (BSD 3-Clause) github.com · accessed
  2. pdfminer.six repository (MIT) github.com · accessed
  3. PyMuPDF repository (AGPL-3.0 or commercial) github.com · accessed
  4. Docling repository (MIT) github.com · accessed
  5. Marker repository (code and weights licences) github.com · accessed
  6. MinerU repository github.com · accessed
  7. MinerU Open Source License github.com · accessed
  8. Unstructured open-source repository github.com · accessed
  9. olmOCR repository and olmOCR-Bench (AI2) github.com · accessed
  10. opendataloader-bench repository and leaderboard github.com · accessed
  11. OmniDocBench repository (OpenDataLab) github.com · accessed

Independent benchmarks and published studies 1

  1. RD-TableBench (run by Reducto) reducto.ai · accessed

Other blogs 4

  1. Danilchenko: MarkItDown vs Docling vs Marker (independent, small test) danilchenko.dev · accessed
  2. Nutrient: best PDF parsers for RAG (vendor) nutrient.io · accessed
  3. fast.io: best PDF parsing tools for RAG (vendor) fast.io · accessed
  4. Nanonets: best PDF parser for RAG apps (vendor, 2024) nanonets.com · accessed

Last updated: 16 November 2026. Researched and drafted with AI tools; human editorial review and publication approval are pending.

What readers say

Used one of the tools in this guide? Tell other readers how it went. I read every review before it goes up, and I never turn one down for being negative. How reviews work.

No reader reviews yet. Yours could be the first.

Write a review
Your rating

What did you use it for, what worked, and what didn't? 30 to 1500 characters. Please don't include links.

Your connection to the company

Your review appears with the name you enter, after I approve it. I don't ask for your email. Privacy.

  1. Explainer

    How to crawl an entire website for your LLM

    Find every URL, keep the crawl in scope and price it first. Settings and costs for Firecrawl, Apify, Crawl4AI, Cloudflare and Spider, checked Nov 2026.

    14 min read