Statistics
What does an LLM task cost, and why do bills overrun?
An LLM task costs its input tokens at the input rate plus its output tokens at the output rate. Real bills overrun because of scope and upgrades.
By the Foxnut team · Updated
What is the LLM cost per task?
The LLM cost per task is its input tokens at the input rate plus its output tokens at the output rate. As arithmetic on the rates cited below, not a measurement, a task that reads 2,000 tokens and writes 500 costs about 2.3 cents on a $5-and-$25 frontier model and about 0.45 cents on a $1-and-$5 small model.
We are Foxnut AI, a senior-only practice in Bengaluru and Paris that builds AI systems and hands them over running. There’s a link to talk to us at the end of this article. Let’s get the arithmetic right first.
What a unit of LLM work costs is public. Every major model vendor publishes a per-token price list, and this page reads them at source and not through aggregators. The three lists below show the same pattern: a frontier-to-small price gap of 5x to 25x for the same volume of work, half price for work that can wait, a 90% discount on context the model has already read, and at least one rate that changes with the shape of the prompt itself.
No price list says why real bills drift past estimates built on these exact numbers, so here this page switches sources. In our own engagement records the two usual causes are added use cases after the system proves itself, and upgrades to frontier models the task never needed.
Token consumption against the rate card is what this studio measures on a live AI system when an estimate meets reality. The records below are the public half of that arithmetic, dated, so any row can be re-checked against its list.
5x
The published gap between Anthropic's frontier tier and its small tier: Claude Opus 5 at $5 per million input tokens and $25 per million output tokens, against Claude Haiku 4.5 at $1 and $5. That is five times the price on both sides for the same volume of work
$2 then $3
A published price with an expiry date printed on it: Claude Sonnet 5 input is $2 per million tokens through 31 August 2026 and $3 from 1 September 2026, with output moving from $10 to $15. The price list itself states when its own numbers stop being true
25x
The span across OpenAI's current GPT-5.6 models: the flagship gpt-5.6-sol at $5.00 per million input tokens and $30.00 per million output tokens, against the small gpt-5.6-luna at $0.20 and $1.20. That is twenty-five times the price on both sides
$2.00 or $4.00
What the same input token costs at Google depending on how long the prompt is: Gemini 3.1 Pro Preview input is $2.00 per million tokens up to 200,000 tokens of context and $4.00 above it, with output moving from $12.00 to $18.00. The task's shape, not just the model, sets the rate
Half price
What all three vendors publish for asynchronous batch processing, the discount for not needing the answer immediately: Anthropic's batch table halves every standard rate, OpenAI's Batch tier prices are half its standard rates ($2.50 and $15.00 against $5.00 and $30.00 on its flagship), and Google states a 50% cost reduction
One tenth
What repeated context costs once cached: Anthropic prices a cache read at 0.1 times its base input rate, and OpenAI's cached-input rates are one tenth of its standard input rates ($0.50 against $5.00 on its flagship). Two vendors independently price re-read context at 90% off
New use cases
The most common reason a real AI bill comes in higher than its estimate, in our experience: scope creep. Once a client sees the system working well, they insist on adding new use cases, and token consumption grows past what was estimated. The rate card never moved, the volume did
Unnecessary upgrades
The second common overrun cause we see: client-insisted upgrades to state of the art models when the initially configured, cheaper model handles the task fine. The work does not change, but every token of it is billed at the frontier rate
| Number | What it measures | Period | Source |
|---|---|---|---|
| 5x | The published gap between Anthropic's frontier tier and its small tier: Claude Opus 5 at $5 per million input tokens and $25 per million output tokens, against Claude Haiku 4.5 at $1 and $5. That is five times the price on both sides for the same volume of work | As published on 5 August 2026 | Anthropic published price list |
| $2 then $3 | A published price with an expiry date printed on it: Claude Sonnet 5 input is $2 per million tokens through 31 August 2026 and $3 from 1 September 2026, with output moving from $10 to $15. The price list itself states when its own numbers stop being true | Read 5 August 2026; change effective 1 September 2026 | Anthropic published price list |
| 25x | The span across OpenAI's current GPT-5.6 models: the flagship gpt-5.6-sol at $5.00 per million input tokens and $30.00 per million output tokens, against the small gpt-5.6-luna at $0.20 and $1.20. That is twenty-five times the price on both sides | As published on 5 August 2026 | OpenAI published price list |
| $2.00 or $4.00 | What the same input token costs at Google depending on how long the prompt is: Gemini 3.1 Pro Preview input is $2.00 per million tokens up to 200,000 tokens of context and $4.00 above it, with output moving from $12.00 to $18.00. The task's shape, not just the model, sets the rate | As published on 5 August 2026 | Google Gemini API published price list |
| Half price | What all three vendors publish for asynchronous batch processing, the discount for not needing the answer immediately: Anthropic's batch table halves every standard rate, OpenAI's Batch tier prices are half its standard rates ($2.50 and $15.00 against $5.00 and $30.00 on its flagship), and Google states a 50% cost reduction | As published on 5 August 2026 | Anthropic, OpenAI and Google published price lists |
| One tenth | What repeated context costs once cached: Anthropic prices a cache read at 0.1 times its base input rate, and OpenAI's cached-input rates are one tenth of its standard input rates ($0.50 against $5.00 on its flagship). Two vendors independently price re-read context at 90% off | As published on 5 August 2026 | Anthropic and OpenAI published price lists |
| New use cases | The most common reason a real AI bill comes in higher than its estimate, in our experience: scope creep. Once a client sees the system working well, they insist on adding new use cases, and token consumption grows past what was estimated. The rate card never moved, the volume did | As of August 2026 | Foxnut AI engagement records (not externally retrievable) |
| Unnecessary upgrades | The second common overrun cause we see: client-insisted upgrades to state of the art models when the initially configured, cheaper model handles the task fine. The work does not change, but every token of it is billed at the frontier rate | As of August 2026 | Foxnut AI engagement records (not externally retrievable) |
How do you get from a price per million tokens to a cost per task?
You multiply each side of the task by its own rate, because nobody buys a million tokens. They run tasks. As arithmetic and not a measurement, a task that reads 2,000 tokens and writes 500 costs about 2.3 cents on a $5-and-$25 frontier model, about 0.45 cents on a $1-and-$5 small model, and about a tenth of a cent on the cheapest current small model on these lists.
That is the whole method. What makes real per-task costs vary a hundredfold is not the rate card but the multipliers on top of it: how many tokens the task actually consumes (a retrieval-heavy task can read fifty times what it writes), which tier the task genuinely needs, whether the work can run in a batch at half price, and how much of the context is repeated and so cacheable at a tenth of the input rate.
A cost estimate that starts from the task’s token profile and applies the published rates can be checked to the cent. An estimate that starts from a circulating monthly average cannot be checked at all.
What do most LLM API cost comparisons get wrong?
The first mistake is comparing input prices alone. Output tokens cost several times the input price on every row cited here, usually five to six times, and one vendor’s list states outright that output prices include the model’s thinking tokens. So a reasoning-heavy task can bill most of its cost on the side of the rate card a comparison ignored.
The second mistake is treating today’s number as durable. One cited rate carries its own expiry date on the page, another carries a Preview suffix, and any of these rows can be different next quarter.
The third is ignoring the published discounts, which are not fine print. Half price for batch work and 90% off cached context are on the same pages as the headline rates, and for high-volume repetitive workloads they move the bill more than the choice of vendor does.
The last is stopping at the rate card entirely, which is where the next section and our own experience come in.
Why do real LLM bills come in above the estimate?
In our experience the overruns do not come from the prices, which is why nothing in the records above explains one. Two patterns account for most of the drift, and both are our founder’s observed record, not industry statistics.
The first is scope creep. Once a client sees the system working well, they insist on adding new use cases, and each one adds token consumption the original estimate never contained. The estimate was right about the system it priced. The system it priced is not the system that ends up running.
The second is unnecessary model upgrades. Clients sometimes insist on state of the art models even when the initially configured, cheaper model does the task perfectly well, and on the rate cards above that single decision multiplies the same volume of work by five to twenty-five times.
Both causes are decisions, not surprises, so we treat them as scoping conversations and not billing incidents. What a running system costs its owner beyond the model bill (monitoring, people, the weeks after deployment) is a separate question, answered separately on this site.
What does this page not tell you about LLM costs?
This page publishes no per-task token measurements from our own systems. Client token bills are client-confidential, and a per-task figure without its workflow context would be a misleading benchmark. It also does not rank vendors, because the lists cited price different model families with different capabilities, and a cheaper token that needs more attempts is not cheaper.
Three kinds of figure are deliberately absent. One is circulating monthly averages for what an LLM costs that trace to no primary list. Another is Google’s context-caching rates, which are priced on a different basis (per-token charges plus hourly storage) and are not comparable row for row with the other two vendors. The third is any prediction of where prices go next.
The one claim this page makes beyond the lists, the two overrun causes, is asserted from our engagement records and labelled as exactly that.
Where do these LLM prices come from?
Every price on this page was read from the vendor’s own live pricing page, as of August 2026: Anthropic’s Claude pricing page, OpenAI’s API pricing page, and Google’s Gemini Developer API pricing page, each linked in the sources. We did not use aggregator comparisons or secondary roundups, even where they quote the same lists, because prices change often enough that only the primary page is evidence.
Important note: check the vendor’s page before you rely on any row here. The worked cost-per-task figures are arithmetic on the cited rates and are labelled as arithmetic in place.
The two overrun causes come from one source only, our own engagement records as summarised by the founder, edited for publication without adding numbers. They are operating experience, not market data. Where this page asserts, it says it asserts.
At Foxnut AI the people who sign the proposal do the work, and there is one tier. We read the token bill of the system we built with the same care as the rate card, and we tell you when a cheaper model already does the job, even when you ask for the frontier one. Then your team takes the system over.
You can read about the consulting work behind these numbers first. If you want a straight answer on what your own workflow would actually cost to run, and not a rate card to interpret yourself, that is a five-minute conversation, not a sales call. Ask us.
Sources
- Anthropic, Claude pricing page: per-million-token input and output rates for every current Claude model, batch rates at half the standard rates, cache reads at 0.1x the base input price, and the Claude Sonnet 5 introductory-pricing note, read on the pageRetrieved
- OpenAI, API pricing page: per-million-token input, cached-input and output rates for the GPT-5 family through the GPT-5.6 models, with a Batch tier priced at half the standard rates, read on the pageRetrieved
- Google, Gemini Developer API pricing page: paid-tier per-million-token rates for the current Gemini models, including the higher input rate above 200,000 tokens of context and the 50% batch cost reduction, read on the pageRetrieved
Foxnut AI takes on work like this from Bengaluru and Paris. If you want to see how we do it before you talk to anyone, here is what an AI engagement costs before you ask.