Jina-OCR-v1: Faster Document Parsing on Low-Budget GPU

We release jina-ocr-v1, a 3.4B-parameter document parser with about 570M active decoder parameters per token. It scores 91.14 on OmniDocBench v1.6 and 83.4 on olmOCR-Bench, and at 2.57 pages per second it has the highest page throughput of the fourteen systems we measured. On an NVIDIA L4 its speculative decoding head nearly doubles decoding speed while keeping decoding lossless.

The model builds on the compressed-vision encoder and mixture-of-experts decoder of DeepSeek-OCR and adds two things. A FastMTP draft head applies one block recursively for three prediction steps, so draft parameters do not grow with depth. Post-training runs under dense verifiable rewards, where every check is deterministic code against a reference and every check is graded. Against that backbone, post-training adds 7.4 points on olmOCR-Bench and improves every OmniDocBench column.

tagModel and training #

tag

Long outputs are what make document parsing expensive to decode. DeepSeek-OCR removed most of that cost with a compressed vision encoder and a compact mixture-of-experts decoder, and jina-ocr-v1 inherits both and targets the autoregressive bottleneck that remains.

OCR output is near-deterministic and locally structured, which makes it a favorable workload for speculative decoding. The usual construction attaches one draft head per prediction depth, so draft parameters grow with how far ahead the model looks. FastMTP uses a single dense block applied recursively for K = 3 steps. The verifier checks each proposal greedily and accepts the longest prefix on which draft and verifier agree, so the committed sequence equals the greedy sequence of the verifier and speculation changes only how long the output takes.

Model specification. The decoder emits Markdown, with tables in HTML and formulas in LaTeX.

Training data draws on public OCR corpora including olmOCR-mix, FinePDFs, LightOnOCR, MMTab and UniMER, plus deliberately hard sources such as Europeana newspapers, Library of Congress transcripts and NARA pension files. A rule-based filter drops degeneration loops and duplicates, and a vision-language pass relabels the hard sources. We also synthesize pages for one specific reason: on natural pages the formula and table reward terms apply to very few samples, so most rollouts carry no structural signal. JinaOCRSynth packs each page with scorable formulas and tables and ships unit tests with it.

Post-training runs supervised alignment, robustness fine-tuning on degraded pages, and GRPO, repeated across the rounds of an outer loop. The GRPO reward is a product of verifiable terms, each computed by deterministic code against a reference transcription.

Multiplicative reward composition. Most terms carry a floor, since under a product one failed check would remove the gradient from an otherwise correct page. The repetition term has none, because degenerate loops are the failure mode that most readily inflates the content score.

Each round leaves a pool of candidate checkpoints. An agent searches merge configurations under a fixed evaluation budget and scores them with unit-test and edit-distance checks, and errors in the selected merge drive the next round of collection. The draft head is fitted last, on the verifier the loop selects.

tagResults #

tag

olmOCR-Bench. jina-ocr-v1 reaches 83.4 overall, 7.4 points above the DeepSeek-OCR backbone it post-trains and ahead of the 8B olmOCR-2. The Hdr/Ftr column tests text absence and rewards omitting headers and footers, so faithful full-page transcription scores low there.

OmniDocBench v1.6. jina-ocr-v1 reaches 91.14 at 570M active parameters, ahead of DeepSeek-OCR-2 on every column and ahead of the much larger Qwen3-VL-235B.

tagSpeculative decoding on an L4

tag

FastMTP on olmOCR-Bench, NVIDIA L4, vLLM 0.20.1, batch size 1. τ is the mean number of tokens committed per speculative step including the bonus token, and c = τ/S is the cost of one speculative step in units of one autoregressive step. Measured on a different device from the figures above.

Draft quality does not depend on the execution mode, since τ is 2.73 in eager mode and 2.74 under CUDA graphs at k = 3. The baseline does. CUDA graphs raise autoregressive decoding from 42.7 to 158.3 tokens per second while the overhead of a speculative step stays near 9 ms, so its cost rises from 1.40 to 2.51 autoregressive steps. The gain tracks the cost of the verifier step it replaces, which puts the best depth at k = 3 in eager mode and k = 1 under graphs.

tagGetting started #

tag

The quickest way to run it is Jina Reader. Point r.jina.ai at a URL and add one header: Reader fetches the page or PDF, renders it, runs jina-ocr-v1 over the result and hands back Markdown. Nothing to deploy, no image plumbing to write, and the same API key as the rest of the platform.

curl "https://r.jina.ai/https://example.com/document.pdf" \
  -H "Authorization: Bearer $JINA_API_KEY" \
  -H "X-Respond-With: jina-ocr-v1"

Add X-Page to transcribe one page of a multi-page document. Both parameters are in the Reader API editor, where the toggle writes the header for you.

For direct access to the model, the hosted endpoint is OpenAI-compatible and needs only an API key from jina.ai.

curl https://api.jina.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ***" \
  -d '{
    "model": "jina-ocr-v1",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "Transcribe the provided document image into a clean Markdown format, preserving the natural reading order."},
        {"type": "image_url", "image_url": {"url": "https://example.com/document.png"}}
      ]
    }]
  }'

To serve it yourself, the weights and the custom modeling code ship in one Hugging Face repository loaded with trust_remote_code=True. FastMTP needs vLLM 0.21 or later and a one-time architecture registration before the engine starts.

import sys
from huggingface_hub import snapshot_download
from PIL import Image
from vllm import LLM

sys.path.insert(0, snapshot_download('jinaai/jina-ocr-v1'))
from deepseek_ocr_mtp import DEFAULT_OCR_PROMPT, register, vllm_llm_kwargs, vllm_sampling_params

register()
llm = LLM(**vllm_llm_kwargs('jinaai/jina-ocr-v1',
                            num_speculative_tokens=3,
                            mtp_heads=1,
                            mtp_recursive=True))

image = Image.open('document.png').convert('RGB')
outputs = llm.chat(
    [{'role': 'user', 'content': [{'type': 'image_pil', 'image_pil': image},
                                  {'type': 'text', 'text': DEFAULT_OCR_PROMPT}]}],
    sampling_params=vllm_sampling_params(max_tokens=4096),
)
print(outputs[0].outputs[0].text)

One detail decides whether the speedup appears. The helper registers the head with method="eagle", since FastMTP is trained with recursive hidden-state feedback and the default method="mtp" re-grounds every draft step on the target. The Transformers path runs the MoE decoder alone and ignores the MTP weights.

The model also handles element-level transcription of tables and formulas, captioning, document VQA and key-information extraction, in English and Chinese. Weights are released under CC BY-NC 4.0.

tagConclusion #

tag

At 570M active parameters jina-ocr-v1 lies on the accuracy-per-parameter frontier of both benchmarks and has the highest page throughput of the systems we measured. Two levers do that work and neither needs a larger model: a graded reward on every verifiable check, and a draft head trained against the final verifier.

Output length is worth a closer look. Token throughput and page throughput rank systems differently, and output length is independent of parsing quality, so conciseness can be optimized on its own. jina-ocr-v1 has the shortest outputs of any system scoring above 83.