A 5x Hike in LLM API Pricing: The Logic Behind the Markup and the Real Cost Truth

1. The Phenomenon: A Pricing Upheaval That Breaks Industry Norms

Recently, a domestic open-source model vendor released a new generation model with the following API pricing: Input 20 yuan/million tokens, Output 100 yuan/million tokens, and Cache Hit 1 yuan/million tokens. Notably, the output price is five times higher than the previous generation.

To understand the shock value of these numbers, we must look at the industry background. Over the past two years, the domestic LLM market has been driven by the mantra of “low price and high utility.” Vendors competed for developers at near-cost or even subsidized prices, driving prices down continuously. Given this mindset, an output unit price jumping into the triple digits is understandably hard for users to swallow.

However, the real takeaway from this price adjustment is not “how much it increased,” but “who it is aligning with.”

2. Price Alignment: Pricing as a Long-Term Valuation of Capabilities

Public information shows that the new model’s pricing almost perfectly mirrors the standard pricing of a leading international vendor’s flagship model. Two details are often overlooked here.

First, it aligns with the standard price, not the actual promotional price. The international vendor is currently running a promotion—offering an actual rate of $2 for input and $10 for output before the end of August. The $3 input and $15 output rates are just the standard pricing after the promotion ends. Therefore, the new model, which aligns with the standard price, currently costs more to call than the promotional actual price of the model it benchmarks against.

Second, pricing and discounts are two different things. A discount is a market-driven operational action that can be given today and withdrawn tomorrow. Pricing, on the other hand, is a company’s long-term valuation of its own technical capabilities. Choosing to align with the “standard price” rather than the “promotional price” is tantamount to declaring: “I am aligning with your valuation of your own intelligence, not your current sales strategy.” This is the first time a domestic model company has refused to play the role of a “budget alternative” at the pricing level, explicitly rejecting the price war.

Of course, the prerequisite for this posture to hold is that the capabilities are actually there. Judging by public benchmarks, the model’s scores do stand in the first tier. Pricing can be aggressive, but benchmark scores cannot be faked.

3. The “Narrative Price”: In the Open-Weights Era, Official List Prices Have a Ten-Day Shelf Life

The most interesting aspect of this pricing is that it is not a faithful reflection of inference costs, but rather a “narrative price.” The key variable is that the model weights will soon be open-sourced.

According to the official announcement, the model weights will be available for download shortly. Open weights mean commoditization: third-party inference providers will likely host the exact same model’s inference services at significantly lower prices almost immediately. Converted, the official 100-yuan list price will only have a “monopoly” window of about ten days.

After ten days, a batch of services offering the same weights will appear on the market at 20% to 30% of the official price. By then, the official 100-yuan price tag will still stand, but its function will have changed—it becomes a price anchor. The anchoring effect is very straightforward here: when you see a 30-yuan service for the same model on a third-party platform, your first reaction will be “what a bargain,” precisely because the official price says it’s worth 100 yuan.

The combination of “open weights + high official list price” has almost no precedent in the history of open-source models. Its essence is to preemptively “carve” a number for the model’s capabilities before the weights are commoditized and prices are rewritten by the market. Whether this number can hold up in the future is irrelevant; what matters is that it was written down first.

4. Shift in Cost Center: Reasoning Models Push the Bill to the Output Side

To understand the impact of this price on your actual bill, we must understand the fundamental difference in cost structure between reasoning models and traditional chat models:

Billing Item	List Price (yuan/million tokens)	Scenario Characteristics
Input	20	Consumption scales with context length, but can be offset by caching
Cache Hit	1	Only 1/20 of the input price; the biggest optimization space for multi-turn Agent calls
Output (incl. Thinking)	100	Thinking tokens are billed as output, making it the bulk of the bill for reasoning models

In the era of traditional chat models, the cost center was on the input side: the longer the context and the more dialogue turns, the larger the input token consumption. In the reasoning model era, however, the center has slid to the output side. Before providing an answer, the model generates a massive amount of “thinking” tokens, and this thinking process is typically billed entirely as output.

This brings a direct consequence: the more the model thinks, the more you pay. Furthermore, when the new model launched, only the highest-intensity thinking tier was available, essentially setting it to “always think the most.” Coupled with the 5x hike in output unit price, the actual bill’s growth rate will be higher than the list price growth rate—thinking tokens will further amplify it.

For pure chat scenarios, this price is disastrous: at 100 yuan/million tokens for output, nobody can afford it for daily casual conversation. Conversely, this pricing has written its target audience right on its face—Agents, and machine-to-machine token consumption scenarios.

5. Task-Based Pricing: A Paradigm Shift in Cost Accounting for the Agent Era

Once a model enters an Agent workflow, the buyer’s accounting logic fundamentally changes: no one cares about the cost per million tokens anymore; everyone only cares about the cost per task.

According to third-party benchmark data, the average cost for the new model to complete a typical benchmark task is about $0.94. This is in the same tier as another international flagship reasoning model at $1.04, and only about half the cost of the same vendor’s even more advanced flagship model.

