IronStratum

VLM vs OCR API: how to choose, document class by document class

Neither path wins this question outright. A traditional OCR API reads exactly what is printed, bills a fixed rate per page, and tops the tables on clean machine-printed forms. A VLM reads layouts and tables that zoning engines break on, and it can also invent text that is not on the page. The deciding variable is the page class in front of you, not the vendor.

Every number below names its owner and its date. Benchmark rows come from the OmniDocBench repository, read 28 October 2026, plus the PP-OCRv6 official documentation and the marker project's own table, read the same day. Vendor-run comparisons carry the vendor label. A cell with no proof stays a dash. Rates for other firms appear as relations against this platform's rates, never as numbers, with source and date named. The pages ranking for this query argue one side or sell one pipeline. This page prices the choice instead.

Last verified: 2026-10-28

The query is a buyer mid-decision

Search completions for "vlm ocr" open a whole evaluation band: leaderboard, models, benchmark, prompt, dataset, state of the art. That capture is dated 26 October 2026. A second band, "gpt 4o ocr", runs toward pricing and page-to-markdown tails. Google attaches four questions to the topic, among them "What is Vision-Language Model Document Parsing?" and "Which LLM is best for OCR?". A re-run of the head query on 28 October 2026 returned the same field: two migration stories, a hybrid-pipeline pitch, an object-detection explainer, and a demo directory. Three demand signals, one message. The market is choosing. The ranking pages are advocacy.

None of them hands you a table keyed on the pages you actually hold. That is the job here. Name your dominant page class first. Then read the row.

Four paths hide inside two labels

The labels blur different purchases. Splitting them is half the choice.

The OCR API is a pipeline. A detection step finds text zones. A reading step reads each zone. Layout rules or zoning assemble the output. Classic engines like Tesseract work this way. So do the compact detect-and-read families behind most per-page OCR APIs, including the engine behind this platform's print lane. The output is raw text or simple structure. The behavior is fixed: the same page returns the same text, run after run.

The small parser VLM is a vision-language model under about 4 billion parameters, trained only to parse pages. It reads layout, tables, formulas, and reading order in one pass and writes Markdown or JSON. This class now tops the open boards. It is also what most modern "OCR API" products quietly are, including this platform's archival lane.

The frontier chat model is a large VLM from the families built for general questions. It parses pages on request, answers questions about them, and pulls fields by prompt. It is the most flexible path and the dearest per page. It also draws the loudest reports of invented text.

The hybrid runs a cheap first pass and routes the hard remainder. An engine reads the bulk pages. A confidence check or a page classifier flags the rest. A VLM reads only those. Most volume pipelines end here.

The decision table

Read the row that matches your dominant pages. The cells name their evidence. Dashes mark what nobody has measured.

Page classOCR API pathVLM pathThe call
Clean printed forms, born-digital print, invoices at volumeWins the vendor tables: a 34.5M-parameter engine outscores frontier models on printed text by wide marginsOverspend: the skill is unused, and VLM rates sit above engine ratesOCR API, engine class
Handwriting on forms and notesWeakest published class for compact engines: the PP-OCRv6 table reads 62.1 on handwritten Chinese and 67.8 on handwritten English, well under its 83.2 averageReads freeform writing better in practice; no board publishes a per-class scoreVLM, with an audit step on every field that matters
Mixed content: tables, formulas, multi-column prose in one fileZoning rules break; table structure needs extra models or templatesSmall parser VLMs hold the top table scores: 96.8 table TEDS for the board leader against 81.9 for the best classic pipelineSmall parser VLM
Degraded scans, old print, aged typeOld scans are where pipelines collapse: a leading open pipeline scores 43.2 on the old-scans category against 99.7 on its baselineFidelity modes exist for this class, verbatim flags that keep archaic spellingParser VLM with fidelity controls, or an archival lane
Merged-cell and stacked-header tablesLine-tracers return empty cells; the fix requests have sat unanswered for yearsStructure recovery is real, but an unaudited guess is invisible; predicted spans can merge the wrong columnsParser VLM, then diff the output against geometry

