How to Evaluate LLM API Pricing and Subscription Value Rationally

Recently, the pricing of a new generation of flagship large models has become a hot topic in the community: one newly released model is priced roughly 5x higher than its predecessor, at about 20 yuan per million input tokens, 100 yuan per million output tokens, and 1 yuan per million cached hit tokens, while ranking near the top of authoritative evaluations. Supporters argue that “the capability is there, so the price is justified”; skeptics run the numbers and conclude that, after factoring in subscription benefits, the actual cost is not advantageous. Setting emotion aside, pricing evaluation can be treated as a computable engineering discipline. This article uses this typical set of numbers as an analysis sample to systematically break down the cost structure, estimation methods, and optimization strategies of large model pricing.

1. Why Model Iterations Often Come with Price Increases

1. Structural rise in inference cost. New-generation models generally have stronger reasoning capabilities and longer context windows. Reasoning models generate a large number of intermediate “thinking tokens” before producing a final answer, multiplying the actual computation per request; longer contexts also make attention computation cost rise with sequence length. Compute is a real expense, and passing that cost through to pricing is a natural outcome.

2. Capability premium and pricing power. When a model sits in the top tier of authoritative evaluations, with scarce supply and strong demand, vendors gain pricing leverage. High pricing is both a way to recover R&D and compute investment and a lever to regulate demand and protect service quality.

3. Price lifecycle patterns. A common industry pattern is: new models launch at high prices, then gradually drop as inference optimization (quantization, speculative decoding, cache reuse, specialized acceleration) and compute supply expand, while previous-generation models cut prices to capture price-sensitive traffic. The “launch price” therefore reflects scarcity more than a long-term equilibrium price.

2. Understanding Three-Tier Pricing: Input, Output, and Cache Hits

Mainstream large model APIs generally adopt three-tier pricing. Understanding the cost logic behind each tier is the first step in evaluation.

Billing item	Sample unit price (yuan per million tokens)	Cost logic
Input	20	Prefill completed in a single forward pass; relatively low cost
Output	100	Autoregressive token-by-token generation; each token requires a full forward pass, typically 3–5x input
Cache hit	1	Repeated prefixes reuse the KV cache, avoiding repeated prefill; can be as low as a fraction of the input price

• Why output is the most expensive: generation proceeds token by token, so an answer of length N requires N forward passes and is hard to parallelize in batches like input, making the per-token cost inherently higher.
• Why caching is cheap: in real applications, system prompts, few-shot examples, and multi-turn conversation history are highly repetitive prefixes. A cache hit means this content does not need to be recomputed, so the marginal cost is extremely low, and vendors pass the savings to users.
• What this means for users: the bulk of structural cost often lies not in “what you ask” but in “what you repeatedly feed in.” Putting stable content first and keeping prefixes consistent is one of the highest-value optimizations.

3. Unit Price Is Not Cost: Measure by Per-Task Consumption

To judge whether something is expensive, the core variable is not the unit price but “how many tokens a task consumes on average.” A commonly overlooked finding in third-party evaluations is that some reasoning models can consume close to flagship-level average tokens per task—even at similar unit prices, actual bills can differ severalfold.

Per-task cost formula:

Task cost = input tokens × input price + output tokens × output price + cache hit tokens × cache price

Example code:

def task_cost(in_toks, out_toks, cache_toks=0,
              p_in=20, p_out=100, p_cache=1):
    """Estimate per-task cost based on per-million-token prices (unit: yuan)"""
    return ((in_toks - cache_toks) * p_in
            + cache_toks * p_cache
            + out_toks * p_out) / 1e6
# Scenario: long system prompt + document context, 50k input tokens, 40k cache hits, 8k output tokens
print(round(task_cost(50_000, 8_000, cache_toks=40_000), 2))  # 1.04
print(round(task_cost(50_000, 8_000, cache_toks=0), 2))       # 1.80

For the same request, raising the cache hit rate from 0 to 80% cuts the per-request cost from 1.80 yuan to 1.04 yuan—a reduction of more than 40%. Zooming out to a monthly view:

def monthly_cost(daily_tasks, avg_cost):
    return daily_tasks * avg_cost * 30
# 1,000 calls per day
print(round(monthly_cost(1000, 1.04)))  # 31200 yuan/month

