Blog · 2026-07-20 · Vynaris Team

What LLM invoice extraction actually costs per 1,000 documents

A reproducible per-document cost model for LLM invoice extraction across four workhorse models, plus what a router does to the bill. Prices verified 2026-07-20.

Extracting structured data from 1,000 invoices costs between $0.74 and $7.80 in model fees, depending on which model you pick. The 5% of documents that land in a human review queue cost about $75. The model choice moves the bill by a few dollars; the exception rate moves it by tens. Prices verified 2026-07-20. This is a reproducible cost model, per document, that you can re-run with your own token counts.

The finding, before the model

Document extraction is the most common production LLM workload that nobody publishes real numbers for. A PDF invoice goes in, a JSON row comes out: vendor, date, line items, total. The vendor demos show the happy path. The bill lives in the parts they skip: the second pass you run on low-confidence documents, and the human who checks the ones the model got wrong.

We built the cost model from public pricing only. No product telemetry. Every token count below is an assumption you can edit, and every price is from a provider's live page, captured 2026-07-20. The output is a per-1,000-document number across four workhorse models, plus what a router does to it.

The workload (edit these)

One batch of 1,000 documents. These are the knobs that set the bill.

Assumption                 Value        Note
-------------------------  -----------  ------------------------------------------------------
Documents per batch        1,000        the outcome unit is cost per 1,000 docs
Input tokens per doc       3,000        rendered page text + shared instructions/schema
Output tokens per doc      700          the extracted JSON row
Shared prefix (cacheable)  1,500        schema + instructions + few-shot, identical every call
Unique doc text            1,500        the invoice itself, different every call
Second verify pass         20% of docs  re-extract low-confidence documents
Human review queue         5% of docs   exceptions a person checks by hand
Review time                3 min/doc    editable
Loaded labor               $30 / hour   editable

Two structural facts drive everything. First, output is expensive: a 700-token JSON row billed at output-token rates is more than half the bill on the pricier models, where output pricing runs 5x to 18x the input rate. Second, the prompt prefix repeats: the same schema and instructions ride on all 1,000 calls, which is exactly what prompt caching is for.

With a verify pass on 20% of documents, one batch is 1,200 model calls: 3.6M input tokens and 0.84M output tokens.

Cost per 1,000 documents, four models

Same workload, same cost-per-token math, four extraction-grade models. Uncached, then with the shared prefix served from cache. Prices verified 2026-07-20.

