Open-weight OCR models now read 1,000 pages for under ten cents on a rented GPU, according to a new benchmark by Hugging Face's Daniel van Strien. The newest model he tested, LightOnOCR-3-0.8B, cost $0.095 per 1,000 pages. An April 2025 model cost $0.51. A million pages comes to roughly $65 to $130 of GPU time, depending on the kind of page.
The headline is "five times cheaper in 18 months." The detail is more useful than the headline: how you run a model saved about as much money as which model you pick, and "five times" holds for one pair of models at one image size. This post walks through the setup, the numbers, the failure modes van Strien documented, and how to test your own pages. The primary source is his post, OCR with open models got about 5x cheaper in 18 months. The Decoder summarized it the same day.
TL;DR: the numbers readers ask for
| Question | Answer from the source |
|---|---|
| Cheapest model tested | LightOnOCR-3-0.8B (October 2026), $0.095 per 1,000 pages |
| Oldest model tested | RolmOCR (April 2025), $0.51 per 1,000 pages |
| Middle five models | $0.23 to $0.28 per 1,000 pages, too close to rank |
| A million pages | About $65 to $130 of GPU time, roughly a day and a half on one rented GPU for a mixed set |
| Test pages | 850 pages: 350 natural history book pages, 250 from the 1771 Britannica, 250 typed archive pages |
| Hardware | One Nvidia RTX PRO 6000 on Hugging Face Jobs at $2.75 per hour |
| Cost of the whole comparison | About $6 for all eight models on all 850 pages |
| Scope warning | These are compute costs only; staff time, pipelines and quality checks remain |
What did the test actually do?
Van Strien ran eight open OCR models, released between April 2025 and October 2026, on the same 850 pages, on the same GPU, served the same way. Every model ran behind a vLLM server, with the same client sending many pages at once. Each page was first fitted to 2,048 pixels on its longest side, though some models shrink it further by their own rule.
The models, from his appendix: RolmOCR (April 2025), dots.ocr (July 2025), olmOCR-2 in FP8 (October 2025), PaddleOCR-VL (October 2025), DeepSeek-OCR (October 2025), GLM-OCR (January 2026), OvisOCR2 (July 2026) and LightOnOCR-3-0.8B (October 2026). The release date is the date each model's Hub repository was created.
Three models ran outside their usual pipeline. Two are built to run after a layout-detection step, which he left out. One used a plain-text prompt in place of its default. That matters for fairness, and he says so.
The cost curve: two steps and a plateau
The shape is not a smooth decline. The two earliest models cost $0.45 to $0.51 per 1,000 pages. Five models from October 2025 to July 2026 sit between $0.23 and $0.28. Then one model from October 2026 comes in at $0.095. The author says a fitted trend halves cost about every ten months, but he would not bet on it.
A price tag with a downward arrow, showing falling open OCR model cost per 1,000 pages
For context, we covered the winner when it launched: LightOnOCR-3 and ParseBench looked at the model's quality claims. This new test adds the cost side on a common GPU.
Where the savings really came from
This is the most useful part of the post. Van Strien took one model, GLM-OCR from January 2026, and one kind of page, the 1771 Britannica. Run the way he ran it in February, it cost $1.57 per 1,000 pages. Then he changed how it runs:
- A vLLM server kept fed with many pages at once, instead of a script sending fixed batches of 64.
- A larger GPU: an RTX PRO 6000 instead of an L4.
- Page images fitted to 2,048 pixels.
- A newer vLLM release.
That brought the same model to $0.40. Swapping in LightOnOCR-3-0.8B, smaller and faster, brought it to $0.13. In his words, "I got less stupid": his February script left the GPU idle about a quarter of the time.
From partial tests, he puts the way pages are sent, the image size and the engine together at about 2.5 times, and the bigger GPU at about 1.5 times. He could not separate them cleanly. He also found that running three models on today's vLLM was 1.2 to 1.5 times faster for the two 2025 models than on the release current when they came out.
The practical lesson: before you evaluate a new OCR model, check your serving. A busy server, fitted images and current software may give you most of the gain. Our guide to vision token budgets and context windows covers the image-size side of that tradeoff.
Did cheaper models read worse?
On ordinary pages, hardly. The numbers:
- On the 282 book pages with human-checked transcriptions, median error rates run from 0.44% to 0.82%, scored with the text rules from
bhl-ocr-eval, the code behind the BHL OCR leaderboard. - The newest model makes no more errors than the April 2025 one on those pages.
- A vision-model judge preferred the newest model on book pages: 35 pages against 7. On typed pages it was 18 against 9, with 22 too close to call.
- On dense two-column 18th-century print, the April 2025 model was preferred over every later model except the newest, which about ties: 18 pages against 19. Several models read the long s as an f.
Two cheaper models make about one and a half times as many errors on book pages as the April 2025 model, and he measured twice with no change. So "cheaper" is not uniformly "as good."
The judge itself was imperfect. It changed its verdict with the order of display on between one page in ten and one in five, and agreed least with other raters on typed pages. Van Strien checked eight pairs blind himself and had four other AI models rate 40 pairs, then trusted verdicts where two raters agreed.
How the models fail
A lens revealing a missing support under an arch, an image for OCR models inventing text on blank pages
The failure section is worth reading before you deploy:
- Blank pages. Of 350 book pages, 63 are blank. Three models correctly return nothing. GLM-OCR, run without its layout step, writes a sentence about the image on all 63, usually that it is too blurry to read. OvisOCR2 answered 24 blank pages with "The quick brown fox". RolmOCR writes made-up tables on most blank pages and, on almost half, repeats an empty table until it hits its output limit.
- Dense forms. On a tax form full of dot leaders, four of the eight models looped in each run, and not the same four both times. The newest model was one of them. No model finished the page cleanly in both runs, and most finished readings had mistakes such as ticking an empty box.
- Damaged text. On a typed page with a black blotch over the last lines, three models each invented a different final entry, in both runs. Nothing in the output shows that they guessed.
- Output limits. The share of pages hitting the output limit ranged from under 1% to 26%, highest for models run outside their usual pipeline.
For anyone building document pipelines, the lesson is to filter blank pages first, set sensible output limits and sample outputs for loops. Treat OCR as extraction that needs checks, not as ground truth. If you need structured fields rather than plain text, see our coverage of Interfaze-1 Lite's deterministic extraction.
Can I run it on a small GPU?
Yes, with caveats. The newest model ran on a 16 GB T4 at $0.40 an hour for roughly $0.25 to $0.41 per 1,000 pages. On a 24 GB GPU the April 2025 model loads, but its weights leave room for only a handful of pages at a time, and it cost about $2.10 to $2.80 per 1,000 pages for two page types, with the third timing out. The author notes the lowest cost per page is still on the big GPU, and the small-GPU figures come from short single runs.
If CPU-only is your constraint, our post on Indra OCR's 1M-parameter CPU model covers a very different tradeoff.
The caveats the author states
Van Strien lists these limits himself, and they matter for how you quote the result:
| Caveat | What it means |
|---|---|
| "About five times" compares one pair at one image size | At 1,288 pixels, the April 2025 model nearly halves in cost, so the gap shrinks to about three times |
| Each model measured twice | Differences under about a quarter are not meaningful for all-pages cost; for a single page type the bar is nearer a half |
| The 2,048-pixel rule is the newest model's own | His harness grew out of that model's recipe; others might do better with tuned settings |
| Newer models are also smaller | "Newer" and "smaller" cannot be separated |
| Accuracy comes from 282 book pages | Other pages rely on a vision-model judge with known biases |
| Prices are today's Hugging Face Jobs prices | They exclude the few minutes each job takes to start |
He also repeats, from an earlier update, that all figures are compute cost only. Staff time, pipeline building and quality checking remain the real costs of a re-OCR programme.
How to test your own pages
His advice is the same as in February and now cheaper to follow: run a few models on a sample of your own pages and look. A repeatable recipe:
- Pull 50 representative pages, including blanks, tables, forms and your worst scans.
- Run two or three models behind one vLLM server, with images fitted to about 2,048 pixels on the long side.
- Record cost per 1,000 pages and the share of pages that hit the output limit or return empty or looping text.
- Check a hand-transcribed subset for character error rate on a text type you care about.
- Only then pick a model. For book and typed pages, the author suggests starting with LightOnOCR-3-0.8B. For dense historical print, test it against RolmOCR.
His earlier re-OCR guide shows the Hugging Face Jobs and uv workflow, and it noted commercial OCR APIs typically charge $0.01 to $0.05 per page. That is $10 to $50 per 1,000 pages, against $0.095 here, though the comparison ignores quality, support and layout formats such as ALTO XML that library workflows often need.
What people are asking
Is this cost comparable to cloud OCR APIs? The author's earlier guide cites $0.01 to $0.05 per page for commercial APIs. His GPU figure excludes staff time, pipelines and checks, so a like-for-like decision needs your own totals.
Does it handle handwriting or complex tables? The test covered printed books, 18th-century print and typed documents. Handwriting and tables were not the focus, and forms with dot leaders caused loops in four of eight models.
Will costs keep halving? The fitted trend halves cost about every ten months, but the author says he would not bet on it. The curve looks like two steps with a plateau, not a line.
What should builders change first? Check serving. A busy server and fitted image sizes drove the biggest saving he measured.
Bottom line
The verified result is narrow and still striking: on one GPU and 850 pages, a 0.8B open model read ordinary pages for under ten cents per 1,000 and matched or beat an April 2025 model there. The claim to repeat carefully is "about five times," which depends on image size, and the bigger lesson is that serving discipline was worth about as much as model choice. For anyone digitizing archives, contracts or books, test your own pages, add checks for blanks and loops, and budget for people, not GPUs.
Figures are as published by Daniel van Strien on November 18, 2026 and may change as he updates the post.
Related reading
- LightOnOCR-3 and ParseBench: an open-weight OCR model
- Indra OCR: a 1M-parameter CPU model at 49 pages per second
- Interfaze-1 Lite: deterministic OCR and extraction
- Vision token budgets and context windows
- Southampton AI reads 100,000 pages of port books
- Sources: van Strien's cost post, his re-OCR guide, The Decoder summary
