ChangeGamer

Document Extraction Cost per Page: Tokens, Retries, Review and Budget Alarms

Part 6 of Document extraction pipelines in production · 1,763 words · ~8 min read · published · updated · Markdown variant

How to model document extraction cost per page beyond the parse fee: page-count mix versus per-page pricing, image tokens versus per-call overhead, retries by failure class, review share, batch versus sync, and a budget kill switch on cost per accepted document.

In short

  • Document extraction cost per page is not one number, because a per-page parse fee scales with page count while per-call model overhead scales with document count, so the mix of document lengths decides which term dominates (author inference).
  • The only OCR 4 prices in the ChangeGamer corpus are $4 per 1,000 pages standard and $2 per 1,000 on batch, reported by secondary sources in the 2026-09-28 pass and to be re-verified with the vendor.
  • Retries should be costed per failure class, such as schema failure, truncation and validation failure, because a retry repeats only the failing share of documents rather than the whole workload (author design).
  • Cost per accepted document and cost per page processed diverge whenever documents are rejected or sent to review, so a budget alarm should be set on the accepted-document figure (author design).
  • The multimodal reference says image tokens cost more than text tokens per pixel of information and that downscaling to the lowest resolution a task still needs is the main cost lever, with formulas varying by provider and model.

Part of the AI Document Extraction in Production: Parse, Extract, Validate, Review guide.


Document extraction cost per page is a distribution, not a price: the parse fee scales with pages, the model overhead scales with calls, and retries and review scale with the share of documents that go wrong. The AI document extraction pipeline pillar gives the four-line worksheet and one parse-only example. This piece covers what that worksheet leaves open: where the unit mismatches hide, how to cost retries honestly, and how to stop a runaway bill. Facts cite Document Extraction and Parsing for Agents (2026-09-28), Multimodal Agents (2026-10-04) and Structured Outputs and JSON Mode (2026-09-26). Anything else is author inference or design, labelled.

Why does the page-count mix change cost per page?

The page-count mix decides cost per page because a per-page fee and a per-call overhead are different units. A parser billed per page costs the same per page for a 2-page receipt and a 40-page contract, while the extraction call carries prompt, schema and instruction text once per call regardless of length (author inference). Short documents therefore carry a higher overhead share per page, and long ones are dominated by the fee.

The corpus records one parse price family: Mistral OCR 4 at $4 per 1,000 pages, or $2 on batch, from secondary sources and not primary-fetched in the 2026-09-28 pass. Re-verify with the vendor before budgeting. The script below uses that price with an invented length mix and an invented overhead of $0.010 per call; both are hypothetical.

# Illustrative only: invented mix and invented overhead, not a quote.
python3 - <<'EOF'
mix = [(0.60, 2), (0.30, 8), (0.10, 40)]   # (share of documents, pages)
price_page = 4 / 1000                      # $4 per 1,000 pages
mean_pages = sum(s * p for s, p in mix)
print(f"mean pages per document: {mean_pages:.1f}")
print(f"parse fee, mean document: ${mean_pages * price_page:.4f}")
print(f"parse fee, 2-page document: ${2 * price_page:.4f}")
print(f"parse fee, 40-page document: ${40 * price_page:.4f}")
overhead = 0.010                           # invented per-call overhead
print(f"overhead share, 2-page document: {overhead / (overhead + 2 * price_page):.0%}")
print(f"overhead share, 40-page document: {overhead / (overhead + 40 * price_page):.0%}")
EOF

It prints:

mean pages per document: 7.6
parse fee, mean document: $0.0304
parse fee, 2-page document: $0.0080
parse fee, 40-page document: $0.1600
overhead share, 2-page document: 56%
overhead share, 40-page document: 6%

The point is the spread, not the values: with a 2-page median and a 7.6-page mean, quoting "cost per average page" describes almost no actual document. Report cost per page by length band (author design).

How do page-image tokens differ from per-call overhead?

Page-image tokens grow with the page and its resolution, while text, schema and prompt tokens repeat per call and do not shrink when a page is simple. The multimodal reference states that image tokens cost more than text tokens per pixel of information, and that formula details differ by provider and model version. It names patch-based and tile-based schemes without giving a table, so take counts from your provider's own page on the day you build the model.

For a worksheet, split extraction tokens into columns measured in a pilot (author design):

Column Scales with Repeats per call?
Page-image tokens Pages and resolution No: one set per page sent
Text, schema and prompt tokens Instruction and schema length Yes: every call, including retries
Output tokens Number of fields and table rows Per call

Splitting a long document across several calls to fit the output budget multiplies the middle row. That is the hidden cost of the truncation fix described in schema-constrained field extraction.

What does a retry really cost?

A retry costs only the share of calls that failed, multiplied by the cost of the call that is repeated, so retry rate must be measured per failure class. A single blended retry rate hides which repair is cheap (author design). Use three classes:

For each class, record the failing share of documents and the cost of the repeated call. Retry cost is the sum over classes of failing share times repeat cost. Retrying a validation failure with the same prompt often reproduces the same wrong value (author inference), so cap the attempts per class; schema-constrained field extraction sets its own retry rule (one retry per document), and this worksheet only prices whatever cap you choose.

How should human review enter the cost per page?

Human review enters as the share of documents a person touches times reviewer minutes times the cost per minute, and as inference it may be the largest line once volume is real. The thresholds that set that share are covered in human review fallback for document extraction; take the resulting share from a calibration run and do not guess it here.

