Document Extraction Cost per Page: Tokens, Retries, Review and Budget Alarms
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.
- 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.
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.
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).
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.
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:
- Schema failure. The output did not match the schema. The structured-outputs reference notes that a
refusalstop reason bypasses the schema guarantee; count refusals here and countmax_tokensstops only under Truncation, so no event lands in two classes. - Truncation. The output hit the token limit; the retry usually needs a split call, which is dearer than a plain repeat (author inference).
- Validation failure. The output parsed but a check failed, as in table and form validation; many of these should go to review, not to another model call.
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.
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.
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):
- Interactive: a user uploads and waits. Use synchronous calls.
- Backlog: a historical archive or overnight inbox. Use batch where offered.
- 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).
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.
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).
- Per-run ceiling. Stop a single job when spend passes a fixed amount, which catches a loop or a batch fed the wrong folder.
- Per-day ceiling. Pause intake when the day's spend passes a limit, and alert a person.
- Kill switch. Pause when cost per accepted document over a rolling window exceeds a multiple of the pilot baseline. Choose the multiple from your pilot variance.
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.
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.
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.
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).
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.