Kimi API Pricing in 2026: Real Costs, the Cache Discount & How to Call It

Moonshot's Kimi API gives you the open-weights K2 family — K2.6 (general), K2.5, and K2.7 Code (the coding-focused model) — at low prices with a deep cache-hit discount that, for the right workload, is the single biggest cost lever you have. This guide has the verified price table, a modeled cost breakdown for real workloads, a clear explanation of how the cache-hit discount works and what it actually saves, the licensing fine print, how to get a Moonshot key, and a worked call with error handling.

What the Kimi API is

The Kimi API is Moonshot AI's access to its open-weights K2 family:

• K2.7 Code — the coding-focused, agentic model (the strongest coder of the family).
• K2.6 — the general-purpose model Moonshot recommends for non-coding work.
• K2.5 — the cheaper prior tier, still very capable.

It is OpenAI-compatible, cheap, and open-weights (so you can self-host). Its standout commercial feature is a deep cache-hit discount that makes repeated-context workloads — agents and RAG that resend a big fixed context every turn — dramatically cheaper than the headline price suggests. That, plus a large ~256K context window, is why Kimi has become a go-to for long-context agentic stacks.

Kimi API pricing table

Per 1M tokens, USD, June 2026. K2.7 Code prices are Moonshot's direct API; on third-party hosts like OpenRouter it runs around $0.75/$3.50. K2.6/K2.5 prices are from the DataLLM Lab catalog.

What Kimi actually costs to run

Headline rates don't tell you the bill — your traffic shape does. Here's what the Kimi tiers cost across five canonical monthly workloads (cache-miss pricing, so this is the conservative ceiling), with two frontier models for contrast:

Even at cache-miss prices, Kimi K2.5 on a coding-agent workload runs about $81/month versus ~$1,025 for Claude Opus. And because these figures ignore the cache-hit discount, the input-heavy rows (RAG, batch extraction) are the conservative ceiling — the next section shows how much lower they go.

How the cache-hit discount works

This is Kimi's signature lever and the reason its real-world cost often beats cheaper-looking rivals. Here's the mechanism:

When consecutive requests share a common prefix — a large system prompt, a fixed set of tool definitions, or a retrieved document you keep in context — Moonshot can serve those repeated tokens from cache instead of recomputing them. Cached tokens are billed at the cache-hit rate (~$0.19/M for K2.7 Code) rather than the fresh cache-miss rate (~$0.95/M) — roughly 5x cheaper on the repeated portion.

Worked example. An agent sends a 30K-token fixed context (system prompt + tools + retrieved docs) plus a 1K-token user turn, 100,000 times a month:

• Without caching: all 31K tokens billed at $0.95/M → 3.1B input tokens → ~$2,945/month input.
• With caching: the 30K fixed prefix hits cache at $0.19/M (~$570) and only the 1K fresh turn pays $0.95/M (~$95) → ~$665/month input.

That's roughly a 77% cut on input cost for a workload that reuses a big context — which is exactly what agents and RAG do. The discount only helps when prefixes actually repeat, so structure your prompts to keep the stable part (instructions, tools) at the front and the variable part (the user turn) at the end.

How it compares on price

On headline output price, Kimi sits in the cheap-open tier — below the Western frontier, alongside DeepSeek and Qwen:

The license fine print

Kimi K2 models are open-weights under a Modified MIT license. It's standard MIT — permissive, commercial-friendly — with one added clause: deployments above 100M monthly active users or $20M monthly revenue must display "Kimi" attribution. For virtually every team that threshold never applies, so it behaves like plain MIT. The practical implication: you can download the weights from Hugging Face, self-host, fine-tune, and ship commercially without legal friction — a meaningful edge over models with more restrictive open licenses.

How to get a Moonshot key

1. Sign up at the Moonshot platform (platform.moonshot.ai) and verify.
2. Add billing (new accounts often get trial credit).
3. Create an API key and store it as export MOONSHOT_API_KEY=...
4. Use the OpenAI-compatible base URL https://api.moonshot.ai/v1.

How to call it (worked example)

The OpenAI SDK works with a base-URL and model-id change. Structure the prompt so the stable prefix comes first to maximize cache hits:

from openai import OpenAI, APIError

client = OpenAI(base_url="https://api.moonshot.ai/v1", api_key="$MOONSHOT_API_KEY")

# keep the stable system/context first so it hits cache on repeat calls
messages = [
    {"role": "system", "content": BIG_FIXED_CONTEXT},   # cached on repeat → ~5x cheaper
    {"role": "user", "content": user_turn},            # the only fresh tokens
]
try:
    resp = client.chat.completions.create(model="kimi-k2.7-code", messages=messages)
    print(resp.choices[0].message.content)
except APIError as e:
    print("Kimi API error:", e.status_code, e.message)   # 401 key, 429 rate, 400 model id

Which Kimi model to use

Calling it through a gateway

To use Kimi alongside other models with failover, call it through a gateway. DataLLM Lab carries Kimi K2.6 and K2.5 with one OpenAI-compatible key:

client = OpenAI(base_url="https://www.datallmlab.com/v1", api_key="$DATALLMLAB_API_KEY")
resp = client.chat.completions.create(model="moonshotai/kimi-k2.6", messages=[{"role":"user","content":"Hello"}])

FAQ