Open any model vendor's pricing page and the story is uniform: per-token prices have fallen all year, some tiers by more than two-thirds. Yet ask developers about their latest quarterly API bill and the answer is rarely cheerful. The unit price dropped; the bill did not. Nobody is lying - the number we call the per-token price simply hides real costs: models have become more verbose, cache hits and misses sit dozens of times apart, aggregators add service fees on top of list prices, and long-context and multimodal usage carry surcharge rules of their own. This article takes that hidden-cost stack apart and gives it a name: the unit-price illusion.
First, scope and sourcing. This review is compiled from multiple public sources, including pricepertoken.com, apirank, kingy.ai, llmapiprices.xyz and CSDN DevPress; it is not a hands-on test of every vendor. All prices carry a snapshot date and source, and each vendor's official page always takes precedence. On division of labor: our October 1 piece, coding-model-price-2026-10-review, answered "which flagship-alternative coding model to pick" - a different topic. This article does not rank model quality; it answers one question: why a cheaper list price does not guarantee a cheaper bill.
Reading the Price Sheet: Three Ledgers of Input, Output and Cache
The first step in reading a model's pricing is realizing it is not one ledger but three. Ledger one is input: the prompts, documents and conversation history you send in, billed at the input rate. Ledger two is output: what the model generates, typically several times more expensive per token than input. Take Moonshot AI's Kimi K3.1 Pro: its standard-tier API is priced at 13 yuan per million input tokens and 68 yuan per million output tokens (roughly 2 and 10 US dollars under the official dollar tier, with the Highspeed variant at twice that; figures per the official page). Output costs more than five times the input rate, so a "cheap prompts, chatty completions" pattern has a cost structure opposite to what the headline suggests.
Ledger three is the most overlooked: cache reads. Most major vendors offer a discounted cache-hit rate for prompt prefixes that repeat across requests, billing the repeated portion far below the normal input rate. In isolation it looks trivial; in some workloads it ends up dominating the whole cost structure, as a later section explains. Only the three ledgers together give the true unit price; choosing by the input rate alone is like judging a car by its fuel tank.
Illusion One: The Model Got Verbose
The first source of the illusion is the raw volume of output tokens, which is itself inflating. Artificial Analysis's testing shows that Kimi K3.1 Pro emitted roughly 150 million tokens of cumulative output to complete a full benchmark suite - nearly 1.7x the median of the models tested - earning it a "very verbose" label. Where from? The model tends to split tasks across parallel sub-agents, and intermediate calls stack layer upon layer, each with its own input and output, so token consumption snowballs.
The extreme case played out with a real subscriber. A user on the 199 yuan plan sent a single instruction - "review this project's architecture" - and the model spun up five sub-agents in parallel. About a dozen minutes later, the five-hour quota window was drained dry. The episode ended on October 26 with an official apology and a 25 percent top-up of the monthly quota. It exposed the mismatch between a time-windowed plan and a model whose token consumption has jumped an order of magnitude.
More telling is a second Artificial Analysis calculation: K3.1 Pro spent about $1.98 per completed benchmark task, essentially flat with the previous generation K3. The unit price fell; the per-task cost did not. The ride-hailing analogy fits: the per-kilometer fare got cheaper, but the driver took a longer route and the final bill came out the same. Call it the verbosity tax - it never appears on the pricing page, only in the invoice. Compare output rates per million tokens without knowing that verbosity can differ by 1.7x, and you are deciding in the wrong coordinate system.
Illusion Two: Cache Hits Are 50x Cheaper
The second illusion hides in the cache price. A June 21 snapshot by kingy.ai, quoting DeepSeek's official pricing page, listed V4 Flash input at $0.14 per million tokens while the cache-hit rate was just $0.0028 - a gap of fully 50x. The same prefix costs an order of magnitude less inside the cache than outside it.
The implication is direct. For workloads with a stable, reused prompt - a support bot with a fixed system prompt, a coding assistant carrying the same project document across hundreds of questions, a batch pipeline - optimizing the cache bill may beat switching to a cheaper model. Keeping the prefix byte-for-byte identical and requests within the cache window often cuts the bill more than any cross-model comparison. Conversely, if your prompts change on every call, the cache rate is irrelevant, and budgeting from the 0.0028 dollar figure is the illusion in its purest form.
One side observation reinforces the point: the official pricing captured by pricepertoken.com lists DeepSeek V4.1-Flash at 0.014 dollars input, 0.180 dollars output and 0.0029 dollars for cache reads with a 1M context, clearly different from the 0.14/0.28 figures in the kingy.ai snapshot. Two sites, two dates, two sets of numbers. Which is right matters less than the lesson: list prices are moving targets, so re-verify against the official page on the day you build a budget.
Illusion Three: Platform Markups and Surcharges
The third illusion lives outside the model price. First, aggregation markups: apirank's figures put OpenRouter's service fee at about 5.5 percent on top of the model price. That sounds small, but for a team spending tens of thousands a month it is a real annual cost. Aggregators sell convenience - one API for dozens of models, one unified bill; direct connections sell a lower rate. There is no universally right answer, but you cannot make the trade if you never noticed the 5.5 percent in your billing detail.
Second, the surcharges. A model advertising a 1M context window does not need every request to fill it, and some vendors apply separate billing tiers for very long contexts. Multimodal inputs such as images and audio are converted to tokens under their own rules. Reasoning mode and tool calls count toward output for some vendors and are billed separately by others - the rules are not standardized, so verify each vendor's official documentation before committing. Individually the surcharges look minor; stacked together they can drive a double-digit percentage gap between a list-price budget and the bill that actually arrives.
The Master Comparison Table
The table below consolidates the list prices discussed here. All figures are snapshot-tier data from the cited aggregators (dates noted), and the official pages always take precedence:
| Model | Input $/1M | Output $/1M | Cache read $/1M | Context | Billing notes |
|---|---|---|---|---|---|
| Kimi K3.1 Pro | approx. 2 (13 yuan, official USD tier) | approx. 10 (68 yuan, official USD tier) | not listed | see official page | Highspeed tier costs 2x; measured output is verbose, about 1.7x the median in cumulative tokens |
| DeepSeek V4.1-Flash | 0.14 | 0.28 | 0.0028 | 1M | cache hit vs miss differs by about 50x (kingy.ai June 21 snapshot quoting the official page); pricepertoken.com lists a separate 0.014/0.180/0.0029 tier |
| GLM-5.3 | 1.40 | 4.40 | not listed | see official page | a GLM-5.3-Flash tier exists at 0.15/0.50 (llmapiprices.xyz) |
| Qwen3.8-Max | 2.00 | 6.00 | not listed | see official page | llmapiprices.xyz capture |
| Qwen3.8-Flash | 0.15 | 0.47 | not listed | see official page | same source; the Flash tier suits high-volume light tasks |
| MiniMax M3 | 0.60 | 2.40 | not listed | see official page | llmapiprices.xyz capture |
| Mistral Large 4 (le Chonk) | 0.70 | 2.10 | not listed | see official page | official figures relayed by CSDN DevPress; open-weight license |
Three caveats. The many "not listed" cache cells mean the aggregator did not capture a rate, not that the vendor lacks one - check the official page. The two capture tiers on the DeepSeek row are themselves evidence of how fluid list prices are. And there is no value-ranking column - by now you know why: per-task cost is the only ranking that pays the bills.
Matching Workloads to Models
With the illusions dismantled, the practical advice is to match the workload first rather than chase the lowest number on a price sheet.
High-volume, routine text processing - cleaning, classification, summarization, format conversion - belongs to the Doubao Lite and Gemini 2.0 Flash tier. The scale is vivid: under apirank's June methodology with a 3:1 input-to-output ratio, 100 dollars buys roughly 5 billion tokens of Doubao Lite at 0.02/0.02, about 3.3 billion of Gemini 2.0 Flash at 0.03/0.06, about 714 million of DeepSeek V3 Chat at 0.14/0.28, and only about 125 million of Claude 3.5 Haiku at 0.80/4.00. The same budget stretches 4x to 40x; picking the wrong tier for a batch workload multiplies the bill.
Long documents plus Chinese-language work: the flagship tier of Chinese labs deserves a hard look on price-performance, with GLM-5.3, Qwen3.8-Max and MiniMax M3 all in that band. The fair way to choose is to run a small sample of your real documents through each first.
Agent and coding workloads: compute the cost per completed task before comparing unit prices. The 1.98 dollar case of K3.1 Pro shows how a verbose model can eat back an entire unit-price advantage. When choosing a model for agents, factor in intermediate call depth and average output tokens per task, and consider capping sub-agent parallelism.
Stable-prompt, multi-turn workloads: configure cache-aware billing. The 50x gap between 0.0028 and 0.14 dollars is the single most certain saving on any pricing page - provided your prefix really is stable.
Finally, self-hosting, which is often assumed to be the ultimate way to save. kingy.ai's analysis punctures that: self-hosting moves costs rather than deleting them - from the token bill to GPU purchases, memory capacity, engineering time, observability and utilization risk. A low-utilization GPU cluster can cost more than the API. The open-source tooling is genuinely mature; standing up a serving stack with vLLM has a low technical bar. But "it runs" and "it runs economically" are separated by an operations team. Teams whose data cannot leave the premises have no choice; everyone else should compute utilization first and talk self-hosting second.
FAQ
Q1: Why does the same model carry different prices on different platforms?
A1: Three reasons: capture dates differ and vendors adjust prices in between; aggregators add a service fee (OpenRouter's is about 5.5 percent per apirank); and price-tracking sites capture different tiers - one DeepSeek model appeared as both 0.014 and 0.14 dollars on two sites. Trust the official page on the day you buy.
Q2: How is the cache-hit price computed?
A2: Vendors bill the portion of a request that exactly matches a recent prompt prefix at the cache rate, and the rest at the normal input rate. The cache rate is far below normal input - DeepSeek's $0.0028 hit rate against a $0.14 miss is a 50x spread. Even one extra space or version number change can cause a miss, so treat byte-level prefix consistency as an engineering discipline.
Q3: How do I estimate my monthly bill?
A3: In four steps. Measure daily request volume and the input/output token distribution per request. Separate cache-hit from cache-miss shares. Multiply each ledger by its rate and sum. Then add platform fees and surcharges - long-context tiers, multimodal conversion, reasoning mode. Estimate from real request logs, never from pricing-page examples, and never assume output equals input.
Q4: Is the gap between cheap and expensive models really that large?
A4: The unit-price gap is enormous - the same budget buys 4x to 40x more tokens depending on the model. But the real bill also depends on verbosity (a 1.7x spread against the median is real) and on cache-hit behavior. For heavy workloads, compare cost per completed task; that is the number that matters.
Q5: Is self-hosting always cheaper?
A5: No. Self-hosting swaps the token bill for GPU purchases, memory, engineering time and operations, and a poorly utilized cluster can cost more than the API. The rule of thumb: self-hosting pays off when load is steady, scale is large, and data cannot leave your premises. For variable or mid-sized workloads, a direct API with cache optimization is usually the calmer, cheaper choice.
Related reading
- Half Price and 80 Percent Off: The Coding-Model Value Reshuffle - our October 1 piece on which flagship-alternative coding model to pick; a complementary angle to this pricing review.
- The AI Price War - the macro backdrop of the current discounting wave and why vendors keep cutting list prices.
- Local Deployment Memory SOP - companion hands-on guide covering memory estimation and setup for the self-hosting route.