Nemotron Parse 2.0 vs MinerU: The Unannounced Challenger vs the Open-Source Default

NVIDIA-Nemotron-Parse-2.0 and MinerU solve the same problem from opposite directions. Both take a scanned or rendered page and return clean, structured markdown with tables, formulas, and reading order intact. But MinerU is the open-source default — tens of thousands of GitHub stars, an Apache-2.0 license, and a hosted API with a free daily quota, the safe first choice most document teams reach for. Nemotron Parse 2.0 is the opposite of settled: it appeared on Hugging Face on August 3, 2026, NVIDIA has issued no announcement for it, and its model card carries a set of benchmark claims that would be the biggest thing to happen to open document parsing this year if they hold up. This pairing is deliberately lopsided — incumbent versus unannounced challenger — and the whole question is what each side's pitch is actually worth.

What each side actually is

MinerU is a complete document-parsing system from OpenDataLab, the data group behind Shanghai AI Laboratory's open releases. The current flagship is MinerU 2.5-Pro, a 1.2B vision-language model in the 2604/2605 point-release line (the 2604 model landed in April 2026, with a 2605 refresh after it). It sits on top of a two-stage engine — coarse global layout analysis, then targeted recognition on native-resolution crops — and the project wraps the model in PDF, DOCX, PPTX, and XLSX ingestion, layout detection, formula and table recognition, and reading-order reconstruction. It is the reference open-source parser for RAG preprocessing, and it has the community to prove it.

Nemotron Parse 2.0 is a 0.9B vision-encoder-decoder from NVIDIA in the same family as NVIDIA-Nemotron-Parse-v1.2, which shipped in February 2026. It uses a ViT-H vision encoder built on NVIDIA's C-RADIOv2 backbone and a ten-layer mBART-style decoder. Input pages go up to 2048×1664, generation runs to a 9,000-token ceiling, and it emits the same structured outputs MinerU does: markdown or plain text, plus tables in LaTeX, HTML, markdown, JSON, hierarchical JSON, or CSV, with layout classes, bounding boxes, and reading order. The repo is complete — configs, a Dockerfile, a test suite with golden outputs — but NVIDIA has not promoted it, there is no NIM packaging, and no inference provider hosts it. Self-hosting is the only option today.

The price story: "free" means two different things

The single biggest practical divergence is that MinerU is free to call and Nemotron Parse 2.0 is only free to run. MinerU's official API at mineru.net carries a daily free tier — roughly 1,000 high-priority pages a day depending on the current promotion — with no per-call charge inside it, and files up to 200 pages each. Beyond the quota, jobs get deprioritized rather than billed, and commercial hosts price the self-hosted model around a tenth of a cent per page. If your pipeline needs thousands of pages a day and you don't want to operate anything, MinerU has a path that costs close to nothing.

Nemotron Parse 2.0 has no such path. The weights are free under the NVIDIA Open Model License, but the model card states it is not deployed by any inference provider, and NVIDIA has not priced or announced a hosted option. Using it means renting or owning a GPU, standing up Transformers or a vLLM build with Nemotron Parse remote-code support, and handling the deployment quirks below. For a small-volume project that is a real cost — a GPU is dramatically more expensive than a free API tier at a few hundred pages a month. For a team that already runs GPU infrastructure, the weights being free is a genuine advantage; the question is whether the operational overhead is worth what the model claims to add.

The benchmark gap: these numbers do not face each other

