If you use an AI subscription heavily, you eventually find a usage stat: tokens consumed, broken down by model. The obvious question follows: what would the same volume have cost through the API? You multiply quantity by price, divide by the subscription fee, and get an impressive number. The number is real. It still means less than it promises. This can be shown cleanly, and the result explains why cheaper tokens don't make the bill smaller.
The concrete case: 230 million tokens in 47 days, spread across four models. What was paid was a subscription of around 200 US dollars a month, so about 313 US dollars over 47 days.
| Model | Input | Output |
|---|---|---|
| Opus 4.8 | 24.5 M | 186.5 M |
| Opus 4.7 | 0.018 M | 1.5 M |
| Fable 5 | 2.4 M | 14.0 M |
| Haiku 4.5 | 0.31 M | 0.87 M |
The calculation at current prices
The relevant prices are in Anthropic's price list. For the four models used, a million tokens cost:
| Model | Price (in / out) | Total |
|---|---|---|
| Opus 4.8 | $5 / $25 | $4,785 |
| Opus 4.7 | $5 / $25 | $38 |
| Fable 5 | $10 / $50 | $724 |
| Haiku 4.5 | $1 / $5 | $5 |
| Total | $5,551 |
That comes to about 5,550 US dollars. Against roughly 313 US dollars of subscription cost for 47 days, it is about eighteen times as much.
A note on the numbers: the input value looks low compared to the output. With agentic use it is usually the other way around, because a lot of context is read in. The stat probably does not count cached tokens. In real API use, prompt caching would make the input share even cheaper. It barely changes the result, because the output tokens drive the price.
The actual reasoning error
That leaves the question of what the number actually measures. It does not measure what the compute costs Anthropic, because the list price includes margin. And it does not measure the value received. It only measures what the same token volume would have cost at the unit price, under an assumption that almost never holds: that you would have consumed the same volume if every token had cost money.
That is the core. You generate 186 million output tokens on Opus because they feel free under the subscription. At 25 US dollars per million, visible with every call, you would have stopped in many places, phrased things shorter, run fewer agents in parallel. The flat rate did not just pay for the usage, it created it.
Cheaper never meant less
This pattern is old and well documented. The economist William Stanley Jevons described in 1865 that Britain's coal consumption rose after James Watt's more efficient steam engine reduced the coal needed per unit of work. Efficiency made coal cheaper per unit of use, so it was applied to more and more purposes. On balance, consumption rose rather than the savings. The principle is known today as the Jevons paradox.
The essay Cheaper Never Meant Less applies this to AI tokens. According to the text, token prices fell by roughly a factor of ten per year over several years, and total bills still rose, because the quantity demanded grew faster than the price fell. As a historical parallel it cites artificial light, which since 1800 fell to about one three-thousandth of its price, while per-capita consumption rose by roughly six thousand times according to the cited data. Its line: "Cheaper tokens didn't shrink anyone's bill. They made enormous asks feel affordable."
Applied to a single person, this means the factor of 18 is not pure gain that you pocket. Part of it is usage that would never have existed without the flat rate. The pricing model expanded the appetite, it did not only cap the price.
And the models now use more tokens for the same task
A second effect adds to this, and it comes from the models, not the user. Current models think before they answer. That thinking is made of tokens, generated internally and billed along with the rest, even though you usually never see them. An older model answered the same question more directly and used far fewer tokens doing it.
So for the same task, token consumption rises from one model generation to the next. A question that used to be answered in a few hundred tokens now costs a multiple, because the model works out a line of reasoning. On complex tasks this is intended and improves the result. On simple tasks you pay for it anyway.
Two things follow for the value calculation. First, comparing token counts across model generations is not a fair comparison, because the same task now ties up more tokens. Second, part of the output tokens is not a visible answer at all, but the model thinking. So you are converting tokens into money when a substantial share of them are internal intermediate steps.
Why a company offers this
That leaves the question of why a 200 US dollar subscription allows usage that would be worth a multiple at list prices. Three factual points, no speculation.
First, buffet logic. Every flat rate loses on the heaviest users and earns on the light ones. The typical subscriber consumes a fraction of a power user. That the math looks negative for one person does not mean the product loses money overall.
Second, the cap. Rate limits bound exactly this case. The loss per user has an upper limit, it is not open ended.
Third, the difference between list price and marginal cost. What an extra token costs Anthropic is well below the sale price. The apparent loss at list prices is smaller at marginal cost.
Everything beyond that is a hypothesis. You can assume that cheap consumer subscriptions build habit, usage signals, and word of mouth that pay off later through enterprise and API contracts. That is a known pattern, but a guess, not an established fact. Anyone who sells it as a certain explanation confuses a plausible story with proof.
Conclusion
The honest version of the calculation is this: at current list prices this usage volume would be billed at roughly 5,550 US dollars, about eighteen times the subscription fee. For a heavy user that is a real advantage. But the number measures less saving than it claims. Part of the volume only came into being through the pricing model, and part of the tokens is the models thinking, not a result you would otherwise have paid for.
The more interesting insight sits underneath. Cheap and flat prices do not simply lower costs, they change behavior and tooling. You make larger requests, and each request ties up more tokens than before. So if you want to know what a token really costs, you need to know not only the price, but also how much more ends up going through the pipe once that price is low enough.