One row decides most budgets: the first. If your pages are machine-printed and arrive at volume, the engine class is faster and cheaper per page. By the vendor's own tables it is also more accurate on that class than models hundreds of times its size. The handwriting row is the honest gap. Compact engines publish their weakest scores there. The VLM side publishes no per-class score at all. Test on your own forms before you commit either way.

What the boards actually say

The combined task has one public scoreboard, OmniDocBench from opendatalab. Its single score averages text, table, and formula quality into one number. The board read 28 October 2026 makes one point loudly. The top of page parsing belongs to small purpose-built models, not to frontier chat models.

ModelClassSizeOverall
TeleOCRsmall parser VLM1.2B96.91
OvisOCR2small parser VLM0.8B96.47
PaddleOCR-VL-1.6small parser VLM0.9B96.34
MinerU2.5-Prosmall parser VLM1.2B95.75
GLM-OCRsmall parser VLM0.9B95.22
Gemini 3 Profrontier chat model-92.91
Gemini 3 Flashfrontier chat model-92.62
dots.ocrsmall parser VLM3B90.77
Qwen3-VL-235Bfrontier chat model235B89.78
GPT-5.2frontier chat model-86.59
MinerU pipelineclassic pipeline-86.47
Mistral OCRsmall parser VLM-85.66
Markerclassic pipeline-78.44

Three readings matter for a buyer. A 0.9B parser outscores a 235B model by more than six points. The frontier names sit behind, not ahead. The best classic pipeline sits ten points under the best parser. The next one sits eighteen under.

Now the other half, which the migration stories skip. The combined board scores full-page parsing to Markdown. It does not score plain text pulled from clean print. That is the job most volume buyers have. On the vendor's own print benchmark, the same tables the compact engine publishes for itself, the picture flips. The 34.5M-parameter engine averages 86.2 detection Hmean and 83.2 reading accuracy. The vendor's runs of frontier models on the same corpus average 46.8, 45.6, and 38.3 on detection, for Gemini-3.1-Pro, GPT-5.5, and Qwen3-VL-235B. Those are vendor-run numbers on a vendor-named corpus: direction, not audit. But the direction is a canyon, and it matches a plain fact. A model trained to read print beats a model trained to chat, at reading print.

The ledger of invented text

The failure that decides regulated work is not a wrong score. It is invention. A wrong letter is a defect a diff can catch. An invented field is a confident lie.

The proof is primary and named. The PP-OCRv6 documentation ships a side-by-side figure, captioned plainly. The compact engine "faithfully reproduces visual text content, while VLMs introduce hallucinated corrections based on linguistic priors". The model nudges what it reads toward what language makes likely. A smeared 1 becomes a 7, because 7 fits the sentence. The dots.ocr model card carries its own warning: pages full of special characters can make output repeat without end. Both warnings come from the publishers of parser VLMs, not from their rivals.

Two guards are worth demanding from any VLM path. Blank-page honesty: a page with nothing on it must return empty text, not a guess. Loop detection: output that repeats a pattern must be stopped, not streamed until the token budget dies. This platform's archival lane ships both. The audit column in the table above exists for one reason. A transcript you cannot audit is a transcript you cannot ship.

Cost per page: two different meters

The two paths do not just charge different rates. They charge different units. That difference decides budgets before any rate talk does.

An OCR API bills by the page. The same scanned form costs the same on page one and on page ten thousand. Monthly cost is pages times rate. You can compute it before you send anything.

