# 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.

Guide: Document extraction pipelines in production — part 6
Published: 2026-10-27 · Updated: 2026-10-27 · 1763 words · ~2345 tokens (estimate)
Canonical: https://changegamer.ai/articles/cost-per-page-for-document-extraction
JSON: https://changegamer.ai/api/articles/cost-per-page-for-document-extraction.json
Access: free — editorial guide, not part of the licensed corpus
Pillar: https://changegamer.ai/articles/ai-document-extraction-pipeline-in-production.md

## 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.

---

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](/articles/ai-document-extraction-pipeline-in-production) 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](/resources/document-extraction-for-agents) (2026-09-28), [Multimodal Agents](/resources/multimodal-agents) (2026-10-04) and [Structured Outputs and JSON Mode](/resources/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.

```bash
# 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:

```text
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](/articles/schema-constrained-field-extraction-from-documents).

## 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:

- **Schema failure.** The output did not match the schema. The structured-outputs reference notes that a `refusal` stop reason bypasses the schema guarantee; count refusals here and count `max_tokens` stops 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](/articles/table-and-form-validation-for-document-extraction); 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](/articles/schema-constrained-field-extraction-from-documents) 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](/articles/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](/articles/extraction-schema-versioning-for-document-pipelines), 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).

- **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](/articles/agent-cost-telemetry-in-production) covers the general pattern.

For how self-hosting changes which costs you carry, see [open source vs managed document parsing](/articles/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:

```bash
# 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).


---

## The rest of this guide

- [AI Document Extraction in Production: Parse, Extract, Validate, Review](https://changegamer.ai/articles/ai-document-extraction-pipeline-in-production.md): How to run AI document extraction as a production pipeline: separate parsing from schema-constrained field extraction, choose OCR, a vision model or a hybrid, validate values, route doubtful ones to a human, version the schema, and work out cost per page.
- [OCR vs Vision Language Model for Document Parsing: How to Choose Stage A](https://changegamer.ai/articles/ocr-vs-vision-model-vs-hybrid-document-parsing.md): OCR vs vision language model for document parsing: a decision order keyed on residency, layout variance, volume and known schema, how a hybrid arbitrates disagreements, a per-field bake-off, failure-mode mapping, page batching and privacy.
- [Schema-Constrained Field Extraction From Documents: Settings and Failure Branches](https://changegamer.ai/articles/schema-constrained-field-extraction-from-documents.md): Schema constrained field extraction from documents: nullable fields, enums with an escape value, evidence fields, a branch table for refusal, truncation, parse failure and empty output, a one-retry policy, and field confidence as inference.
- [Table and Form Validation for Document Extraction: Row Counts, Totals and Required Fields](https://changegamer.ai/articles/table-and-form-validation-for-document-extraction.md): Validating table and form extraction from documents: rows split across pages, subtotal rows, exact money reconciliation, column sums, required-field maps per form type, cross-field checks and a failed-check-to-route table.
- [Human Review Fallback for Document Extraction: Triggers, Capacity and the Correction Loop](https://changegamer.ai/articles/human-review-fallback-for-document-extraction.md): Designing the human review fallback for document extraction: a routing-trigger table, cross-checking high-stakes fields, review capacity and backlog policy, the review item record and a correction loop that feeds regression sets.
- [Versioning a Document Extraction Schema: Migrations, Manifests and Rollback](https://changegamer.ai/articles/extraction-schema-versioning-for-document-pipelines.md): How to version a document extraction schema: which edits break stored records, absent versus null fields, lazy upcast versus backfill, reprocessing from stored parse output, a version manifest, dual-read cutover, correction migration and rollback.
- [Open Source vs Managed Document Parsing: A Decision Order, Operating Burden and Exit Plan](https://changegamer.ai/articles/open-source-vs-managed-document-parsing.md): How to decide between self-hosted open-source parsers and a managed parsing service: residency and licence first, volume and operations capacity second, reversibility third, plus the cost of operating models, lock-in, a single-interface fallback design and a trial protocol on your own documents.
- [Writing Extracted Document Data to a System of Record: Matching, Keys, States and Replay](https://changegamer.ai/articles/feeding-extraction-output-into-a-system-of-record.md): How to write extracted document data to a system of record: matching an extracted record to an existing one, retry keys versus business keys, a staged-to-committed state machine, per-record versus per-document atomicity, dead-letter queues, replay from the saved parse artifact and the write-boundary log.
- [Multimodal Document Understanding for Extraction: Charts, Diagrams, Photos, Stamps and Video Frames](https://changegamer.ai/articles/multimodal-document-understanding-for-extraction-pipelines.md): How to handle non-text visuals in a document extraction pipeline: when OCR is not enough, extracting a value versus a description versus a class, region-level routing, figure-aware page packing, poor scans, video frames, image-borne injection and per-visual evaluation.
- [Monitoring Document Extraction Accuracy in Production: Audit Samples, Field Metrics and Drift](https://changegamer.ai/articles/monitoring-document-extraction-accuracy-in-production.md): How to monitor document extraction accuracy in production: a stratified audit sample with independent labels, per-field metrics with intervals, extraction-specific drift triggers, thresholds from your own variance, and regression intake.
- [How to Split Long Documents for Extraction: Batches, Overlap and Reassembly](https://changegamer.ai/articles/splitting-long-documents-for-document-extraction.md): How to split long documents for extraction: size batches from measured tokens per page, choose section or page windows, overlap pages, carry table headers, reconcile conflicts across batches and reassemble with provenance.

## Reference resources

- https://changegamer.ai/resources/document-extraction-for-agents.md
- https://changegamer.ai/resources/multimodal-agents.md
- https://changegamer.ai/resources/structured-outputs-and-json-mode.md

All guides: https://changegamer.ai/api/articles.json · Reference corpus: https://changegamer.ai/llms.txt
Licensing: https://changegamer.ai/api/pricing.json (offer catalog) · https://changegamer.ai/api/payment.json (payment methods, HTTP 402 flow) · access guide: https://changegamer.ai/resources/access-and-pricing.md
