Kimi K3 Pricing Explained: Caching & Cost Tricks (2026)

Kimi K3 is Moonshot AI’s flagship model — capabilities maxed out, and a flagship price tag to match. The first time people see “output ¥100/M” they tend to flinch, but your real bill depends on how you use caching and how full you pack the context. This post walks through K3’s billing rules, its caching mechanism, and the cost of a typical call, then compares aggregator pricing along the way.

Official pricing table

Kimi K3 bills per token, and input is split into “cache hit / cache miss.” The reference prices below are per million tokens, in RMB (the live console price always takes precedence):

Billing item	Price / 1M tokens
Input (cache miss)	¥20
Input (cache hit)	¥2
Output	¥100

Compared with the K2 series, where output ran a few RMB, K3’s output is an order of magnitude pricier — that’s the pricing logic of a flagship model with reasoning always on (the thinking tokens produced by reasoning also count as output). So controlling output length and leaning on caching are the two main levers for saving money on K3.

How caching is calculated, and why it saves so much

K3 has context caching on by default: when the prefix of a request (say a very long system prompt, a fixed reference document, or tool definitions) matches a previous one, that portion of the input is billed at ¥2/M instead of ¥20/M — a straight 90% discount.

This is decisive for two kinds of scenarios:

• Long system prompts / fixed RAG documents: the same tens-of-thousands-of-tokens background is sent every time; once it hits the cache, input cost drops by 90%;
• Long-running agents: across round after round of tool calls, the earlier history keeps reappearing as a prefix, and caching spreads that cost paper-thin.

In practice, put the unchanging content up front (system, documents, tool definitions) and place the per-turn user input at the end to maximize your hit rate.

What a single call really costs

Two examples (rough figures at the reference price, with ~¥7.2 ≈ $1, for illustration only):

Short Q&A: 2K input tokens (cache miss), 500 output tokens = 2/1000×¥20 + 0.5/1000×¥100 = ¥0.04 + ¥0.05 = about ¥0.09.

Long-document Q&A (with cache): a 200K document sent in one shot, of which 190K hits the cache and 10K is new input, output 2K = 190/1000×¥2 + 10/1000×¥20 + 2/1000×¥100 = ¥0.38 + ¥0.20 + ¥0.20 = about ¥0.78. If all 200K were cache misses, the input portion alone would be ¥4.0 — the gap is stark. Caching is the make-or-break factor for long-text scenarios.

So K3’s output unit price looks scary on its own, but the real cost depends heavily on your context structure. Reuse your fixed prefix, and the bill for long-text / agent work comes out a lot lower than intuition suggests.

Why the ¥15 trial credit can’t be used on K3

The ¥15 trial credit Moonshot AI hands out to new users currently can’t be used on K3 — official K3 access is paid. If you want to poke at K3’s capabilities at zero cost, go through an aggregator: register with a referral code on GetModel to claim a batch of free credit that works across all models, so you can try K3, GPT and Claude at the same time and decide on your main model after a side-by-side comparison.

Aggregator price comparison

A direct connection suits you if you only use Kimi; but if you also need GPT, Claude and Gemini at once, an aggregator gateway saves the hassle of multiple sign-ups and reconciliations. When you use an aggregation interface like GetModel:

• One key, one bill, with balance shared across all models — switching models means only changing the model field;
• The live unit prices for Kimi and other models are on the pricing page; the live price rules at order time;
• The gateway layers on multi-channel failover, so when a single upstream gets rate-limited or wobbles it reroutes automatically, keeping production steadier.

Money-saving checklist

• Don’t reach for K3 when K2 will do: use the K2 series for pure throughput tasks, where the unit price is an order of magnitude lower (see K3 vs K2);
• Fixed prefix up front + max out the cache to push input down to ¥2/M;
• Control output length — reasoning tokens count as output too, so tighten answers when needed;
• Don’t mindlessly fill the full 1M — longer means pricier and slower, so trim when you should;
• Compare prices side by side, use an aggregator to get live prices, and route cheap tasks to cheaper models.

To cost out Kimi K3 alongside other models at live prices while maintaining just one key, start from the GetModel dashboard. For the full integration steps, see the Kimi K3 API integration tutorial.