Kimi K3 API pricing has three rates: cached input, uncached input, and output. The difference between a cache hit and a miss is 10×, so two agents processing the same 500K-token repository can have very different costs depending on session design.
Moonshot does not add a higher per-token tier for K3's 1-million-token context window. Long context is still not free: an uncached 1M-token prompt costs $3 before the model produces an answer.
Availability and prices updated July 22, 2026. Kimi K3 is available on Poyo.ai as
kimi-k3through the OpenAI-compatible Chat Completions API. Pricing is $2.28 per 1M input tokens and $11.40 per 1M output tokens — 24% lower than official pricing.
Official Kimi K3 API prices
| Usage | Price per 1M tokens |
|---|---|
| Cache-hit input | $0.30 |
| Cache-miss input | $3.00 |
| Output | $15.00 |
K3 uses flat pay-as-you-go pricing. Moonshot's documentation does not list a separate long-context surcharge. The API attempts context caching automatically; applications do not create a cache ID or configure a TTL for ordinary requests.
Kimi K3 cost formula
Use this formula for one request or an aggregated workload:
cost =
cached_input_tokens / 1,000,000 × $0.30
+ uncached_input_tokens / 1,000,000 × $3.00
+ output_tokens / 1,000,000 × $15.00
The API usage response and billing dashboard should be the source of truth. Estimates can differ when tokenization, retries, tool turns, or caching behavior changes.
Real Kimi K3 cost examples
Short analysis request
Assume 10,000 uncached input tokens and 2,000 output tokens.
| Component | Calculation | Cost |
|---|---|---|
| Input | 10K / 1M × $3 | $0.03 |
| Output | 2K / 1M × $15 | $0.03 |
| Total | $0.06 |
Even with six times more input than output, both parts cost the same because output tokens are five times more expensive.
A 100K-token repository review
Assume 100,000 uncached input tokens and 10,000 output tokens.
| Component | Cost |
|---|---|
| Input | $0.30 |
| Output | $0.15 |
| Total | $0.45 |
If the same stable repository prefix receives a cache hit on the next turn, its input portion falls from $0.30 to $0.03.
A 500K-token research corpus
Assume 500,000 input tokens and 20,000 output tokens.
| Cache state | Input cost | Output cost | Total |
|---|---|---|---|
| Cache miss | $1.50 | $0.30 | $1.80 |
| Cache hit | $0.15 | $0.30 | $0.45 |
This is why repeated knowledge-work sessions benefit from a stable prefix. Once output becomes the largest cost, asking the model to be concise can matter as much as caching.
Full 1M context with 50K output
| Cache state | Input cost | Output cost | Total |
|---|---|---|---|
| Cache miss | $3.00 | $0.75 | $3.75 |
| Cache hit | $0.30 | $0.75 | $1.05 |
The 1M window is a maximum capability, not a target for every request. Retrieval and staged analysis may be cheaper and easier to verify.
Multi-turn coding-agent cost
Consider a five-turn coding session with a 200K-token stable repository prefix, 20K new input tokens per turn, and 8K output tokens per turn.
If the first turn misses and later stable prefixes hit:
| Usage | Approximate cost |
|---|---|
| Initial 200K uncached prefix | $0.60 |
| Four 200K cached-prefix reads | $0.24 |
| Five × 20K new uncached input | $0.30 |
| Five × 8K output | $0.60 |
| Total | $1.74 |
If the application changes the beginning of the context every turn and prevents reuse, five uncached reads of the 200K prefix alone would cost $3.00. Session construction creates a larger difference than small prompt edits.
How automatic context caching works
Moonshot says caching is automatic for regular K3 requests. To give the service the best chance to reuse a prefix:
- keep the long beginning of the conversation unchanged;
- append new questions and tool results instead of rewriting old messages;
- avoid dynamic timestamps and request IDs near the start;
- keep system instructions stable;
- preserve the complete assistant message required by K3;
- group users and documents correctly so unrelated data never shares application state.
A cache hit is an optimization, not a guarantee. Monitor the actual cached and uncached token counts returned by the service.
Output tokens can dominate the bill
K3's output price is $15 per million tokens, five times the uncached input rate and 50 times the cached-input rate. Long reasoning and verbose agent reports can erase input-cache savings.
Control output cost by:
- setting a realistic
max_completion_tokensvalue; - asking for concise final artifacts;
- using structured output that includes only required fields;
- avoiding repeated restatements of large plans;
- measuring whether lower reasoning effort solves the task reliably;
- stopping tool loops after verification or a defined failure threshold.
Do not trim required thinking history from later turns merely to save tokens. Moonshot warns that incomplete state can make K3 unstable, which may create more retries and higher total cost.
Kimi K3 versus self-hosting cost
Open weights do not make inference free. K3 has 2.8T total parameters, uses extreme expert parallelism, and is recommended for supernodes with 64 or more accelerators. Self-hosting adds hardware, networking, engineering, utilization, monitoring, and availability costs.
API access is generally the practical option for variable or modest traffic. Self-hosting becomes a strategic discussion for organizations with sustained utilization, infrastructure expertise, data-control requirements, and access to suitable clusters. Wait for the actual weight license and supported inference stack before building a budget.
How to reduce Kimi K3 API cost
- Use a smaller model for classification, routing, and easy extraction.
- Send K3 only tasks that benefit from long-horizon reasoning or multimodal context.
- Keep reusable prefixes stable.
- Retrieve the relevant subset when full-context reasoning is unnecessary.
- Set bounded output and tool-loop limits.
- Compare
low,high, andmaxreasoning on a real evaluation set. - Log cost per verified success, including retries.
- Track severe failures and human correction time.
Is Kimi K3 expensive?
K3 is inexpensive when a cached long prefix supports a high-value task and the output remains focused. It can be expensive when every turn misses the cache, emits a long completion, and triggers multiple retries.
The useful comparison is not dollars per million tokens in isolation:
effective task cost =
API cost per attempt × attempts per verified success
+ human correction cost
For capability and benchmark context, read the Kimi K3 review and Kimi K3 benchmark analysis.
Frequently asked questions
How much is Kimi K3 per million tokens?
The official Moonshot rates are $0.30 for cache-hit input, $3 for cache-miss input, and $15 for output.
Does the 1M context window have a higher token price?
Moonshot lists flat rates rather than a separate long-context tier. A larger prompt still costs more because it contains more tokens.
Is there a free Kimi K3 API?
Promotional credits or third-party offers may change. Do not build a production cost model around temporary free access; verify the official console and provider terms.
Are reasoning tokens billed?
Use the official usage response and billing documentation for the final accounting of each request. K3 streams reasoning separately from final content, and long reasoning can increase generated-token usage.
Is Kimi K3 available on Poyo.ai?
Yes. The Kimi K3 model page includes the live playground, model ID kimi-k3, API access, and current Poyo pricing: $2.28 input and $11.40 output per 1M tokens, 24% lower than official pricing.