ModelContext$/1M in$/1M out$/1M cached
Qwen
qwen3.8-27b262K$0.35$2.55$0.105
qwen3.6-35b131K$0.11$0.8$0.044
Minimax
minimax-m2.7197K$0.24$0.95$0.072
Muse
muse-glimmer-30b131K$0.28$1.2$0.084
Ornith
ornith-1.5-35b100K$0.35$2.55$0.105
ornith-1.5-9b100K$0.1$0.3$0.03
Glm
glm-5.3-flash1049K$0.11$0.35$0.033
Deepseek
deepseek-v4-flash-07311311K$0.15$0.42$0.045
Gemma
gemma-4-31b-it262K$0.22$0.49$0.066
Deepseek
deepseek-v4-pro1000K$1.13$2.21$0.339
deepseek-v4.1-flash1000K$0.19$0.71$0.06
deepseek-v4.1-flash-10171049K$0.16$0.65$0.003
Glm
glm-5.31000K$1.32$4.25$0.4
Flux
flux-1-schnell—$0.003/image
flux-pro-1.1—$0.04/image
Chatterbox
chatterbox-tts—$25/1M chars
Kokoro
kokoro-tts—$15/1M chars
Pocket
pocket-tts—$16/1M chars
Audio
audio8-tts—$8/1M chars
Hayamimi
hayamimi-stt—$0.6/audio-hr
Bge
bge-m3—$0.05/1M tokens
bge-reranker-v2-m3—$1.5/1k searches
Ocr
ocr-print—$1/1k pages
ocr-archival—$3/1k pages
Whisper
whisper—$0.12/audio-hr
Iab
iab-2x—$0.7/1k pages
iab-3x—$0.7/1k pages
Gliner
gliner-extract—$0.9/1k searches
Jev
jev-fast1K$0.03$0—
jev-causal1K$0.03$0—
jev-batch1K$0.03$0—
Wemm
wemm-embed—$0.09/1M tokens
Molmo
molmo2-er8K$1$5$0.5
Cosmos
cosmos-reason2-2b4K$0.1$0.4$0.05
Sam
sam2.1-base—$0.02/image
Da
da3-small—$0.05/image
Smolvla
smolvla—$0.001/call
Openvla
openvla-oft—$0.006/call
Act
act—$0.001/call

Worked with named terms, engine path:

monthly cost  =  ( N / 1,000 ) x R

N:  pages processed in the month
R:  per-thousand-page rate for the lane, from the fenced table

One sensitivity line. The lane meters the page count the engine reports, and refused or oversized requests bill nothing. The number you compute is the number you owe.

A VLM path bills by the token. Image tiles, prompt, and output all meter. The same page costs more at higher resolution, and more when the model is chatty. The per-page figure is a range you measure, not a rate you look up:

cost per 1,000 pages  =  ( P / 1,000,000 ) x ( Rin x Tin + Rout x Tout )

P:    pages processed
Tin:  input tokens per page, image tiles plus prompt; grows with image resolution
Tout: output tokens per page; grows with output length
Rin, Rout: per-million-token input and output rates, from the fenced table

The two formulas are the real price war. One has no variables you fail to control. The other has two, and you control them only by shrinking images or capping output. Both moves cost you quality.

Named relations for the wider market, each read 28 October 2026 at the vendor's own pages. AWS Textract lists its plain text-detection rate per page above this platform's print-lane rate, and its forms-analysis rate at a large multiple of it. Google's enterprise document OCR processor lists per thousand pages above the print lane's rate and below the archival lane's. Both firms drop their rates past volume tiers. On the VLM side, OpenAI's live pricing page carries its current chat families at per-million-token rates, and a page's cost under that meter moves with resolution and output length. That is the point: the unit difference is the cost difference. Mistral's news page publishes a headline rate of 1000 pages per dollar, read 28 October 2026, with batch inference roughly doubling the pages per dollar; that headline rate sits at this platform's print-lane rate. Its benchmark row above is board-verified.

The hybrid pattern, priced

At volume, the hybrid is usually the correct answer at the lowest cost. The engine reads every page at the per-page rate. A router sends only the suspect few to a VLM. Call the flagged share F. Monthly cost is the engine formula, plus F times the VLM formula on the same page count. At a two percent flag rate, the token meter touches one page in fifty. At forty percent, skip the hybrid and move the whole stream.

The router does not need to be clever. Engine confidence scores, blank-output pages, a page classifier, or a document-type split all work. The hybrid buys more than cost. It buys an audit line. The pages a VLM touched are exactly the pages your review queue holds.

What this platform serves