This is the section where most comparisons quietly go wrong, so let's be explicit. Nemotron Parse 2.0's card reports four benchmarks: ParseBench overall at 0.6391 (up from v1.2's 0.5782), MOSCAR multilingual OCR at 0.9102 BoC F1 (up from 0.4410), IndicVisionBench at 0.7203 ANLS-character (up from 0.0612), and an OmniDocBench handwriting subset measured as text-edit distance improving from 0.9739 to 0.3395. MinerU 2.5-Pro reports a different suite: an OmniDocBench v1.6 overall score of 95.69 — state of the art, above much larger models — plus 97.29 on dense formula parsing and a 0.036 text-edit distance on its own OmniDocBench runs.

The two models share the name "OmniDocBench," which makes them look comparable, and then the metrics are not. NVIDIA reports a handwriting-only subset as edit distance; OpenDataLab reports an overall composite on a different benchmark version. ParseBench is NVIDIA's own suite and has no MinerU entry. MOSCAR and IndicVisionBench have no MinerU entry. Every number on both sides is vendor-reported, and neither model has an independent third-party run published that the other appears on. That means there is currently no apples-to-apples figure that ranks Nemotron Parse 2.0 against MinerU — anyone who tells you one model "wins" the benchmark comparison is extrapolating from different tests. What you can say directionally: MinerU's claims are mature and have survived a year of community use, while Nemotron Parse 2.0's claims are fresh, unaudited, and — if its MOSCAR and IndicVision jumps replicate — a big deal for multilingual parsing specifically.

Where they diverge on real workloads

Set the benchmarks aside and the differences that show up in a pipeline are about scope, latency, and multilingual coverage.

• Input scope — MinerU ingests full PDFs up to 200 pages per file through its API and merges cross-page tables; Nemotron Parse 2.0 takes a page image up to 2048×1664 per call, so a 200-page document is 200 requests. If your input is a PDF, that is a workflow difference before any accuracy question.

• Serving maturity — MinerU ships vLLM and SGLang backends with published throughput (about 2 pages per second on a single A100 via its async engine), a Docker runner, and a hosted API. Nemotron Parse 2.0's serving story is young and bumpy: vLLM needs remote-code support and, on A100/A10 hardware, the Triton attention backend; the tokenizer ships a serialized tokenizer.json with baked-in padding to 9,000 tokens, which one serving stack hit as a six-token prompt exploding to 54,000 token IDs; and the repo carries a runtime patch for vLLM builds that do not support its tied output head. None of this is insurmountable, but it is real friction.

• Multilingual — this is where Nemotron Parse 2.0's card is loudest. The 2.0 release expanded the vocabulary from about 52,000 to 72,000 tokens specifically for multilingual OCR, and the claimed gains are concentrated there: MOSCAR up from 0.44 to 0.91, and IndicVisionBench (Bengali, Hindi, Tamil, and seven more Indic scripts) up from 0.06 to 0.72. MinerU supports 109 languages as a headline feature, but its proof is the OmniDocBench composite, not a per-script breakdown. If your corpus is heavy on Indic or low-resource scripts, Nemotron Parse 2.0's numbers are the more interesting claim to test — they are also the least independently verified.

• Handwriting — the single largest delta on NVIDIA's card is handwriting: edit distance on the OmniDocBench notes subset dropping from 0.97 to 0.34. MinerU's own 0.036 text-edit distance is on its overall OmniDocBench runs, not the handwriting subset, so again the numbers don't face each other. But handwritten notes are a classic failure mode for both, and this is the one area where Nemotron Parse 2.0's claimed improvement is big enough to justify a direct test on your own pages.

Who should pick which

Pick MinerU if you want a parser you can call today: a free daily tier, mature serving, full-PDF input, an Apache-2.0 license with no compliance review, and a community large enough that answers to setup questions already exist. It is the default for a reason, and for most RAG preprocessing workloads it is the lower-risk choice.

Pick Nemotron Parse 2.0 if you are already comfortable self-hosting models — particularly if you are on the NVIDIA NIM or NeMo side of the world, since v1.2 is served as a NIM and 2.0 looks like its successor — and if the multilingual or handwriting story is the specific thing your corpus needs. A weekend test on your own Indic or note-heavy pages will tell you more than any benchmark table, because the claims are either going to replicate or collapse under independent data. Just do not plan a production path around an unannounced model until you have run that test and confirmed the tokenizer and serving quirks are handled in your stack.

Why the parser is not the only cost in the pipeline

Whatever you choose, the parser is usually the cheapest stage in a document pipeline once the volume is real. The expensive stage is the LLM that turns parsed markdown into summaries, structured records, or answers — and that is the stage where a routing layer changes the economics. OrcaRouter puts 200+ models behind one API at the provider's list price with no markup, so a vendor price cut is live the same day it is announced, and automatic failover means one degraded provider does not stall the whole extraction job. Concretely: you can test Nemotron Parse 2.0's handwriting claims against MinerU on your own corpus without committing your downstream model stack to either parser, because the parser swap and the LLM layer are decoupled. We do not host either parser today — Nemotron Parse 2.0 is a self-hosted model and MinerU runs on its own service — but a routing layer on the LLM stage is exactly what keeps the parser decision from becoming a lock-in decision.

Bottom line

MinerU is the rational default: mature, free to call at small scale, permissively licensed, and proven in production. Nemotron Parse 2.0 is the interesting bet: a 0.9B NVIDIA model shipped quietly five days ago, whose card claims a dramatic multilingual and handwriting jump that no one has independently verified. If you parse mostly English technical documents at volume, MinerU is the answer and Nemotron Parse 2.0's risk is not worth it. If you parse Indic or low-resource scripts, or handwritten notes, the claims are big enough — and the weights free enough — that running the test yourself is cheap. NVIDIA shipping a new parser roughly every quarter (v1.1 in November 2025, v1.2 in February 2026, 2.0 now) suggests an announcement may land soon; until it does, treat 2.0's numbers as directional and test on your own corpus.

FAQ

Is Nemotron Parse 2.0 available through any API?

Not through a hosted one. The Hugging Face card states the model is not deployed by any inference provider, and NVIDIA has not announced NIM packaging or pricing for it, as of early August 2026. The only way to run it is to self-host the weights via Hugging Face Transformers with trust_remote_code, or via a vLLM build that includes Nemotron Parse remote-code support. MinerU, by contrast, has an official API with a free daily page quota.

Which model is better for RAG preprocessing?

For typical RAG pipelines — English and CJK technical documents, tables, and mixed layouts — MinerU is the safer, more proven choice: it accepts full PDFs, merges cross-page tables, has mature serving, and costs nothing at small scale through its free tier. Nemotron Parse 2.0 only becomes the right call if your corpus is heavy on Indic or low-resource scripts, handwritten notes, or chart-heavy pages where its claimed gains are concentrated — and even then, verify on your own documents before committing.

Do the benchmark numbers on the two model cards compare directly?

No. Nemotron Parse 2.0 reports ParseBench (NVIDIA's own suite), MOSCAR, IndicVisionBench, and an OmniDocBench handwriting subset as edit distance. MinerU 2.5-Pro reports an OmniDocBench v1.6 overall composite plus formula and text-edit metrics. The overlapping benchmark name is not the same metric, no independent run puts both models on the same test, and every figure on both cards is vendor-reported. Treat them as directional, not directly comparable.