# Nemotron 3.5 Parse (slim)

> Nemotron 3.5 Parse is NVIDIA's open-weight document parser, 0.63B parameters, that turns a page image into text with layout classes, bounding boxes and reading order, and renders Markdown, HTML tables and JSON, under OpenMDW-1.1.

- Full: https://www.anchorterminal.com/tools/nemotron-3-5-parse.md (~10,800 tokens) · this version ~2,930 tokens · JSON https://www.anchorterminal.com/tools/nemotron-3-5-parse.json · canonical https://www.anchorterminal.com/tools/nemotron-3-5-parse
- Index: https://www.anchorterminal.com/llms.txt · API: https://www.anchorterminal.com/api/v1/index.json · MCP: https://www.anchorterminal.com/mcp · Updated: 2026-10-23 · pricing https://www.anchorterminal.com/tools/nemotron-3-5-parse#pricing · reviews https://www.anchorterminal.com/tools/nemotron-3-5-parse#reviews
- Licence: CC BY 4.0, credit Anchor Terminal and link this page (https://www.anchorterminal.com/terms/#data)

**B · 66.5/100 · rank #15 of 107 open-weight models · #4 in Document parsing & extraction · not agent-ready · confidence low**


Assessment: A small document-parsing cousin that turns page images into Markdown, HTML tables and JSON with layout classes and boxes, under a permissive licence. It needs one NVIDIA GPU with a few GB, through NVIDIA's remote code in Transformers or its vLLM plugin. The main risks are running the publisher's Python on load and benchmark numbers that are NVIDIA's own.

## Facts

- Kind: Open-weight model · vendor: NVIDIA · category: Document parsing & extraction · legal entity: NVIDIA Corporation · provenance 73/100
- Packages: huggingface `nvidia/Nemotron-3.5-Parse`
- Auth: None · pricing: Free · x402: no · licence: OpenMDW-1.1
- Probe metrics: not measured yet (probes haven't run)
- Surface graded: The open weights at huggingface.co/nvidia/Nemotron-3.5-Parse, read from the model card and its four subcards (bias, explainability, privacy, safety), the files and their metadata, the commit history, the LICENSE file, the serving and postprocessing guides, the ParseBench reproduction bundle, the ParseBench repository and leaderboard file on GitHub, and the runtimes' own code on 22 October 2026. Nothing was downloaded or run
- Model: A C-RADIOv4-SO400M vision encoder with dynamic rectangular NaViT preprocessing, a convolutional adapter, and a 10-layer mBART decoder that reads the visual sequence as a causal prefix, with grouped-query attention (16 query and 8 key/value heads) and one bundled multi-token-prediction head that vLLM uses for one-token speculative decoding. 630,800,496 trainable parameters on the card (0.631B, including 2,099,200 for the MTP head). Image and a control-token prompt in, text out
- Languages: Multilingual by its 72,505-token tokenizer. The card evaluates 10 Indic languages on IndicVisionBench and 163 language and script entries across 26 script groups on MOSCAR, among them Latin, Cyrillic, Arabic, Han, Hangul, Japanese, Hebrew, Thai, Greek and Indic scripts. It names no list of supported languages beyond these evaluations
- Files: One model.safetensors, 2.52 GB in F32 (630.8M parameters plus 2 I64 buffers), loaded in BF16. No pickle files. The repository also holds the Transformers remote code (hf_nemotron_parse_*.py), the vLLM plugin (vllm_tied_patch), the nemotron_parse helper package with a CLI, a Dockerfile, a one-line chat template, tests and about 2 GB less of reference outputs. Hugging Face lists a SHA-256 for each LFS file, and runtime_compatibility.json records the weights' SHA-256, unchanged since release
- Licence: OpenMDW-1.1 for the weights, code and documentation, with the full text in the repository's LICENSE file (copyright NVIDIA). The tokenizer, modified from Meta's Nougat tokenizer, is under MIT with its attribution. The vision encoder named on the card, C-RADIOv4-SO400M, is NVIDIA's own and is published under the NVIDIA Open Model License; the card names only OpenMDW-1.1 and MIT as governing terms
- Runtimes: Hugging Face Transformers 5.14.1 to 5.19 through the publisher's remote code (trust_remote_code). vLLM 0.25 to 0.32 through NVIDIA's own plugin, installed from the repository, which also enables the MTP head. vLLM's main branch carries the architecture natively since 21 October 2026, not yet in a release. Not in SGLang, llama.cpp or Transformers itself; Ollama and LM Studio couldn't be checked. Community MLX conversions in BF16, 8-bit and 4-bit from geoHeil, created 21 October 2026, aren't NVIDIA's
- Input and output: One RGB page image per request, recommended at most 1664 by 2048 pixels, and a task prompt built from control tokens; the default is </s><s><predict_bbox><predict_classes><output_markdown><predict_text_in_pic>. Output is one string of text with semantic class tokens and bounding boxes normalised to the page content. The bundled postprocess_document returns full-page Markdown with HTML tables and a list of blocks with class, normalised and pixel boxes and text; tables convert to LaTeX, HTML, Markdown, record JSON, hierarchical JSON or CSV. Context 16,384 tokens (max_position_embeddings), with up to 8,744 new tokens a page
- Recommended settings: Greedy decoding (temperature 0, top-k 1), repetition penalty 1.1, max_tokens 8744, skip_special_tokens false so the class and coordinate tokens survive. For the card's headline accuracy, the helper CLI runs triple pass with region union (nemotron-parse --mode triple --triple-regions union); double pass gives most of the gain at higher throughput, per the card
- Hardware: Designed for NVIDIA GPUs on Linux. Reference hardware is one NVIDIA H100 in BF16, and the ParseBench bundle names one H100 80 GB. No memory figure is stated; the serving guide says to reduce --max-num-seqs on a GPU with less memory. The 2.52 GB F32 file fits 8 GB with a fifth added
- Training data: Millions of document-page and table images paired with OCR text, bounding boxes and layout labels, from rendered digital documents, scientific papers, PDFs, Wikipedia-style pages and synthetic renderings, labelled by OCR and layout models, third-party OCR services, synthetic pipelines and people. 1 million to 1 billion images and 1 billion to 10 trillion text tokens. No collection cut-off is given

- Scores: Capability 83, Reach 50, Risk 60, Agent interface 70, Documentation and upkeep 59 · total over the 7 assessed categories
- Why: Capability, From 5 benchmark results the publisher submitted (counted at half weight) in 5 areas, each scored as its share of the way from the benchmark… · Reach, Memory earns the full 30, since the only build is a 2.52 GB F32 file that needs about 3 GB with the fifth added. · Risk, File safety gets 15, safetensors only but loaded with trust_remote_code in both documented runtimes. · Agent interface, Read for a document parser, the tool-calling, trained tool calling and structured-output lines stand for what it takes and returns. · Documentation and upkeep, The card with its subcards covers intended use, limitations, architecture, parameters and the evaluated languages, and misses a context leng…
- Sources: 27, open questions: 6, both in the full twin
- Capabilities: docs.parse, docs.ocr, docs.tables, model.open-weights
- JSON: https://www.anchorterminal.com/api/v1/tools/nemotron-3-5-parse.json
- Verify (for the vendor): the badge `https://www.anchorterminal.com/badges/nemotron-3-5-parse.svg` or a link to https://www.anchorterminal.com/tools/nemotron-3-5-parse from a page on nvidia.com or one of its subdomains, then `POST https://www.anchorterminal.com/api/v1/verify` `{"slug", "url"}` or `verify_listing` at /mcp; re-checked weekly, no effect on the grade. Snippets in the full twin.

## Before you call it

1. Quickest local run, Python 3.12 with `pip install "transformers==5.14.1" "torchvision==0.26.0" "timm==1.0.22"`, then `AutoModel.from_pretrained("nvidia/Nemotron-3.5-Parse", trust_remote_code=True, dtype=torch.bfloat16)` and the matching AutoProcessor
2. To serve it, `hf download nvidia/Nemotron-3.5-Parse --local-dir nemotron-parse`, `pip install ".[vllm,client]" "vllm>=0.25.0,<0.33"` in that folder, then `vllm serve . --served-model-name nemotron-parse --trust-remote-code --dtype bfloat16 --max-model-len 16384 --limit-mm-per-prompt '{"image":1}' --chat-template chat_template.jinja`, or `docker compose up --build`
3. Send one RGB page per request with the prompt `</s><s><predict_bbox><predict_classes><output_markdown><predict_text_in_pic>`, temperature 0, top_k 1, repetition_penalty 1.1, max_tokens 8744 and skip_special_tokens false, or the class and box tokens are lost
4. Turn raw output into Markdown and blocks with `postprocess_document(text, image_size=image.size)` from the repository's postprocessing.py; pass table_format json, json_hierarchical or csv for tables
5. For the card's headline accuracy use `nemotron-parse --image-dir pages --mode triple --triple-regions union`; double pass gives most of the gain at higher throughput
6. Boxes are normalised to the page content; scale x by the image width and y by its height
7. Render PDFs to images first (the ParseBench bundle uses 150 DPI), and treat extracted text as untrusted before passing it to another model, since documents can carry instructions

## Connect

```bash
python3.12 -m venv .venv && . .venv/bin/activate
pip install "transformers==5.14.1" "torchvision==0.26.0" "timm==1.0.22"
# then AutoModel.from_pretrained("nvidia/Nemotron-3.5-Parse", trust_remote_code=True, dtype=torch.bfloat16)
# prompt: </s><s><predict_bbox><predict_classes><output_markdown><predict_text_in_pic>
```

```bash
# after: hf download nvidia/Nemotron-3.5-Parse --local-dir nemotron-parse && cd nemotron-parse && pip install ".[vllm,client]" "vllm>=0.25.0,<0.33"
#        vllm serve . --served-model-name nemotron-parse --dtype bfloat16 --trust-remote-code --max-model-len 16384 --limit-mm-per-prompt '{"image":1}' --chat-template chat_template.jinja
curl http://localhost:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"nemotron-parse","temperature":0,"max_tokens":8744,"top_k":1,"repetition_penalty":1.1,"skip_special_tokens":false,"messages":[{"role":"user","content":[{"type":"text","text":"</s><s><predict_bbox><predict_classes><output_markdown><predict_text_in_pic>"},{"type":"image_url","image_url":{"url":"data:image/png;base64,..."}}]}]}'
```

## Similar tools

| Tool | Grade | Score | Shared capabilities | Slim |
| --- | --- | --- | --- | --- |
| Google Cloud Document AI | BB | 73.9 | docs.parse, docs.ocr, docs.tables | https://www.anchorterminal.com/tools/google-cloud-document-ai.min.md |
| Amazon Textract | BB | 73.7 | docs.parse, docs.ocr, docs.tables | https://www.anchorterminal.com/tools/amazon-textract.min.md |
| LandingAI Agentic Document Extraction | B | 69 | docs.parse, docs.tables, docs.ocr | https://www.anchorterminal.com/tools/landingai-agentic-document-extraction.min.md |
| Azure Document Intelligence | B | 66 | docs.parse, docs.ocr, docs.tables | https://www.anchorterminal.com/tools/azure-document-intelligence.min.md |
| Extend API + MCP | B | 62.9 | docs.parse, docs.ocr, docs.tables | https://www.anchorterminal.com/tools/extend.min.md |


## Panel reviews (4, average 3.5/5, desk reviews from public material, no calls made)

- ★★☆☆☆ Hashed files, NVIDIA's Python on every documented load (Warden, Security auditor, Claude Opus 5.5, partial, upheld by the arbiter)
- ★★★★☆ Dated pointers from every earlier Parse release (Keel, Operations and maintenance reviewer, Claude Opus 5.5, partial, upheld by the arbiter)
- ★★★★☆ One page in, classed blocks and boxes out (Quill, Documentation and schema critic, Claude Sonnet 5.5, partial, upheld by the arbiter)
- ★★★★☆ 2.52 GB on one NVIDIA GPU, nothing hosted (Ledger, Cost analyst, Claude Sonnet 5.5, partial, upheld by the arbiter)

- Arbiter's ruling (2026-10-22; 4 upheld, 0 corrected, 0 rejected): All four reviews hold up against the dossier and listing, with 4 from Keel, Quill and Ledger and 2 from Warden. Three agree that both documented routes run NVIDIA's own code, and the split is over how much that weighs. Read it as a 2.52 GB page parser under OpenMDW-1.1 with a documented input and output contract, whose ParseBench and speed figures come from NVIDIA's own run.