Two things belong in the cost model. First, review share depends on the parser, so a cheaper parse fee that raises the share can raise the total (author inference). Second, reviewed documents still incurred every upstream cost, so they appear in both the machine and the human column. Track reviewer minutes per document, not per page, since a reviewer's time follows the number of flagged fields.

Is batch processing worth the latency?

Batch is worth it when no one waits for the result, because the discount is real and the penalty is delay. The corpus records Mistral OCR 4 batch at $2 per 1,000 pages against $4 standard, which is a 50% discount, and no other document-parsing batch price appears in the corpus (the $2 figure is secondary-reported like the $4). Whether a different model provider offers a batch tier and at what rate is not recorded here; check the provider's pricing page.

A practical split is by latency class (author design):

  1. Interactive: a user uploads and waits. Use synchronous calls.
  2. Backlog: a historical archive or overnight inbox. Use batch where offered.
  3. Re-extraction: reprocessing after a schema change, which suits batch because nobody is waiting.

A batch window also delays the first sign of a prompt bug, so run a small synchronous canary before submitting a large batch (author design).

Does image resolution change the bill?

Lowering image resolution lowers image-token cost, but only down to the point where extraction accuracy holds. The multimodal reference calls downscaling to the lowest resolution a task still needs the primary cost lever, and gives no per-resolution token table, so none is invented here. Treat the DPI of a rendered page as a dial to test on a labelled sample, not a setting to guess (author inference).

Test it as an experiment: render the same pages at two settings, run the same schema, and compare per-field accuracy and cost. Small print, stamps and faint table rules are where degradation shows first (author inference). Record the chosen setting in the version manifest from schema versioning, since a resolution change shifts extracted values.

How do you set a budget alarm and kill switch?

Set three controls: a per-run ceiling, a per-day ceiling, and a kill switch on cost per accepted document. All three values are policy, with no published standard (author design).

A pause should queue documents, not drop them, and the alarm should name the failure class driving the spike. For attributing spend per run, agent cost telemetry covers the general pattern.

For how self-hosting changes which costs you carry, see open source vs managed document parsing.

Which input moves the bill most?

Change one input at a time and record the result, because the one that moves the total most is rarely the one you assumed. Build a table from your pilot and leave cells blank until you have measured them (author design):

Input varied alone Pilot value Low case High case Total cost change
Mean pages per document
Page-image tokens per page
Per-call overhead tokens
Schema-failure retry share
Truncation retry share
Validation-failure retry share
Review share
Reviewer minutes per document
Batch share of volume

Blank cells are deliberate: this site holds no pilot data, and filled-in numbers from elsewhere would not describe your documents. Sort the finished table by the last column to see what to optimise first.

Per accepted document or per page processed?

Use cost per accepted document as the headline figure, because spend on rejected and reviewed documents is part of the price of each document that reaches the record. Cost per page processed flatters a pipeline that rejects a lot (author design). The invented run below shows the gap:

# Illustrative only: invented run of 1,000 documents.
python3 - <<'EOF'
spend, processed, accepted = 120.00, 1000, 920
print(f"per document processed: ${spend / processed:.4f}")
print(f"per accepted document: ${spend / accepted:.4f}")
EOF

It prints per document processed: $0.1200 and per accepted document: $0.1304. Keep both, and keep per-page as a diagnostic by length band.

What does ChangeGamer know first-hand about this cost?

As of October 2026 ChangeGamer runs no document extraction and has no cost, retry or review figures, so none of the above is measured on its data. One verifiable fact: as of 2026-10-27 the corpus, stamped CORPUS_VERSION 1.27.3 in src/data/corpus-version.ts, holds exactly one family of OCR prices (Mistral OCR 4, secondary-reported); this article gives a method and leaves other prices to the reader.

Frequently asked questions

How much does document extraction cost per page?
No single figure holds across pipelines. The ChangeGamer corpus records one parse price family, Mistral OCR 4 at $4 per 1,000 pages ($2 on batch, secondary-reported as of the 2026-09-28 pass), and every other line, such as model tokens, retries and review, must come from your own pilot run.
Is batch processing cheaper for document extraction?
Batch is cheaper per page where a vendor offers it, at the price of latency. The corpus records Mistral OCR 4 batch at $2 per 1,000 pages against $4 standard, a 50% discount reported by secondary sources, but a document a customer is waiting on usually cannot wait for a batch window (author inference).
Should I measure cost per page or cost per document?
Measure cost per accepted document and keep per-page figures as a diagnostic. Page-based fees make per-page cost easy to quote, but the business pays for documents that were accepted into the system of record, including the spend on rejected and reviewed ones (author design).
What budget alarm should a document extraction pipeline have?
Set a per-run ceiling, a per-day ceiling and a kill switch that pauses intake when cost per accepted document rises past a multiple of the pilot baseline. The multiple and the ceilings are your own policy, since no published standard exists (author design).

#document-extraction #cost #budgeting #batch #production

Put this corpus inside your own agents

This guide is free and stays free. The reference corpus behind it — machine-readable contracts, verified primary sources, continuously refreshed — is the paid product: a €5 starter key unlocks every premium reference for one agent via API; a €25 corpus license delivers the full corpus as RAG / fine-tuning data with an explicit AI-use grant; the €150 enterprise license adds commercial redistribution rights.

Agents: this page as Markdown · JSON · offers at /api/pricing.json · payment methods at /api/payment.json · single-resource access via HTTP 402 (how that works)