A monthly bill in the tens of thousands of yuan shows that “per-task consumption × call frequency” is the first-principles variable of cost, with unit price merely a coefficient.

4. How to Evaluate Subscription Plans: The Equivalent Usage Multiple Method

In addition to pay-as-you-go billing, vendors commonly offer fixed monthly subscription plans. The key metric for evaluating a plan is the equivalent usage multiple:

Equivalent multiple = cost of the same usage under pay-as-you-go ÷ monthly plan fee

Take a hypothetical set of numbers: a plan costs 199 yuan per month, and if its quota were billed pay-as-you-go it would cost about 1,200–2,800 yuan, giving an equivalent multiple of roughly 6–14x. In public industry discussions, some international vendors’ subscriptions are known for high multiples, commonly on the order of “roughly 20x usage for lower-tier plans and roughly 50x usage for higher-tier plans.”

This suggests a two-dimensional framework: pay-as-you-go unit price determines the barrier for light users, while the subscription’s equivalent multiple determines the actual cost for heavy users. If a flagship model’s pay-as-you-go price is high while its subscription’s equivalent multiple is clearly below the international top tier, the overall cost disadvantage for heavy users is multiplied. Conversely, the community expectation that “a hundred-yuan monthly fee should correspond to thousands of yuan in usage, and a thousand-yuan monthly fee to tens of thousands of yuan in usage” is essentially a demand that equivalent multiples match the industry’s top tier—only when the multiple is high enough will a high unit price not become a weakness when competing with international products. For users, calculating the equivalent multiple after getting a plan and combining it with their own average monthly usage immediately reveals whether the subscription is “worth it.”

5. How to Match Capability with Price: Evaluation Dimensions Beyond Benchmark Scores

1. Benchmark scores are necessary but not sufficient. Entering the top tier of authoritative evaluations shows the model has solid capability and that high pricing has some justification; but leaderboard results often do not align with performance in specific business scenarios, and rankings cannot be used directly to extrapolate returns.

2. Run small-scale POCs on real tasks. It is advisable to select 20–50 representative real samples and record task success rate, manual correction rate, average input/output tokens, and average latency. With this data, you can derive “per-task cost” and “quality gain” and compare them quantitatively with existing solutions.

3. Introduce quality-adjusted cost. If a new model raises the first-pass success rate on a class of complex tasks from 70% to 95%, the savings in retries, manual review, and rework may far exceed the token price increase. In this case, the “more expensive model” is actually the cheaper choice.

6. Cost-Optimization Checklist for Developers and Enterprises

1. Tiered routing: assign lightweight tasks such as format conversion and simple summarization to lightweight models, and reserve flagship models for heavy tasks such as code generation and deep analysis. Automatic routing by task type at the gateway layer is one of the fastest ways to cut costs.
2. Make full use of prefix caching: fix system prompts, organize knowledge base snippets into stable prefixes, and concatenate multi-turn conversation history in a stable order to maximize cache hit rates.
3. Constrain output: output unit price is usually several times that of input, so reduce redundant generation through maximum length limits, structured output constraints, and concise instructions; for reasoning models, evaluate whether a high thinking budget is really necessary.
4. Compress context: use retrieval augmentation to inject only relevant snippets, periodically summarize long conversation history, and avoid feeding entire documents into the prompt repeatedly.
5. Build usage dashboards and budget alerts: track token consumption by application and team, use “per-task cost × average daily calls” to forecast monthly bills on a rolling basis, and set threshold alerts. Mainstream cloud platforms (such as Baidu AI Cloud) typically provide logging, monitoring alerts, and multiple billing methods for their large model services, and these general capabilities can be reused directly to put the method into practice.
6. Hybrid billing strategy: lock in low costs for baseline load with plans or resource packages, and route burst traffic to pay-as-you-go billing; regularly calculate the break-even point between the two and adjust dynamically as business volume changes.

7. Conclusion: Turning “Is It Expensive?” into a Calculable Question

A price several times higher than the previous generation does not by itself constitute a verdict. The real questions to answer are three: What is my per-task token consumption? How high can I push the cache hit rate? How much is the model’s capability improvement worth in my scenario? Once these three questions are calculated clearly, the pricing debate shifts from an emotional topic to an engineering one. For vendors, price is a function of capability and compute supply; for users, cost is a function of architecture and usage. When both sides speak with data, the market moves toward a healthier equilibrium.