Nemotron 3.5 Parse

Nemotron 3.5 Parse

Reads page images of scans, PDFs, slides and forms and returns their text, tables, chart data, reading order and boxes as Markdown, HTML or JSON. A 631M-parameter model by NVIDIA for developers.

Made by nvidia on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Nemotron 3.5 Parse is a 631M-parameter model from NVIDIA that turns an image of a document page into structured data. From one page image it gives back the text, the tables, the numbers behind charts, the order to read in, a label for each region and a box around each one. You can export the result as Markdown, HTML or structured JSON.

Who it suits: Developers who build document pipelines and need page images turned into data that code can use.

Industry | Who uses it | How they use it | Example
Document processing | Pipeline developers | Convert scans and PDFs into structured data | A scanned report turned into Markdown
Finance and business | Analysts and data teams | Pull tables and chart data from reports | A table from a report page as structured output
Administration | Back-office teams | Read forms and mixed layouts | A filled form read into fields
Presentations | Content teams | Read slides as text and layout | A slide's text in reading order

If you only need to read one document by eye, or you have no GPU, you can skip it.

Where to use it:

• Python with the transformers library, on a machine with a CUDA GPU as in the card's example
• A vLLM server, which the card describes for faster generation
• NVIDIA Build API and Baseten, which the card lists as hosted options

Use case | Who | What they get back
Scans and PDFs | Developers | Text, tables and reading order from each page
Charts in reports | Analysts | Chart data pulled out of page images
Page layout | Pipeline builders | Bounding boxes and semantic classes for each region

How to set it up:

• Python, ideally in a fresh virtual environment
• The transformers, torchvision and timm packages
• A CUDA GPU for the card's transformers example
• About 2.5 GB of disk space in F32, or about 315 MB at 4-bit (an estimate)

1. Create and activate a fresh Python environment.
2. Install the packages.
3. Run the Python example with a page image saved as page.png.

python -m venv .venv
source .venv/bin/activate
python -m pip install transformers torchvision timm

You can also fetch the files on their own with the Hugging Face tools.

pip install -U huggingface_hub
hf download nvidia/Nemotron-3.5-Parse

How to use it: Run the example on a page image. It loads the model, sends one page with a task prompt and prints the raw output. Keep the control tokens in that raw output, because later postprocessing needs them.

import torch
from PIL import Image
from transformers import AutoModel, AutoProcessor, GenerationConfig

MODEL = "nvidia/Nemotron-3.5-Parse"
TASK_PROMPT = "</s><s><predict_bbox><predict_classes><output_markdown><predict_text_in_pic>"

model = AutoModel.from_pretrained(
    MODEL, trust_remote_code=True, dtype=torch.bfloat16,
).to("cuda").eval()
processor = AutoProcessor.from_pretrained(MODEL, trust_remote_code=True)
image = Image.open("page.png").convert("RGB")
inputs = processor(
    images=[image], text=TASK_PROMPT,
    return_tensors="pt", add_special_tokens=False,
).to("cuda")
generation = GenerationConfig.from_pretrained(MODEL)
generation.max_new_tokens = 8744

with torch.inference_mode():
    output_ids = model.generate(**inputs, generation_config=generation)
raw_output = processor.batch_decode(output_ids, skip_special_tokens=False)[0]
print(raw_output)

Tool | What it does
Text extraction | Reads the text on the page image
Tables | Returns table content
Chart data | Pulls data out of charts
Reading order | Orders the page's content as a person would read it
Semantic classes | Labels each region of the page
Bounding boxes | Gives the position of each region

Example: You save a scanned report page as page.png and run the script above. The model prints raw output holding the page's text, its tables and the boxes around each region, which postprocessing turns into Markdown or JSON.

For newcomers and experts: If you are new to this, try the NVIDIA Build API the card lists before you set up a GPU. Upload one clear page and look at the Markdown that comes back.

It has 631M parameters. A smaller optional helper model of 89.3M parameters, named DFlash2, can speed up generation when you serve it with vLLM. On ParseBench with triple-pass parsing, the card gives it 75.20 and calls that the top score among the systems it compared. It also lists evaluation across 163 language and script entries. Those figures are NVIDIA's own.

Save the document page as an image
Send it with a task prompt
The model returns text, tables and boxes
Postprocess into Markdown, HTML or JSON

Good to know:

• Hardware: the transformers example moves the model to a CUDA GPU
• Benchmarks: the figures come from NVIDIA's own comparison, so check them on your own pages
• Input: it reads page images, so a PDF needs rendering to images first
• License: openmdw-1.1
• Cost to run: no key is needed for the local example, and the hosted NVIDIA Build API and Baseten options are named without prices
• Data it reaches: the local example reads the image file you give it, while a hosted option sends your page images to that service
• Not for: reading documents you are not allowed to process, since pages may hold private data

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 631M
• Weights: about 2.5 GB in F32; about 315 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 23,202
• Likes: 161
• License: openmdw-1.1
• Quantized versions: 8
• Fine-tunes: 6
• Tags: transformers, safetensors, nemotron_parse, text-generation, parse, image-text-to-text, conversational

Links

• Model: https://huggingface.co/nvidia/Nemotron-3.5-Parse
• Files: https://huggingface.co/nvidia/Nemotron-3.5-Parse/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download nvidia/Nemotron-3.5-Parse

Then follow the usage in its model card. Nothing in this kit runs by itself.