Chinese LLM API Cost Calculator (2026)

To estimate any Chinese LLM API bill, multiply input tokens by the input rate and output tokens by the output rate, then sum across calls: blended cost = (input_tokens × input_$/1M + output_tokens × output_$/1M) ÷ 1,000,000. The trap is that output rates run far higher than input rates, so a verbose model can cost more than a pricier-looking one.

Most teams pick a model off a single headline number, usually the input price, and then get surprised by the invoice. The fix is a blended-cost formula that respects your real token mix, plus one caution the rate card never shows: reasoning tiers generate so many output tokens that their cheap-looking per-token rate understates the real bill. This guide walks the formula across three families, then shows what we actually paid when we billed the calls.

The blended-cost formula (verified 2026-06)

A blended cost is the total dollar figure for one call or one workload once input and output are priced separately and added together. The formula is plain arithmetic, but the inputs matter:

input_tokens = your prompt size, including system prompt and any retrieved context.
output_tokens = what the model generates. This is the variable most people underestimate.
rates are quoted per 1,000,000 tokens (per 1M), and input and output almost never match.

So a single call costs (input_tokens × input_rate + output_tokens × output_rate) ÷ 1,000,000. For a monthly budget, multiply by your call volume. The reason output dominates is structural: across the Chinese-model set, output rates run two to ten times the input rate, so a chatty model burns budget on the side you control least.

Per-token rates for three families (verified 2026-06)

Here are the three families we will run through the formula. DeepSeek figures are from its official endpoint; the Qwen and GLM figures were measured via OpenRouter and carry a native-reverify flag, since OpenRouter's catalog can undercut the vendor's own international endpoint.

Model	Input $/1M	Output $/1M	Output/input ratio	Source
DeepSeek V4-Flash	0.14	0.28	2.0×	official api.deepseek.com
Qwen3-Max	0.78	3.90	5.0×	measured via OpenRouter
GLM-4.6	0.43	1.74	4.0×	measured via OpenRouter

According to DeepSeek API Docs, V4-Flash bills input at $0.14 and output at $0.28 per million tokens, the only one of the three priced directly off the vendor. The Qwen and GLM rows reflect what the OpenRouter route charged on 2026-06-26; the official endpoints can differ, which is exactly why a calculator built on routed prices needs a re-check before you commit a large budget.

A worked example: same job, three models

Take one realistic call: a 1,000-token prompt that produces a 500-token answer. Plug each model into the formula and the spread is wide.

Model	Input cost	Output cost	Cost per call	Per 100k calls
DeepSeek V4-Flash	$0.00014	$0.00014	$0.00028	$28
GLM-4.6	$0.00043	$0.00087	$0.00130	$130
Qwen3-Max	$0.00078	$0.00195	$0.00273	$273

The practical upshot: for this balanced workload, DeepSeek V4-Flash runs roughly ten times cheaper than Qwen3-Max, and most of that gap is output, not input. If your real output is longer than 500 tokens, the gap widens further, because Qwen3-Max's output rate is 5× its input rate while V4-Flash's is only 2×. That ratio column in the rate table is the part most buyers skip, and it decides the bill more than the headline input price does.

What we actually paid (first-hand evidence)

Formulas are only as good as the rates behind them, so we billed real calls and read the cost back from the response. The non-DeepSeek numbers below were measured via OpenRouter on 2026-06-26; DeepSeek ran on its official endpoint.

On a short general-knowledge prompt, here is what three families billed:

Model	Prompt tokens	Completion tokens	Billed cost	Latency
Qwen3-Max	38	63	$0.00027534	3.22s
GLM-4.6	32	200	$0.00036376	8.58s
Kimi K2	36	60	$0.00015852	7.03s

What surprised us was the latency, not the cost. DeepSeek V4-Flash on its official endpoint answered a coding-anchor prompt in about 2 to 3.2 seconds across runs, consistently the fastest in the set, while GLM-4.6 took 8.58 seconds for a 200-token answer. The billed costs are tiny per call, but they scale linearly, so the per-call figure is the multiplier for your whole budget.

Then the reasoning-tier blow-up. We ran Kimi K2-Thinking on a two-sentence prompt and it generated 553 completion tokens for a billed $0.0014041, while Qwen3.5-Flash produced 2,831 output tokens on a similar short prompt and billed $0.00073866 over 17.85 seconds. Those output counts are 9× to 47× a normal short answer, which means the per-token rate badly understates a thinking tier's true cost. According to Alibaba Cloud, Qwen's reasoning variants emit extended chains of thought that are billed as output tokens, so the model's verbosity, not its sticker rate, drives the bill. Budget reasoning models by expected output volume, not by their headline price.

Budgeting caution: reasoning tiers break the calculator

A reasoning tier is a model variant that emits a long internal chain of thought before its answer, and that hidden work is billed as output tokens. This is why the formula needs a fudge factor for them. According to z.ai, GLM ships both standard and thinking-style tiers, and the thinking path trades latency and output volume for accuracy. The calculator still works; you just have to feed it a realistic output_tokens number, which for a reasoning tier might be 5× to 40× what the same prompt produces on a standard model.

The clean way to budget: pick your model, estimate input_tokens from your actual prompt, then estimate output_tokens from a real sample run rather than a guess. For standard tiers, a few hundred output tokens is typical. For reasoning tiers, sample first, because the rate card cannot warn you about a 2,831-token answer to a one-line question.

FAQ

How do I calculate the cost of a Chinese LLM API call? Multiply input tokens by the input rate per million and output tokens by the output rate per million, then add them: (input_tokens × input_$/1M + output_tokens × output_$/1M) ÷ 1,000,000. For a 1,000-token prompt and 500-token answer, DeepSeek V4-Flash costs about $0.00028, GLM-4.6 about $0.00130, and Qwen3-Max about $0.00273.

Why does output cost more than input? Across the Chinese-model set, output rates run two to ten times the input rate. DeepSeek V4-Flash's output is 2× its input ($0.28 vs $0.14), while Qwen3-Max's is 5× ($3.90 vs $0.78). A verbose model can therefore cost more than a model with a higher input price but a tighter output ratio.

Which Chinese model is cheapest for a balanced workload? On a 1,000-in / 500-out call, DeepSeek V4-Flash at roughly $0.00028 was about 10× cheaper than Qwen3-Max and 4.6× cheaper than GLM-4.6 in our worked example, and it was also the fastest model we measured.

Do reasoning tiers cost more than the rate card suggests? Yes. We measured Qwen3.5-Flash generating 2,831 output tokens on a short prompt and Kimi K2-Thinking generating 553. Because all of that is billed as output, a reasoning tier's real cost can be many times its standard sibling's, so budget by sampled output volume, not the sticker rate.

Are these prices the official vendor rates? DeepSeek's are official. The Qwen, GLM, and Kimi figures were measured via OpenRouter and carry a needs_native_reverify flag, because OpenRouter's catalog can undercut a vendor's own international endpoint. Re-check the native rate before committing a large budget.

For the full ranked comparison across families, see the best Chinese LLM API hub. For single-family deep dives, see the DeepSeek API pricing hub and the Qwen API pricing hub.

Author: Kevin Fan, Customer Success Manager at China LLM Directory, specializing in Chinese LLM ecosystem pricing. Last verified: 2026-06-26.