Kimi K3 Pricing: $3/$15 with 90% Cache Hits Makes It Cheaper Than It Looks
At first glance, Kimi K3 looks like a premium model. $3 per million input tokens and $15 per million output tokens places it in the same tier as Claude Sonnet 5 and above budget options like Grok 4.5.
But K3 has a trick: prefix caching at $0.30 per million tokens with 90%+ hit rates in typical coding workflows. This transforms the effective pricing from “$3/$15” to something closer to “$0.50/$15” for sustained development sessions.
Here is exactly how the pricing works, when you benefit most, and how to optimize your usage.
Base Pricing
| Tier | Cost per Million Tokens |
|---|---|
| Input (no cache) | $3.00 |
| Input (cache hit) | $0.30 |
| Output | $15.00 |
The model is available on OpenRouter as moonshotai/kimi-k3 and directly through Moonshot’s API. Pricing is the same on both.
How Prefix Caching Works
Prefix caching is simple in concept. When you send a request, the system checks if the beginning of your input matches a previous request. If it does, those matching tokens are served from cache at the reduced $0.30/M rate instead of the full $3/M rate.
In coding workflows, this happens naturally because:
- System prompts stay constant. Your instructions to the model rarely change between requests.
- Codebase context stays constant. When you load files into context, they remain the same across multiple interactions.
- Conversation history accumulates. Each new message includes all previous messages as prefix.
The result is that as a conversation progresses, an increasingly large portion of each request is a prefix match. By the third or fourth exchange, 90%+ of your input tokens are hitting cache.
Effective Cost Calculations
Let me work through realistic scenarios.
Scenario 1: Quick Question (No Cache Benefit)
- Input: 1,000 tokens at $3/M = $0.003
- Output: 500 tokens at $15/M = $0.0075
- Total: $0.0105
Scenario 2: Extended Coding Session (10 Exchanges)
Assume you load 50K tokens of codebase context and have a 10-exchange conversation:
- Exchange 1: 52K input (all fresh) = $0.156
- Exchange 2: 54K input (52K cached + 2K new) = $0.0156 + $0.006 = $0.0216
- Exchange 3: 56K input (54K cached + 2K new) = $0.0162 + $0.006 = $0.0222
- …continuing this pattern…
- Exchange 10: 70K input (68K cached + 2K new) = $0.0204 + $0.006 = $0.0264
- Output across all 10 exchanges: ~30K tokens = $0.45
Total for 10 exchanges: ~$0.80 Without cache: ~$2.35 Savings: ~66%
Scenario 3: Full Day of Heavy Development
A heavy development day might involve multiple sessions totaling:
- 5M input tokens (with 90% cache rate)
- 1M output tokens
With cache: (0.5M x $3) + (4.5M x $0.30) + (1M x $15) = $1.50 + $1.35 + $15 = $17.85 Without cache: (5M x $3) + (1M x $15) = $15 + $15 = $30.00 Savings: 40%
Scenario 4: Team of 5 Developers, Monthly
5 developers, each doing moderate coding (3M input, 600K output per day, 22 work days):
- Monthly input: 330M tokens (90% cached)
- Monthly output: 66M tokens
With cache: (33M x $3) + (297M x $0.30) + (66M x $15) = $99 + $89.10 + $990 = $1,178/month Without cache: (330M x $3) + (66M x $15) = $990 + $990 = $1,980/month Savings: $802/month (40%)
Comparison to Other Models
| Model | Input | Output | Cache | Effective Input (90% cache) |
|---|---|---|---|---|
| Kimi K3 | $3.00 | $15.00 | $0.30/M | ~$0.57/M |
| Claude Opus 4.8 | $5.00 | $25.00 | Varies | Varies |
| GPT-5.6 Sol | $5.00 | $30.00 | Varies | Varies |
| Claude Sonnet 5 | $2.00 | $10.00 | Varies | Varies |
| Grok 4.5 | $2.00 | $6.00 | Limited | ~$2.00/M |
| Tencent Hy3 | $0.14 | $0.14 | N/A | $0.14/M |
| DeepSeek V4 Pro | Budget | Budget | Varies | Budget |
K3’s effective input cost with caching ($0.57/M average) is remarkably competitive. Only Tencent Hy3 and budget-tier models are cheaper on input, and those sacrifice significant performance. K3 gives you #2 Terminal-Bench performance at a blended rate that approaches budget model pricing on input.
For the full pricing landscape, see our AI API pricing comparison.
How to Maximize Cache Hit Rates
1. Use Consistent System Prompts
Keep your system prompt identical across requests. Any change, even a single character, breaks the prefix match from that point forward.
// Good: Same system prompt every time
system: "You are a senior developer. Follow these coding standards: ..."
// Bad: Dynamic content in system prompt
system: "You are a senior developer. Current time: {timestamp}. Follow..."2. Front-Load Static Content
Put your codebase context and documentation before the conversation history. Static content at the beginning of the input creates a long, cacheable prefix.
[System Prompt] <- cached
[Codebase files] <- cached (if unchanged)
[Previous messages] <- cached (grows each turn)
[New user message] <- not cached (small)3. Avoid Reordering Context
If you load 10 files into context, keep them in the same order every request. Reordering breaks the prefix match even if the content is identical.
4. Batch Related Questions
Instead of starting a new conversation for each question about the same codebase, continue the existing conversation. Each subsequent exchange benefits from more cached prefix.
5. Use Large Context Windows
Load more context upfront, even if you do not need it all immediately. The initial cost is $3/M, but subsequent requests referencing the same context cost only $0.30/M. Front-loading context pays for itself after 1-2 follow-up exchanges.
When Cache Does NOT Help
Cache hit rates drop in these scenarios:
- One-off questions: Single requests with no follow-up get zero cache benefit.
- Rapidly changing context: If you modify files between every request, the cached prefix is shorter.
- Short sessions: The cache benefit grows over time. A 2-message exchange benefits less than a 10-message one.
- Different projects: Switching between unrelated codebases resets the cache.
For these patterns, K3 costs its full $3/$15 rate. It is still cheaper than Opus 4.8 at $5/$25 and Sol at $5/$30, but the dramatic savings from caching do not apply.
K3 vs Budget Models: When Does Performance Justify the Cost?
Tencent Hy3 costs $0.14/M for both input and output. That is 10x cheaper than K3 on output. Why not just use Hy3?
Because K3 scores 88.3% on Terminal-Bench while Hy3 does not reach that tier. If a model fails on a task and you spend 30 minutes debugging manually, the “savings” from a cheaper model evaporate. For professional development where your time has value, paying for higher success rates usually makes economic sense.
The break-even depends on your hourly rate. If your time is worth $50/hour and K3 saves you one 30-minute debugging session per day compared to a cheaper model, that is $25/day in time savings versus maybe $10/day in extra API costs.
OpenRouter Access
K3 is available on OpenRouter as moonshotai/kimi-k3. OpenRouter passes through Moonshot’s pricing without markup for this model. Cache behavior works the same through OpenRouter as through the direct API.
To use K3 through OpenRouter with tools like Aider, see our setup guide.
FAQ
How does K3’s cache actually achieve 90%+ hit rates?
In coding workflows, most of your input is repeated context: system prompts, loaded files, and conversation history. Only the newest user message is fresh. After a few exchanges, the new content is a tiny fraction of total input. Moonshot reports 90%+ hit rates as the average across typical coding sessions, which aligns with how these interactions are structured.
Is the $0.30/M cache price guaranteed?
It is the current published pricing. Moonshot could change it, but as of July 2026 it is stable. The 90% hit rate is an average; your actual rate depends on how you structure requests.
How does K3 pricing compare to self-hosting?
Self-hosting 2.8T parameters requires significant GPU infrastructure (multiple high-end nodes). For most teams, the API pricing is far cheaper than the capital and operational cost of self-hosting. Self-hosting makes sense only for organizations with existing GPU clusters and very high usage volumes.
Is K3 worth the premium over Sonnet 5?
K3 costs $3/$15 vs Sonnet 5 at $2/$10. The performance gap is substantial: K3 scores 88.3% on Terminal-Bench and 67.5% on DeepSWE, both significantly above Sonnet 5’s 63.2%. For coding work, the premium buys meaningfully better results.
What happens if my cache hit rate is below 90%?
Even at 50% cache hit rates, K3 is competitive. At 50% cache: effective input becomes (0.5 x $3) + (0.5 x $0.30) = $1.65/M. Still cheaper than Opus 4.8 and Sol on input. The model is priced to work even without optimal caching; the cache is a bonus, not a requirement.