LLM API Pricing: Sticker Price, Subscription Multipliers, and Real Task Costs

    This article explains why comparing LLM API list prices alone can lead to misleading conclusions. It separates three cost perspectives—per-token list price, effective subscription price, and real task consumption—and examines cache-hit pricing, subscription usage multipliers, benchmark token consumption, and a practical cost-estimation framework for developers and enterprises.

    1. Background: Why a New Model Generation Raised Prices

    A Chinese LLM vendor recently released a new flagship model with API pricing noticeably higher than the previous generation: output price rose to about five times the previous level, input price increased as well, while cache-hit pricing remains very low. The change sparked intense discussion in developer communities. Some argued that strong benchmark rankings justify the higher price, while others compared the pricing structure with international vendors and concluded that actual usage costs may be significantly higher than the surface impression suggests.

    To evaluate this rationally, it is necessary to distinguish three easily confused concepts: list price per token, effective price from subscription plans, and real task consumption cost. These are different measures, and direct comparisons based only on list prices often produce distorted conclusions.

    2. List Price Comparison: Whether It Is Expensive Depends on the Reference Point

    From public list prices, the new generation model’s output price is in the hundreds of RMB per million tokens, input price is in the tens of RMB per million tokens, and cache hits cost only around one RMB per million tokens. This structure has three notable features:

    1. Cache-hit pricing is extremely low. For scenarios with long system prompts and high multi-turn reuse—such as fixed personas or long-document RAG retrieval—caching can significantly reduce effective cost. The list price may look high, but if the cache hit rate exceeds 50%, the amortized cost may be far below the list price.

    2. The input-to-output price ratio is about 5:1. This is consistent with mainstream industry pricing structures and reflects the much higher compute cost of the generation stage—autoregressive decoding—compared with the understanding stage, or prefill.

    3. Comparison with international flagships. For same-tier flagship models from international vendors, output pricing is usually several times higher, and the input/output price gap can even exceed 20:1. Therefore, from the perspective of “price per token,” the Chinese model still has a price advantage.

    3. Subscription Plans Are the Hidden Pricing Battlefield

    What truly affects the experience of ordinary developers is often not the API list price, but the implicit “exchange rate” of subscription plans. International vendors commonly use subscription models:

    • A plan priced at around USD 20 typically allows consumption of API usage worth USD 400–800.
    • A top-tier plan priced at around USD 200 can imply usage worth tens of thousands of dollars.

    In other words, subscribers receive a usage multiplier of dozens of times. Such plans are possible partly because rate limits, time-based scheduling, and downgrade routing control marginal costs, and partly because vendors use low prices to gain ecosystem adoption, data feedback, and developer stickiness.

    By contrast, a typical Chinese model plan is priced at 199 RMB. Converted at API list prices, the implied usage is roughly in the 1,200–2,800 RMB range, a multiplier clearly lower than that of international vendors. This is the real focus of community discussion: the unit price is cheaper than international competitors, but the subscription “value multiplier” is much lower.

    4. Consumption Is the Final Judge: Benchmark-Based Reference

    Whether a price is expensive ultimately comes down to “how much it costs to complete a typical task.” Third-party evaluation data shows that the new generation model’s average token consumption per task on standard coding and agent benchmark tasks is already close to that of top international flagship models.

    This leads to a counterintuitive conclusion: if per-task consumption is comparable to competitors, while the subscription multiplier is only a fraction of theirs, then the actual task cost for subscribers may be several times higher than that of competitors. In other words:

    1. Actual task cost ≈ (task token consumption × unit price) / subscription multiplier

    Low unit price + high consumption + low multiplier can together offset the list-price advantage. This also explains why some heavy users are dissatisfied with the new pricing—what they care about is never how much each million tokens costs, but how much their monthly coding task list will cost.

    5. A Cost Evaluation Framework for Developers and Enterprises

    When facing complex pricing structures, it is advisable to establish the following evaluation process:

    1. Measure a consumption baseline. Select 3–5 real typical tasks—such as code generation, long-document summarization, and multi-turn agent execution—run each several times on candidate models, and record average input, output, and cache-hit token counts.
    2. Calculate cache-hit benefits. If system prompts are stable and long, prioritize invocation methods with high cache hit rates. This can reduce effective input cost by an order of magnitude.
    3. Distinguish API and subscription scenarios. High-frequency daily users should look at the effective price of subscription plans; low-frequency users or product-integrated scenarios should look at API list prices, concurrency, and rate-limit policies.
    4. Reserve a downgrade path. Routing simple requests to cheaper models and complex requests to flagship models is a mature industry cost-reduction practice, typically saving more than 50% of costs.
    1. # Simplified cost estimation example
    2. def task_cost(in_tok, out_tok, cache_ratio, price_in, price_out, price_cache):
    3. eff_in = in_tok * (1 - cache_ratio)
    4. cached_in = in_tok * cache_ratio
    5. return (eff_in * price_in + cached_in * price_cache
    6. + out_tok * price_out) / 1e6 # price per million tokens

    6. Rational Expectations: Pricing Will Return as Competition Intensifies

    It should be noted that current high pricing is more of a premium strategy during the launch period: exclusive flagship capabilities, strong benchmark rankings, and supply that has not yet been fully released. Based on historical industry patterns, several months after a flagship model launch, price cuts, lightweight versions, or subscription-plan adjustments usually appear. For cost-sensitive users, waiting for the window period or adopting a hybrid routing strategy is often more cost-effective than switching immediately.

    In summary, judging whether a model is “expensive” cannot rely only on list price or benchmark scores. It should combine cache mechanisms, subscription multipliers, and real task consumption. For vendors, true product strength is not only model capability, but also pricing design that lets developers “afford it and enjoy using it.” Whoever offers a better solution on this curve can gain the initiative in the next round of competition.