Search "Kimi K2 price" and you'll get a single number, usually from whichever platform's blog post ranks first that week. Pull pricing from more than one source at the same time and the picture looks different: for the exact same model, output pricing alone ranges from roughly $3.20 to $4.50 per million tokens depending on which platform you call it through, and that's before accounting for a couple of listings that look more like promotional teaser rates than sustainable pricing.
None of that is a scandal — it's just what happens when a model gets resold through a dozen-plus routing layers, each with its own margin and business model. But "Kimi K2 price" as a single number is close to meaningless without knowing which platform, which variant, and which side of the input/output ratio your workload actually hits.
First, which "Kimi K2" you mean
Moonshot's K2 lineup currently has two live, actively supported variants worth pricing out: kimi-k2.6, the general-purpose model, and kimi-k2.7-code, tuned specifically for coding tasks, both with a 262K context window. A third variant, kimi-k2.5, was sunset by Moonshot at the end of August 2026 — if you're seeing K2.5 pricing on a resale platform's page, that's worth treating as a stale listing rather than a live option, since official support for it has ended even if a routing platform's catalog hasn't caught up yet. This is a good general habit with any fast-moving model lineup: a pricing page's last-updated date matters as much as the number on it.
The actual spread, current as of this writing
Here's per-million-token pricing for kimi-k2.6 across a representative set of platforms:
Platform Input Output
DeepInfra $0.75 $3.50
OpenRouter $0.68 $3.41
novita $0.80 $3.40
CometAPI $0.76 $3.20
Fireworks $0.95 $4.00
Together AI $1.20 $4.50
And for kimi-k2.7-code:
Platform Input Output
DeepInfra $0.74 $3.50
OpenRouter $0.75 $3.50
CometAPI $0.76 $3.20
novita / Together AI / Fireworks $0.95 $4.00
Two things stand out. First, K2.7 Code's pricing is tighter across platforms than K2.6's — most cluster within a few cents of each other, with Together AI's K2.6 rate ($1.20/$4.50) sitting noticeably above the pack rather than the whole market moving together. Second, a couple of listings I checked while pulling this together showed output pricing well below the range above — one showing K2.6 output priced under $0.10 per million tokens, an order of magnitude below every other platform. That's the kind of number worth verifying directly with the platform before building a cost model around it; it's far more likely to be a promotional rate, an introductory tier, or a stale/incorrect listing than a sustainable price nobody else can match. Treat any single outlier that far from the pack as a thing to confirm, not a thing to bank on.
Cache pricing is the part most "price" posts skip entirely
Headline input/output numbers are only part of the actual cost if your workload reuses context — a system prompt, a large document, repo context for a coding task. Several platforms price cached input tokens far below the standard input rate: DeepInfra and Fireworks both price K2.6 cache reads around $0.15-0.16 per million tokens, roughly a fifth of standard input pricing, while nano-gpt's cache rate on the same model runs close to a hundredth of its standard input rate. If your actual traffic resends a large, mostly-static prefix on every call — which describes a lot of coding-agent and RAG workloads — the cache rate matters more to your real bill than the headline input number, and it's the number most comparison posts leave out entirely.
Why the headline number doesn't tell you your actual cost
The reason none of the numbers above answer "what will this cost me" on their own is that your actual bill depends on your input-to-output token ratio, and that ratio varies enormously by task. A summarization workload might send 5,000 input tokens and get back 200. A long-form generation task might do the reverse. Since input and output are priced differently — often by 4-5x — the "cheaper" platform for one workload can be the more expensive one for another.
// kimi-cost-estimate.js — compare platforms against your own actual usage pattern,
// not just the headline input/output numbers
const PLATFORM_RATES = {
// per-million-token rates for kimi-k2.6
deepinfra: { input: 0.75, output: 3.50, cache: 0.15 },
openrouter: { input: 0.68, output: 3.41, cache: null },
novita: { input: 0.80, output: 3.40, cache: 0.16 },
fireworks: { input: 0.95, output: 4.00, cache: 0.16 },
together: { input: 1.20, output: 4.50, cache: 0.20 },
};
function estimateMonthlyCost(rates, { inputTokens, outputTokens, cachedInputTokens = 0 }) {
const regularInput = Math.max(inputTokens - cachedInputTokens, 0);
const inputCost = (regularInput / 1_000_000) * rates.input;
const cacheCost = rates.cache
? (cachedInputTokens / 1_000_000) * rates.cache
: (cachedInputTokens / 1_000_000) * rates.input; // no cache discount available
const outputCost = (outputTokens / 1_000_000) * rates.output;
return +(inputCost + cacheCost + outputCost).toFixed(2);
}
// Example: a coding-agent workload with a large, mostly-static repo context
// resent on every call — heavy on cached input, moderate output
const monthlyUsage = {
inputTokens: 40_000_000,
cachedInputTokens: 32_000_000, // most of the input is a repeated context prefix
outputTokens: 6_000_000,
};
for (const [platform, rates] of Object.entries(PLATFORM_RATES)) {
const cost = estimateMonthlyCost(rates, monthlyUsage);
console.log(`${platform}: $${cost}/month`);
}
Run that with a summarization-style profile instead (high input, low output, little to no cache reuse) and the ranking between platforms can shift — a platform with a slightly higher output rate but a much better cache discount can come out ahead for a cache-heavy workload while losing on a straight output-heavy one. The only way to know which applies to you is running your own numbers, not reading a ranked list built on someone else's assumed ratio.
Where the official direct price fits in
It's worth separating "resale platform pricing" from "calling Moonshot directly," since they're not automatically the same number. Depending on the platform and moment, some resale listings for K2.6 and K2.7 Code come in below Moonshot's own direct API pricing, and some come in above it — direct access removes a routing layer but doesn't automatically mean the lowest price, and it also means managing Moonshot's own rate-limit tier system yourself rather than inheriting whatever a gateway has already worked out.
What this actually means for picking a platform
Don't shop by a single headline number for "Kimi K2 price" — it answers a question your actual traffic pattern isn't asking. Instead: confirm you're pricing a currently supported variant (K2.6 or K2.7 Code, not the sunset K2.5), check both the input and output rate rather than just one, factor in cache pricing if your workload reuses context at all, and run your actual token ratio through something like the calculator above across two or three candidates rather than trusting a single ranked table — including the one earlier in this post. Gateways like RouteAI, which also lists Kimi models in its catalog, are worth adding to that same comparison rather than taking any platform's word for where it ranks — the only pricing number that matters is the one computed against your own usage.
TL;DR: Kimi K2.6 and K2.7 Code pricing varies by roughly 2x across resale platforms depending on input, output, and cache-read rates, with a couple of suspiciously low listings worth verifying rather than trusting outright — the platform that's cheapest for your workload depends entirely on your input-to-output token ratio, which is worth calculating directly rather than reading off a single "price" number.
Website: https://www.fastrouteai.com
Top comments (0)