LLM API Cost Comparison: Why Identical Per-Token Prices Can Lead to a 2x Monthly Bill
Large language model API pricing pages can look nearly identical on input and output rates, yet monthly bills can vary dramatically. This article breaks down an LLM API bill into base token costs, cache write and hit costs, batch discounts, subscription credits, off-peak scheduling, and regional premiums. It compares representative platform pricing, provides a reusable cost model, and offers a practical decision framework for real-time, offline, and legacy-model scenarios. The main takeaway: the monthly bill is determined not only by per-token prices, but by billing rules, usage patterns, and architecture choices.
LLM API Cost Comparison: Why Identical Per-Token Prices Can Lead to a 2x Monthly Bill
Many teams that have already launched LLM-powered applications have experienced the same surprise during a quarterly cost review: two business lines use roughly the same call volume, but one spends only 60% of what the other does on inference. When you go back and compare the price tables, the input price and output price are identical.
This points to one important fact: the per-token unit price is only one factor in the bill. It is not the bill itself.
This article does not try to answer “Which provider is cheapest?” Instead, it answers four questions:
- What layers make up a monthly LLM API bill?
- If the published per-token prices are aligned across platforms, where else can cost differences come from?
- How should you choose between platforms for real-time conversation, offline batch processing, and legacy model migration?
- Which “seemingly harmless” contract terms can become the most expensive hidden costs?
One important caveat first: LLM pricing pages, regional pricing, and limited-time promotions change frequently. The conclusions in this article are based on publicly verifiable pricing information as of November 2026, checked on November 17 and November 19, 2026. Any specific number should be treated as a snapshot. Before making a decision, always check the current official pricing page of the platform you intend to use. The real goal of this article is not to provide a quote that will expire, but to deliver a reusable cost-evaluation framework.
1. The bill has four layers: start with the model, then optimize
Before comparing platforms, you need to understand how a monthly bill expands. For a typical LLM API consumer, the bill can be written as:
Monthly bill =base token charges (accumulated item by item from usage logs)+ cache write charges (incurred when filling or extending a cache)- cache hit discounts (hit tokens are billed at the hit price)- asynchronous batch discounts (offline jobs are billed at a discounted rate)- subscription credit / off-peak discounts (reductions from prepaid plans or time-based pricing)+ overseas-region premiums and taxes (cross-border deployment and billing differences)
In these four layers, the first layer determines the baseline, while the remaining three determine where you actually land relative to that baseline. Most debates about “same unit price, different bill” happen because the first layer is aligned, but the later layers are not.
1.1 Layer 1: base token charges
The standard billing formula is usually:
input tokens × input price + output tokens × output price
Prices are commonly expressed per million tokens. Three details are easy to overlook:
- Billing is based on tokens, not characters. In Chinese, roughly 1 Chinese character is about 1–2 tokens. In English, roughly 1 word is about 1.3 tokens. Estimating cost by character count often introduces errors of more than 30%.
- Input and output prices can differ significantly. In the example price table below, the flagship model’s output price is five times its input price. This means that a summarization workload with long input and short output has a completely different cost structure from a generation workload with short input and long output, and the optimization methods are also different.
- Multimodal and tool calls can amplify output costs. Structured output, such as JSON with a fixed schema, may not contain many tokens itself, but retries caused by failed calls or format correction can significantly increase actual consumption. This is usually discovered through observability, not through the price table.
1.2 Layers 2 and 3: caching
Prefix caching, also known as prompt caching, is becoming a basic capability across mainstream model services. When multiple requests share the same prefix, such as a system prompt, few-shot examples, or a long document body, the service can reuse the already-computed KV state for that prefix and only perform a forward pass on the newly added suffix. The hit portion is billed at the cache-hit price, while the missed portion is billed at the normal input price.
The key conclusion is: the cache hit rate directly determines the lower bound of input costs. In a typical price table, the cache-hit price is about one-tenth of the input price. In other words, if a workload has a stable 60% hit rate, its input cost can drop to about 46% of the theoretical uncached cost. This is usually the optimization with the highest return on investment, and it is almost independent of which platform you choose, because most major platforms either support it or do not.
2. Horizontal comparison: four platform types, one aligned price table
The table below reflects verifiable information at the time of writing. It uses four representative platform categories:
- an official model developer platform;
- a public cloud provider’s managed model service;
- a cloud provider’s AI development platform;
- a third-party model aggregation platform.
In this article, “home region” refers to the platform’s primary local region. Overseas-region pricing is discussed separately later. Two other public cloud providers did not list this model family at the time and therefore could not be included in the comparison. This is itself an important signal: the number of viable options is often smaller than expected.
Unit: CNY per million tokens. Format: input / cache hit / output.
| Model tier | Official developer platform | Public cloud managed model service (home region) | Cloud provider AI platform (home region) | Third-party aggregation platform | Rules that can create differences |
|---|---|---|---|---|---|
| Flagship | 20 / 2 / 100 | 20 / 2 / 100 | 20 / not listed / 100 | 20 / 2 / 100 | Batch processing at 60% of standard price |
| Balanced (Pro) | 13 / 1.3 / 68 | 13 / 1.3 / 68 | 13 / 1.3 / 68 | 13 / 1.3 / 68 | Free credits for new models |
| Light coding | 6.5 / 1.3 / 27 | 6.5 / 1.3 / 27 | 6.5 / not listed / 27 | 6.5 / 1.3 / 27 | Subscription plan and off-peak rules |
| Previous generation | No longer open to new users | Follows upstream provider | Follows upstream provider | Follows upstream provider | Retirement countdown |
Source: official platform pricing pages, verified on 2026-11-17.
Three things can be read from this table
First, usage-based pricing has become highly homogeneous. The input and output prices for the three active tiers are identical across the four platform categories. This means the question “Which platform has a cheaper unit price?” has lost most of its value in 2026. Platform selection should be based on the rules table, not just the price table.
Second, cache-hit pricing is not always publicly listed. One platform does not show a cache-hit price for the flagship and light coding tiers on its pricing page. This is not a minor detail. If your workload depends heavily on prefix caching and the selected platform does not clearly state the cache-hit price, you cannot accurately budget costs or verify savings on the bill. The completeness of pricing information is itself a selection criterion.
Third, the rules that create real differences are concentrated in two areas: batch discounts and subscription plans. The official platform explicitly offers a 60% batch discount for the flagship and balanced tiers. The third-party aggregation platform emphasizes subscription plans and off-peak discounts. These are the main sources of the cost gap analyzed later.
3. Four overlooked rules that determine where you land on the bill
The following terms come from official pricing pages and documentation, verified on 2026-11-19.
3.1 Cache writes also cost money, and TTL can be a double-edged sword
Caching is not free. The current mainstream billing logic generally works as follows:
- Repeated requests with the same prefix automatically reuse the cache, with a default TTL of 5 minutes.
- Writing a cache for the first time, or explicitly writing for a longer TTL such as 1 hour, may be charged separately.
- After a cache hit, only the cache-hit price is charged.
The implication is straightforward: a low hit rate plus a short TTL is a double waste. You pay for the cache write but fail to get enough hits. On the other hand, a long TTL is suitable for stable prefixes such as system prompts plus long documents. The write cost is paid once, and subsequent requests over the next few hours benefit from the discounted hit price.
3.2 The previous-generation model is being retired
Starting from October 31, 2026, the previous-generation series is no longer open to newly registered users. It is planned to be fully retired by the end of December, and the official recommendation is to migrate to the Balanced (Pro) tier.
This is a financial issue, not just a technical issue. If a business is still using a previous-generation model, it faces several risks: new users may not be able to reproduce the same call path, the model may be retired unexpectedly, and a forced migration may cause a bill change that cannot be estimated in advance. The question is not whether to migrate, but when to migrate and according to which mapping table.
3.3 Overseas regions are more expensive, and the billing currency may differ
Cross-border deployment can introduce two layers of premium. Using the flagship model as an example, the home-region price is 20 / 2 / 100 CNY, while the Singapore region is approximately 21.974 / — / 109.869 CNY for the public cloud managed model service and approximately 21.875 / — / 109.9 CNY for the cloud provider AI platform. This means input is about 10% more expensive and output is about 10% more expensive. Some platforms bill in USD, and exchange-rate and tax effects may also apply during settlement.
If your workload has clear regional compliance requirements, this cost must be included in the budget in advance. If the only reason is “closer network access,” confirm that your users are actually in that region.
3.4 Free credits are limited-time and should not be treated as long-term savings
The cloud provider AI platform offers 1 million free tokens for new models. This credit is valuable during the validation phase because it may be enough to complete a round of quality evaluation and load testing. However, it is one-time. If you include it in a monthly cost model, your budget will be understated from the very first month.
4. Calculating the bill: a reusable cost model
The rules above are useful, but they become more valuable when turned into something you can calculate.
4.1 Basic estimation function
from dataclasses import dataclass@dataclass(frozen=True)class Price:input_per_mtok: float # CNY per million input tokenscache_hit_per_mtok: float # CNY per million cache-hit tokensoutput_per_mtok: float # CNY per million output tokens# Example prices (CNY per million tokens); always verify against the platform's current pricing page.FLAGSHIP = Price(20.0, 2.0, 100.0)BALANCED = Price(13.0, 1.3, 68.0)LIGHT = Price(6.5, 1.3, 27.0)def bill(mtok_in: float,mtok_out: float,cache_hit_ratio: float = 0.0,price: Price = FLAGSHIP,batch: bool = False,plan_factor: float = 1.0,offpeak_share: float = 0.0,offpeak_factor: float = 1.0,) -> dict:"""Estimate monthly cost.plan_factor < 1 represents a subscription-plan discount.offpeak_share is the share of calls that fall into an off-peak window."""hit = mtok_in * cache_hit_ratiomiss = mtok_in - hitbase = (miss * price.input_per_mtok+ hit * price.cache_hit_per_mtok+ mtok_out * price.output_per_mtok)if batch:base *= 0.6 # asynchronous batch discounttime_factor = offpeak_share * offpeak_factor + (1 - offpeak_share)total = base * plan_factor * time_factorreturn {"base_cost": round(base, 2),"after_subscription": round(base * plan_factor, 2),"after_offpeak": round(total, 2),"savings_vs_usage": round(1 - total / base, 4),}
4.2 A medium-sized workload example
Assume:
- 30 million input tokens per month;
- 40% of input tokens hit the prefix cache;
- 9 million output tokens per month;
- flagship model tier.
bill(mtok_in=30, mtok_out=9, cache_hit_ratio=0.4, price=FLAGSHIP)# {'base_cost': 1284.0, 'after_subscription': 1284.0, 'after_offpeak': 1284.0, 'savings_vs_usage': 0.0}
With pay-as-you-go pricing and no optimization: 1,284 CNY per month.
Now apply three rules one by one:
| Plan | Parameters | Monthly cost | Difference from baseline |
|---|---|---|---|
| Pure usage-based | — | 1,284 CNY | Baseline |
| Subscription + overage usage | plan_factor=0.88 |
1,130 CNY | −12% |
| Better subscription tier | plan_factor=0.76 |
976 CNY | −24% |
| Subscription + half of calls shifted to off-peak | plan_factor=0.88, offpeak_share=0.5, offpeak_factor≈0.18 |
about 668 CNY | about −48% |
The same workload costs 1,284 CNY or 668 CNY depending on the combination of billing method and scheduling. This is the full answer to “same unit price, half the bill”: the difference is not the price table itself, but the combination of time-window scheduling and billing mode.
The off-peak discount factor in the last row is an illustrative parameter derived from disclosed discounts. The combined discount is 0.52, the subscription discount is 0.88, and the off-peak share is 0.5; solving backward gives an effective off-peak factor of about 0.18. It is used only to show the order of magnitude. The actual factor should be based on the time-based pricing terms of the platform you use.
4.3 Scheduling calls into off-peak windows: a simple dispatch skeleton
The most valuable row in the table above is not difficult to implement. The core idea is to tag requests as “deferrable” and place them into a queue that is consumed during non-peak periods.
# Tag business tasks: distinguish "must be real-time" from "can wait"DEADLINE_TOLERANT = {"offline_eval", "batch_summary", "embedding_backfill", "log_enrich"}def dispatch(task):if task.kind in DEADLINE_TOLERANT and task.deadline - now() > SAFE_MARGIN:queue.publish(task) # message queue; consumed during off-peak windowselse:return call_model(task) # synchronous real-time call
A production-grade implementation usually needs several things:
- Deadline awareness. “Deferrable” does not mean “can be delayed forever.” Tasks must carry a deadline. When the deadline approaches, they should unconditionally go through the real-time path to avoid backlog buildup and SLA breaches.
- Idempotency keys. Retrying the same request must not create double charges. This is the only reliable defense against retry storms.
- Queue backlog alerts. Off-peak windows have capacity. If the backlog exceeds a threshold, either scale out consumers or temporarily allow requests through the real-time path and accept a higher cost.
- Artifact storage. Batch input and output should preferably be stored in object storage, with lifecycle policies to clean up intermediate files. Otherwise, storage costs may erase the savings from inference.
4.4 How much can downgrading the model save?
Going back to the price table, the price gap between tiers is substantial. Using the flagship tier as 100%:
| Tier | Input price index | Output price index |
|---|---|---|
| Flagship | 100% | 100% |
| Balanced (Pro) | 65% | 68% |
| Light coding | 33% | 27% |
Moving from flagship to Balanced (Pro) saves about 35% on input and 32% on output. If the workload is code completion or structured extraction, moving down to the light coding tier can cut output costs by roughly three-quarters.
This is the largest cost-reduction lever, but only if you have an evaluation set. Without your own evaluation set, downgrading a model is a gamble.
A practical rollout sequence is:
- Build an evaluation set of 200–500 real-traffic examples with standard answers.
- Run the lower-tier model and measure pass rate.
- If the result is acceptable, canary 10% of traffic.
- Observe business metrics for two weeks, including not only accuracy but also manual correction rate and timeout rate.
- Roll out to all traffic.
5. Decision matrix: how to choose for four common scenarios
| Scenario characteristics | Recommended path | Reason |
|---|---|---|
| Not locked to a specific model; quality target is sufficient | Use Balanced (Pro) with pay-as-you-go pricing; any platform can work | Unit prices are aligned; output cost is about 32% lower; switching flexibility is preserved |
| Workload can be offline or delayed, such as evaluation, summarization, backfilling | Choose a platform that offers a 60% batch discount and use asynchronous batch processing | For the same volume, a 4,000 CNY bill can become about 2,400 CNY, with little extra engineering complexity |
| Locked to flagship tier and mostly real-time calls | Subscription plan + overage usage; prefer a platform with off-peak discounts | 12%–24% lower than pure usage-based pricing; if half the calls are shifted to off-peak, savings can approach 48% |
| Existing workload already runs on a public cloud | Use that cloud provider’s managed model service if available | The unit price may match the original provider, while avoiding cross-network traffic and data-egress costs |
| Regional compliance requirements exist | Prefer the home region; if overseas deployment is truly required, budget about 10% premium plus taxes | Overseas regions can be about 10% more expensive for both input and output, and the billing currency may differ |
One additional recommendation: do not put all eggs in one basket, but do not adopt multi-cloud just for the sake of multi-cloud. Keeping an access layer compatible with at least two platforms—through a unified abstraction interface and configurable endpoints—costs almost nothing, but it gives you flexibility if one platform experiences rate limiting, outages, or price increases. However, do not hard-code business logic around one provider’s proprietary parameters. That is one of the most common failure modes in multi-cloud architecture.
6. Launch checklist
Review the following items before launch. They can prevent most unexpected bills.
Pricing and terms
- Confirm whether the platform’s current pricing page lists the target model. If it is not listed, it is not selectable.
- Confirm whether the cache-hit price is publicly listed. If it is not listed, budgeting and verification are difficult.
- Confirm the batch discount ratio and which model tiers it supports.
- Confirm the subscription plan’s billing cycle, overage price, and off-peak window start and end times.
- Confirm the billing currency, tax treatment, and whether there are limited-time free credits.
Model lifecycle
- Maintain a mapping table from model versions to business lines.
- Record retirement announcement dates for all models in use, and plan migration at least one quarter ahead.
- Define a downgrade mapping: flagship → balanced → light, with baseline evaluation scores attached.
Cache strategy
- Put system prompts, few-shot examples, and long documents at the beginning of the prompt. Put changing content after them.
- Use explicit writes with a longer TTL for stable prefixes. Do not let dynamic content pollute the cache.
- Monitor hit rate. If it is lower than expected, check whether timestamps or random IDs are breaking the shared prefix.
Observability and budgeting
- Log every call with model tier, region, cache hit or miss, time window, token count, and estimated cost.
- Use a log service for detailed retention. Configure alerts at both “by business line” and “by model” dimensions.
- Set monthly budget threshold alerts, such as warning at 70% and escalation at 90%.
- Require retries to include idempotency keys and a maximum retry count.
7. Conclusion
Returning to the original question: if four platforms have exactly the same unit prices, why can their monthly bills differ by half?
Because the unit prices may be the same, but the rules are different. Cache-write TTL terms, batch discount scope, subscription-plan off-peak windows, and regional premium calculation rules are all potential sources of difference. When any one of these layers is applied to millions of tokens, it can produce a bill difference close to 50%.
The recommended order of actions, ranked by return on investment, is:
- Optimize caching first. This can take half a day, can reduce input costs by 30%–60%, and is largely independent of platform choice.
- Build an evaluation set and consider model downgrade. This can take about a week, can reduce output costs by 30%–70%, and has the largest potential impact.
- Send offline tasks through batch processing. This costs almost nothing and can directly save about 40%.
- Evaluate subscription plans for real-time workloads. If half of the calls can be shifted to off-peak windows, the bill can nearly be halved.
- Choose the platform last. In many cases, you may find that the unit price is effectively the same everywhere.
For Baidu AI Cloud and similar model-service platforms, the final evaluation should focus on three practical questions: whether the pricing rules are transparent, whether discounts are verifiable, and whether model retirement is announced with sufficient advance notice. Using these three criteria as scoring dimensions is far more useful than comparing prices to several decimal places.
Finally, model-service pricing and rules change frequently. All specific numbers in this article should be treated as snapshots at the time of verification. Before implementation, always check the current official pricing page of the platform you use, and plug your own usage parameters into the cost function in section 4.1. Your own numbers are more reliable than anyone else’s conclusions.