In a task-based pricing world, the conclusion is completely different from token-based pricing: it is not expensive—provided your tasks are genuinely complex enough to require deep reasoning. If it’s just summarization, rewriting, or simple Q&A, paying a premium for thinking tokens is pure waste.

6. Internal Divergence Within the Open-Weights Camp

However, if we narrow the comparison strictly to the open-weights camp, the picture changes immediately. Under the same task benchmark:

• Another mainstream model in the camp has a per-task cost of about $0.32;
• Yet another model has a per-task cost of only about 4 cents, a gap of more than twenty times compared to the new model.

Previously, a vendor within the camp permanently reduced its flagship model’s price in May to 3 yuan for input and 6 yuan for output—the new model’s output list price is more than 16 times that.

For the first time, a magnitude-level pricing divergence has appeared within the same open-source camp. This signals that the equation “open source = low price” is failing: open weights solve for “availability,” while pricing solves for “value positioning.” The two can now be decoupled.

7. What Should Developers and Enterprises Do: Five Actionable Best Practices

Rather than fixating on whether it’s “expensive,” it’s better to establish your own cost evaluation methodology.

1. Build benchmarks with real tasks; don’t draw conclusions solely from list prices. During selection, use real business task samples for benchmark testing. Track the token distribution (input, cache hit, thinking, answer) per call to directly calculate the per-task cost—this is the only number that fits into a financial model.

2. Incorporate thinking tokens into your billing model. The estimation code below can be directly embedded into a cost model (example):

# Estimate reasoning model call cost per task: thinking tokens are the most easily overlooked "hidden output"
INPUT_PRICE = 20      # yuan / million tokens
OUTPUT_PRICE = 100    # yuan / million tokens
CACHE_HIT_PRICE = 1   # yuan / million tokens
def estimate_task_cost(prompt_tokens, cached_tokens, thinking_tokens, answer_tokens):
    """cached_tokens is the part of prompt_tokens that hits the prefix cache"""
    fresh_input = prompt_tokens - cached_tokens
    cost = (
        fresh_input * INPUT_PRICE
        + cached_tokens * CACHE_HIT_PRICE
        + (thinking_tokens + answer_tokens) * OUTPUT_PRICE
    ) / 1e6
    return round(cost, 4)
# Example: A typical Agent task (long context + deep thinking)
print(estimate_task_cost(
    prompt_tokens=120_000,   # Context accumulated from multi-turn tool calls
    cached_tokens=100_000,   # Part that hits the prefix cache
    thinking_tokens=30_000,  # Chain of thought tokens, billed at output price
    answer_tokens=2_000,     # Final answer
))
# ≈ 3.7 yuan, of which the output side accounts for over 85%

In this example, the input side totals only 0.5 yuan, while the output side (primarily thinking) costs 3.2 yuan—this is the concrete meaning of “cost center on the output side.”

3. Implement tiered model routing; don’t use heavy models for light tasks. A sound enterprise architecture should route based on task complexity: route complex, high-value tasks to deep reasoning models; assign medium-to-low complexity tasks to balanced or low-cost models. Blocking 80% of low-value calls at the low-cost model layer is the most effective step to control total costs.

4. Master caching mechanisms for order-of-magnitude savings. The cache hit price is only 1/20 of the normal input price. In Agent scenarios, multi-turn calls are highly repetitive—system prompts, tool definitions, and historical context are stable prefixes. As long as stable content is fixed at the prefix position and dynamic changes to the prefix are avoided, the hit rate can significantly improve. Taking the new model as an example: 100,000 tokens hitting the cache costs only 0.1 yuan, whereas a cache miss costs 2 yuan.

5. Re-evaluate self-hosting vs. third-party inference once weights are open. After weights are available for download, multiple low-cost inference options for the same model will emerge outside the official channel. Enterprises need to recalculate: compare the official API list price, third-party inference quotes, and self-hosting GPU and O&M costs. For batch, offline, or latency-insensitive scenarios, low-cost channels might reduce costs to a fraction of the official list price. For mission-critical links, weigh stability, latency, and compliance. At the implementation level, you can also leverage general capabilities provided by cloud platforms—such as Baidu AI Cloud—for model access, logging services, and monitoring alerts to achieve unified multi-model management, budget control, and anomalous billing alerts.

8. Conclusion: Pricing is a Manifesto, Accounting is a Capability

Rather than a simple price hike, this “5x” pricing is better understood as a value manifesto. For the first time, a model vendor has explicitly differentiated between “how much I charge” and “how much I think I’m worth,” leaving the latter to be tested by the market through open weights.

For developers and enterprise users, there are two key takeaways: First, the billing structure in the reasoning model era has changed. Any cost estimation that ignores thinking tokens and cache hit rates is distorted. Second, the decisive factor in model selection is shifting from “who has the lowest unit price” to “who has the lowest cost per task.” Establishing your own task-level benchmarking and accounting system is far more important than chasing any leaderboard or list price.