Model                                                                      Uncached / 1k docs  Cached prefix / 1k docs  Cache saves
-------------------------------------------------------------------------  ------------------  -----------------------  -----------
[deepseek-v4-flash](https://vynaris.com/models#deepseek-v4-flash)          $0.74               $0.49                    33%
[Gemini 3.1 Flash-Lite](https://vynaris.com/models#gemini-3-1-flash-lite)  $2.16               $1.76                    19%
[gpt-5.4-mini](https://vynaris.com/models#gpt-5-4-mini)                    $6.48               $5.27                    19%
[Claude Haiku 4.5](https://vynaris.com/models#claude-haiku-4-5)            $7.80               $6.18                    21%

deepseek-v4-flash at $0.74 is 10.6x cheaper than Haiku 4.5 at $7.80 for the identical job. The gap is almost entirely the output price: DeepSeek bills output at $0.28 per million tokens, Haiku 4.5 at $5.00, an 18x difference on the 700 tokens that dominate an extraction call.

Caching helps most where input is a larger share of the bill. On deepseek-v4-flash the shared prefix served at the $0.0028 cache-hit rate cuts 33%, because its cache read is 2% of its input price. On Haiku 4.5, where output already dominates, the same technique saves 21%. Caching is a lever on the input half of the bill; it cannot touch the output half. This is the same behavior we quantified in prompt caching in production.

Where a router changes the unit economics

The verify pass is the interesting cell. In the single-model numbers above, the low-confidence 20% get re-extracted on the same model. A router does something different: run the whole batch on the cheapest model, then escalate only the low-confidence 20% to a frontier model instead of re-running the cheap one.

Strategy                                                                                        Cost / 1k docs  vs all-frontier
----------------------------------------------------------------------------------------------  --------------  ---------------
All deepseek-v4-flash (first pass + verify)                                                     $0.74           96% less
Routed: DeepSeek bulk + [Gemini 3.1 Pro](https://vynaris.com/models#gemini-3-1-pro) escalation  $3.50           80% less
All Gemini 3.1 Pro (first pass + verify)                                                        $17.28          —

The routed run costs $3.50: $0.62 to extract all 1,000 documents on deepseek-v4-flash, plus $2.88 to re-extract the hard 200 on Gemini 3.1 Pro at $2.00 / $12.00 per million. That buys frontier accuracy on the documents that need it for 80% less than running frontier on everything, which would cost $17.28.

Routing earns its keep here because extraction confidence is measurable. A JSON schema with required fields, a checksum on the line-item total against the invoice total, a low log-probability on a parsed field: each is a cheap signal that a document is hard, and each tells the router which 20% to escalate. If you want to run your own escalation rate and token shape, the calculator takes the per-document input and output counts directly. This is the same model-routing discipline we applied to the coding-agent cost-per-task model.

The chart: the model is the cheap part

The dashed line is the number that should reset the conversation. At a 5% human review rate, 3 minutes per document, and $30/hour loaded labor, the exceptions cost $75 per 1,000 documents. That is above every single model bar. On deepseek-v4-flash the model is 1.0% of the total bill of $75.74; even on Haiku 4.5 the model is 9.4% of $82.80. Halving your review rate from 5% to 2.5% saves $37.50 per 1,000 docs, more than switching from Haiku 4.5 to DeepSeek saves on the model line. Right-size the model, but obsess over the exception rate.

Build notes

Extraction has constraints a token model does not capture.

• Accuracy sets the review rate, and the review rate sets the bill. A cheaper model that raises the exception rate from 5% to 8% adds $45 of human review per 1,000 docs, which erases any model saving. Measure accuracy on your own documents before you pick on price. Extraction is where a slightly better model can be cheaper overall.
• Structured output has its own token tax. Forcing valid JSON with tool-calling or a schema adds fixed tokens to every call, and on small extraction requests that overhead is a real share of input. We measured it separately in the structured-output cost post.
• Batch discounts stack on all of this. If the documents are not time-sensitive, both Anthropic and OpenAI cut input and output 50% for asynchronous batch processing, and Gemini 3.1 Flash-Lite drops to $0.125 / $0.75. That halves every model number above with no accuracy change.
• Vision changes the input count. These numbers assume the page is already text. If you send the invoice as an image to a vision model, the image tokens replace the 1,500 text tokens and the input side grows; re-run the model with your real per-page token count.

When this workload does not need a router

The honest tradeoff: if deepseek-v4-flash alone clears your accuracy bar on the hard documents, do not build a router. Pay $0.74 per 1,000 docs and move on. A router adds a confidence signal, an escalation path, and a second provider integration, and it only earns that complexity when the cost of a wrong extraction on a hard document exceeds the ~$2.76 escalation premium per 1,000 docs. For a batch where a wrong invoice total means a wrong payment, the frontier escalation is cheap insurance. For a batch feeding a dashboard where an occasional miss is tolerable, the router is over-engineering, and the single cheap model with a good schema and a 5% human check is the right build. The extraction workhorse comparison walks the model-only decision if you have already ruled routing out.

FAQ

What does LLM invoice extraction cost per document? On our model, $0.0007 to $0.0078 per document in model fees, which is $0.74 to $7.80 per 1,000 documents across deepseek-v4-flash through Claude Haiku 4.5, with 3,000 input and 700 output tokens per doc and a verify pass on 20%. Human review of the 5% exception rate adds about $75 per 1,000 docs.

Which model is cheapest for document extraction? deepseek-v4-flash at $0.74 per 1,000 documents, because its $0.28 output price is roughly 18x below Claude Haiku 4.5's $5.00, and extraction output dominates the bill. It is only the right choice if it clears your accuracy bar on your documents.

Does prompt caching help invoice extraction? Yes, on the input half of the bill. Serving the shared schema and instructions from cache cuts 19% to 33% depending on the model, most on deepseek-v4-flash whose cache read is $0.0028 per million. It does not reduce the output cost, which is the larger half on the pricier models.

When should I route between models for extraction? When you can measure per-document confidence and the cost of a wrong extraction is high. Running the batch on a cheap model and escalating only the low-confidence 20% to Gemini 3.1 Pro costs $3.50 per 1,000 docs, 80% less than running frontier on everything at $17.28, while still applying the strong model where it matters.

What is the real cost driver in a document pipeline? Human exception review, not the model. At a 5% review rate the human cost of $75 per 1,000 docs is above every model option. Reducing the exception rate saves more than any model switch.

Sources

• Anthropic pricing (Claude Haiku 4.5, cache read/write multipliers), captured 2026-07-20: https://platform.claude.com/docs/en/about-claude/pricing
• OpenAI API pricing (gpt-5.4-mini), captured 2026-07-20: https://developers.openai.com/api/docs/pricing
• DeepSeek API pricing (v4-flash, cache-hit rate), captured 2026-07-20: https://api-docs.deepseek.com/quick_start/pricing
• Google Gemini API pricing (3.1 Flash-Lite, 3.1 Pro, batch), captured 2026-07-20: https://ai.google.dev/gemini-api/docs/pricing
• Cost model script and per-document arithmetic: from the assumptions table above.

Prices change. We re-verify every figure in this post monthly and stamp updates. Numbers here are current as of 2026-07-20.

The lesson from the model: the model line is the cheap part of a document pipeline, and routing turns the verify pass into frontier accuracy at a fraction of frontier cost. Vynaris is an OpenAI-compatible gateway that routes each request to the cheapest right-sized model, escalates on your confidence signal, and shows the per-document cost. One base URL swap. Get an API key at vynaris.com.