Stated as dated facts. The print lane and the archival lane are per-page OCR routes. Both went live on 26 October 2026, confirmed by that day's requests. The print lane page and the archival lane page carry the full contracts. The print lane runs the compact engine class at volume. The archival lane is itself a small parser VLM, with the fidelity controls and the two guards named above. That is this page's point, lived: the market's two labels now overlap inside single products. The VLM side is served by molmo2-er, a vision-language model on the chat route, metered per token, serving since 6 October 2026. A fourth capability, a structured-parse row evaluated on GLM-OCR, is not currently offered and carries no rate. Its evaluation page holds the benchmark record and the request shape a row would take. The parsing category maps all of it. The pricing guide holds every live rate.

Make the first call

Sign up, create a key, and put one real page through the lane you are weighing. The engine path is one multipart request:

curl -X POST "https://api.ironstratum.com/v1/ocr" \
  -H "Authorization: Bearer $KEY" \
  -F "model=ocr-print" \
  -F "file=@invoice-page-01.png"

The answer carries the text and the page count the meter will match. For the VLM side, the chat route takes the page image in an image block, and your instruction as text. The lane pages above document both shapes. The metering law is the same on both. Spend stops at the wallet balance. Refused requests bill nothing. Every response carries a usage record your bill will match. If runaway metered spend is the worry you are pricing, how to avoid API bill shock covers the controls.

Read the classes top to bottom

Stop at the first match.

  1. Machine-printed pages at volume, structure not needed: the engine class, per-page metered.
  2. Born-digital reports bound for retrieval, tables and headings must survive: a small parser VLM, or a marker-class pipeline at lower quality.
  3. Old scans, aged print, citation-grade transcripts: a fidelity-controlled VLM path, verbatim mode on.
  4. Handwriting-heavy forms: a VLM path, an audit step, and your own test set. No board settles this row.
  5. One document type, millions of copies, fixed layout: an engine with a template, tuned per field.
  6. Unknown mixed stream at volume: the hybrid, with a flag rate you measure in week one.

Questions buyers ask

Is VLM OCR just better than OCR now? On the combined parsing task, small parser VLMs lead the public board, and every leader sits under 4B parameters. On clean print at volume, the vendor tables run the other way, by a canyon. The word "better" has no referent until you name the page class. Any page that hands you one winner has flattened the table above.

Which is cheaper per page? The units differ before the rates do. Per-page metering gives a fixed cost you can compute up front. Token metering gives a range that moves with image resolution and output length. At small volume the gap is noise. At a million pages a month, the unit difference is the budget.

Do VLMs invent text on documents? The publishers of parser VLMs document it themselves. The PP-OCRv6 docs name "hallucinated corrections based on linguistic priors" in their own figure. The dots.ocr card warns of endless repeats on special-character runs. Fixes exist and work: verbatim modes, blank-page honesty, loop guards, field-level audits. Plan for the failure class. Do not hope the model is polite.

What about handwriting? The one honest answer is a test. Compact engines publish their weakest scores there. The VLM side publishes no per-class score. Handwriting is also where invention costs most. A confident invented reading of a signature line is worse than an honest failure. Audit every field that matters.

Should I just run both, a hybrid? At volume, usually yes, and the flag rate decides it. Below some volume, the cost of the router beats what it saves. Measure the share of pages the engine fails on. Single-digit percents: hybrid. Near half: move the whole stream to the VLM path, and spend your effort on the audit queue instead.

How do I test before committing? Pull fifty real pages that span your classes. Run each candidate lane. Diff the outputs against ground truth you trust. Count invented fields, not just wrong letters. The merged-cell guide ships a rebuildable test corpus for the table class. The PDF-to-markdown guide carries the retrieval-side check. Both are linked below.

The short version

Name the page class first. Clean print at volume: the engine path, per-page metered, fixed in behavior, and by vendor tables the most accurate thing there is on that class. Messy layouts, tables, degraded scans: the small parser VLM class, which owns the public boards and now powers many products sold as OCR. Frontier chat models: flexible, token-metered, behind on the board, first in invention reports, and the wrong default for volume. Handwriting: settled by no board; test and audit. Depth on the neighboring problems: merged cells, PDF to markdown for retrieval, and what a VLM is. The live rates sit on the pricing guide. When the class is named and the meter fits, sign up and put one page through.

Last verified: 2026-10-28