118× Price List, 380× Bill: The Three Multipliers Behind Model Costs
How usage and retries multiply model costs.
AionRouter Team ·
Two companies use the same model for the same task, yet their monthly bills differ by a factor of five. This happens every month, and the reason usually has little to do with negotiation.
Price lists are laid out linearly by token. Each row lists input, output, and cached-input prices—neat, comparable, and easy to screenshot and share. But a bill does not come from that row alone. It comes from multiplication: unit price, usage, and retry count.
The problem is that only the first multiplier appears on the price list.
1. Price Lists Are Linear. Bills Are Not.
Start with a familiar set of numbers. Across the 152 models currently available, input prices range from $0.085 to $10 per million tokens, and output prices from $0.425 to $50—a roughly 118-fold difference at both ends. That is all the public price list can tell you.
Comparing models then looks deceptively simple: sort by price and pick a cheap one, or sort by capability, pick a powerful one, and accept the premium. Both approaches are valid, but both capture only a small part of the bill.
The actual bill works like this: unit price multiplied by usage, then multiplied by the number of attempts required because of failures. The provider sets the first multiplier. Your system design determines the other two. And their effect on the final amount can often exceed that of unit price itself.
The next three sections unpack these multipliers one by one.
2. The First Multiplier: Unit Price Is a Set of Numbers
Even unit price is more than a single figure for “dollars per million tokens.”
First, there is the ratio between input and output prices. Among the 120 models with a listed output-to-input pricing ratio, the median is 5.0×, with a range of 1× to 20×. Twenty models charge the same for input and output—not just multimodal models for video and audio, but also mainstream text models such as claude-sonnet-5-5 and grok-4.5.
This ratio determines which side consumes your budget. For a request with 1,000 input tokens and 1,000 output tokens, output accounts for 83% of the bill on a model with a 5× ratio, versus just 50% on a model with a 1× ratio. The most effective cost-cutting measures therefore differ: for a 5× model, shortening responses, constraining structured output, and reducing revision rounds offer the greatest returns; for a 1× model, compressing context and input passages becomes the main lever. Apply the same cost-saving method to every model, and the results will naturally be inconsistent.
Next comes the depth of the cache discount. Among the 78 models with listed cache prices, the median cached-input price is 0.1 times the standard input price—a 90% discount. But the range is wide: the cheapest tier charges 2.5% of the standard rate, while the most expensive charges 50%, a 20-fold difference.
The value of a “cache hit” therefore depends on the model. At a 2.5% rate, cached input is almost free, making it worthwhile to restructure prompts around caching. At a 50% rate, a hit only halves the cost, so the return on engineering effort needs a fresh calculation. Many teams build caching layers without first checking whether their model’s cache multiplier is 0.025 or 0.5.
There is also the link between group discounts and rate limits. Currently, 29 models offer group discounts of 10% to 20%. But a discount is more than a coupon: it comes with different rate limits. The standard group has median limits of roughly 500 requests per minute and 1 million tokens per minute, while discounted groups have median limits of roughly 10,000 requests per minute and 10 million tokens per minute.
This is a pricing structure tiered by scale: the lower-priced tier has much higher throughput limits. Viewed from the other direction, if your workload consists of infrequent, bursty, token-heavy tasks, the standard group may hit its TPM ceiling sooner. Negotiate price and limits together, or rate limiting may take back what you saved on unit price.
3. The Second Multiplier: Usage Is What the Model Reads
The token count on the bill is almost always higher than engineers expect. The reason is simple: you write a question, but the model reads the system prompt, tool definitions, conversation history, retrieved passages, and the previous response.
This creates two structural realities.
First, input capacity can be enormous, while output remains constrained. Across the 152 models, the median context window is 1 million tokens, but the median maximum output is only 128,000 tokens—roughly one-eighth of the context window. You can pile a million tokens into the context, but the response still has a hard ceiling. When output is cut off at that ceiling, the result is often a failed attempt followed by a retry, rather than simply a shorter answer. Cost jumps straight from the first multiplier to the third.
Second, cache savings are a product, not a switch. The actual savings rate is the cache hit rate multiplied by one minus the cached-input price multiplier. An 80% hit rate on a model with a 0.1 cache multiplier saves about 72%; the same hit rate on a model with a 0.5 multiplier saves only about 40%. The hit rate itself depends on three things: whether the prefix is stable, whether the assembly order is consistent, and whether the model supports caching.
The usage multiplier, then, is never settled at the moment you write a prompt. It is shaped by retrieval precision, history-trimming policies, redundant tool definitions, and cache-prefix design. Usage is designed.
4. The Third Multiplier: Retries, the Cost Missing from Every Price List
Now for the most easily overlooked factor.
A price list describes the price of the successful attempt. But a request does not always succeed. Once success rate is factored in, expected cost becomes unit price divided by success rate—the cost amplification caused by retries.
Run the calculation using real-world performance samples from 45 models, and the differences become hard to ignore:
Prices below are in USD per million tokens; times are in seconds.
| Model | Listed price | Success rate | Effective cost | Average latency | Expected time to success |
|---|---|---|---|---|---|
| claude-fable-5-1 | $10 / $50 | 30.5% | $32.75 / $163.77 | 12.7 | 41.6 |
| claude-fable-5 | $10 / $50 | 100% | $10.00 / $50.00 | 28.4 | 28.4 |
| gpt-6-astra | $10 / $50 | 80.8% | $12.38 / $61.90 | 5.3 | 6.5 |
| qwen3.8-max | $2 / $6 | 20.0% | $10.00 / $30.00 | 15.8 | 79.0 |
| claude-sonnet-5-5 | $2 / $10 | 99.0% | $2.02 / $10.10 | 18.1 | 18.3 |
| gpt-6-luna | $0.10 / $0.50 | 99.8% | $0.10 / $0.50 | 13.7 | 13.7 |
| gpt-4o-mini | $0.15 / $0.60 | 100% | $0.15 / $0.60 | 2.5 | 2.5 |
Three things in this table deserve a closer look.
First, two consecutive versions in the same family have identical prices, yet their effective costs differ by 3.3×. Both claude-fable-5 and claude-fable-5-1 list prices of $10 / $50, but the former has a 100% success rate and the latter 30.5%. After adjusting for success rate, the newer version’s effective output cost is $163.77, compared with $50 for the older version. Their speeds make the comparison even more interesting: the newer version averages 12.7 seconds, versus 28.4 seconds for the older one. In other words, the newer version trades greater speed for greater expense. Looking only at speed or only at listed price can lead to conflicting conclusions.
Second, a “cheap model” may be anything but cheap. qwen3.8-max lists prices of $2 / $6, less than one-fifth of flagship pricing. But a 20% success rate translates that into $10 / $30, putting it in flagship territory. Its expected time to success is 79 seconds, the slowest in the table. Ranking by unit price breaks down completely here.
Third, expected time to success belongs alongside cost as a core metric. What users experience is the average time until they get a result: latency divided by success rate. The fastest model in the table, gpt-4o-mini, takes 2.5 seconds, versus 41.6 seconds at the slow end—a 16-fold difference that appears on no price list.
The methodology behind this table needs to be explicit to prevent misuse. First, these are upper-bound estimates: they assume failed requests are billed at the same rate and require a full retry. If a failure occurs before the first byte arrives, or the provider does not charge for error responses, actual costs will be lower. Second, success rates include factors beyond the model: client timeouts, context-limit violations, interrupted tool calls, and stalled streaming connections all count as failures. Flagship models also tend to handle the heaviest tasks, which are most likely to time out. Third, falling back to another model changes the cost structure—the calculations in this section apply only to retries on the same model.
With those qualifications in place, the conclusion becomes clearer: precisely because success rate depends on the workload, it must enter model-selection decisions alongside unit price. Looking at either one alone invites misjudgment.
5. Between 118× and 380× Lies Judgment
Return to the opening numbers. The largest listed-price difference is roughly 118×. After adjusting for success rate, the largest effective-cost difference is roughly 380×.
About one-third of that gap comes from the price list; the rest comes from workload and reliability. There is a structural reason for this amplification: expensive models typically handle the heaviest, most uncertain tasks, so their success rates are lower. Cheaper models more often handle classification, extraction, and short Q&A, so their success rates approach 100%. The expensive models become more expensive after adjustment, while the cheap ones remain cheap—the Matthew effect is a consequence of the pricing formula itself.
This does not mean expensive models are poor value. Quite the opposite: if your task requires one, an effective cost of $163.77 may still be reasonable because it buys capability unavailable elsewhere. But you need to know what you are paying for: capability or failure. Those two expenses require entirely different approaches to optimization.
6. Four Rules You Can Apply Immediately
First, replace token-based accounting with business-based accounting. Measure cost per support ticket, code review, video, or thousand questions answered. Only at the business-unit level do the three multipliers combine into a comparable number.
Second, check the input-to-output price ratio before choosing what to optimize. On a 5× model, reducing output is most effective; on a 1× model, compressing context is most effective. Work in the wrong direction, and your effort delivers less.
Third, add an “effective unit price” column to your model-selection table. Calculate it as listed price divided by success rate. This column will change the rankings, and the revised rankings will usually track real bills more closely.
Fourth, design for caching. Check the target model’s cached-input price multiplier before investing engineering effort in prompt restructuring. Cache hits come from stable prefixes and consistent assembly order.
If there is a fifth rule, it is this: negotiate rate limits alongside discounts. Price, requests per minute, and tokens per minute are two sides of the same pricing structure. Negotiate only one side, and the other will return in the form of rate limiting.
7. Cost Is Designed
Of the three multipliers, only the first is set by the provider. Usage is determined by how you manage context. Retries are determined by your timeout, retry, and fallback policies.
That is why we put these numbers in the same interface: the Model Hub provides prices and billing parameters, while Performance Monitoring provides latency and success rates. Put them side by side, and effective cost becomes calculable. A price list can tell you what one token costs. That has never been the whole bill.
Your bill is a function of how well you understand the task. The more precisely you understand it, the smaller the multipliers become.
— The AionRouter Team
Data Sources and Methodology
Pricing: Taken from billing configurations in the AionRouter Model Hub, including actual prices after group discounts. Covers 152 available models as of November 5, 2026.
Performance: Average request latency and request success rates collected across the serving pipeline for 45 models. Samples include real-world requests of widely varying lengths and are affected by client timeouts, context length, and streaming connection status. They are not model capability benchmarks.
Effective cost: Estimated as “listed price ÷ success rate” and treated as an upper bound. Assumes failed requests are billed at the original rate and require a full retry. Actual costs are lower if failures occur before the first byte arrives or the provider does not charge for them. Intended only for comparative analysis and does not constitute procurement advice.
Billing parameters: Input-to-output price ratios, cache multipliers, output limits, and rate limits are taken from public configurations in the Model Hub. These may change between versions; consult the live pages for current values.