Kimi K3: benchmarks, pricing, API, context window, and open-weight status

Kimi K3 API pricing

The official hosted API costs $3 per million cache-miss input tokens, $0.30 per million cache-hit input tokens, and $15 per million output tokens. The 90% cache discount is excellent for repeated repository context, system prompts, and stable document corpora. Output can still dominate the bill because K3 reasons by default and reasoning tokens count toward usage.

How to access Kimi K3

K3 currently has five practical access paths:

1. Kimi.com and mobile apps: direct chat and agent experience. New subscriptions were temporarily paused on July 20; existing users were prioritized.
2. Kimi Work: desktop knowledge-work environment, version 3.1.0 or later on Windows and Apple silicon Macs.
3. Kimi Code: terminal coding agent. Choose K3 with /model. The model ID here is k3.
4. Kimi API: OpenAI-compatible Chat Completions endpoint at https://api.moonshot.ai/v1. The model ID is kimi-k3.
5. Third-party hosts: OpenRouter lists moonshotai/kimi-k3; Cloudflare Workers AI lists moonshotai/kimi-k3. Check each provider's live pricing, capacity, media support, and data policy.

Kimi K3 API example with cURL

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "system", "content": "You are a careful software engineer."},
      {"role": "user", "content": "Review this migration plan and identify rollback risks."}
    ],
    "stream": true
  }'

Kimi K3 with the OpenAI JavaScript SDK

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "user", content: "Map the architecture of this repository." },
  ],
  stream: true,
});

for await (const chunk of response) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

The API is stateless, so send the conversation history you want K3 to use. Preserve reasoning content during multi-step tool calls if the endpoint returns it, stream long responses, and budget for both returned reasoning and final-answer tokens. The general Moonshot API also supports tool calls and structured output, but verify K3-specific parameter support against the live model docs before hard-coding it.

What the one-million-token context window means

Cloudflare documents the exact limit as 1,048,576 tokens. In practical terms, that is enough capacity for a large repository, hundreds of normal documents, or a long agent history in one request. Capacity is not the same as comprehension: models can accept a token without reliably retrieving or using it, and performance may vary by position, document structure, and reasoning budget.

Moonshot's own BrowseComp footnote is revealing. With context compaction triggered at 300K, its table reports 91.2. With the full 1M window and no context management, it reports 90.4. The model can operate at that length, but deliberate context management still matters.

How to use the context efficiently

• Put stable instructions and repository context first so automatic caching can reuse the prefix.
• Start a new Kimi Code session when switching models or reasoning effort; the docs warn that switching invalidates the existing cache.
• Give files clear names and delimiters, then ask K3 to cite paths or document IDs in its answer.
• Test retrieval at the beginning, middle, and end before trusting a million-token production workflow.
• Do not send a million tokens simply because you can. Retrieval, summaries, and scoped agents can be cheaper and easier to audit.

For the broader market, see our guide to the largest-context-window models.

Open-weight status and self-hosting reality

As of this article's July 20 update, there is no K3 checkpoint on Moonshot's Hugging Face organization. Moonshot has committed to releasing the full weights by July 27 and says vLLM support for KDA prefix caching will arrive with the model. The final license and exact files are not yet public. Until they are, calling K3 downloadable or independently reproducible is premature.

Even with weights, “local” will mean a server room, not a gaming PC. A simple four-bit calculation—2.8 trillion parameters × 0.5 bytes—produces about 1.4 TB for weights alone. Quantization scales, shared components, runtime buffers, expert routing, vision components, and the KV or recurrent state increase the real footprint. Moonshot recommends a supernode with at least 64 accelerators.

Kimi K3 vs K2.6, Claude, GPT, and other frontier models

Kimi K3 vs Kimi K2.6

Kimi K3 vs proprietary frontier models

K3's strongest case against Claude Fable 5 and GPT-5.6 Sol is not that it wins every benchmark. It does not. The case is that it operates in the same performance band on many agentic tasks, wins important coding and document evaluations, offers a one-million-token window, and is scheduled to become open-weight. Choose based on workload:

• Choose K3 for frontend generation, enormous repository context, autonomous terminal work, multimodal iteration, and future control over deployment.
• Choose Fable 5 when its stronger HLE, DeepSWE, GDPval, and OfficeQA results match your workload—or when a mature managed coding ecosystem matters more than openness.
• Choose GPT-5.6 Sol when you want the strongest displayed DeepSWE, Terminal-Bench, GPQA, and MMMU-Pro scores and prefer the Codex ecosystem.
• Choose K2.6 or another lower-cost model when throughput and unit economics matter more than the final few points of capability.

Use WhatLLM's model comparison tool for current provider-level price and performance data rather than freezing a fast-changing market into this launch article.

Limitations and unanswered questions

1. The weights are not public yet. Architecture and reproducibility claims cannot be fully inspected.
2. The detailed benchmark set is vendor-assembled. Harnesses, context management, fallbacks, hardware, and reasoning settings vary.
3. Independent API evaluation is still early. Artificial Analysis now measures K3, but provider speed data and weight-level reproduction remain incomplete.
4. Launch capacity is constrained. Moonshot paused new subscriptions after demand strained infrastructure; rate limits and latency may change quickly.
5. Output is expensive. At $15/M output tokens, long reasoning trajectories can erase the savings from cached input.
6. Self-hosting is a datacenter project. Sparse activation reduces compute per token, not the need to store and communicate a 2.8T-parameter model.
7. One million tokens needs independent testing. Maximum accepted length does not guarantee perfect recall or stable tool behavior.
8. Privacy depends on the route. Kimi.com, Moonshot API, OpenRouter, Cloudflare, and a future self-hosted deployment have different data paths and policies. Review the provider terms for sensitive work.
9. The product surface is inconsistent. API and Kimi Code use different IDs and currently document reasoning controls differently.

Our verdict: who should use Kimi K3?

K3 is one of the most important model releases of 2026 because it combines three things that rarely arrive together: near-frontier coding, a genuine million-token serving target, and a promised open checkpoint at unprecedented scale. Its best early evidence is concrete—blind frontend preference, strong terminal and program benchmarks, and document-heavy agent results.

But K3 is not a bargain replacement for every model call. It is more than three times the output price of K2.6, launch capacity is tight, the weights are not here, and the benchmark story is still mostly controlled by Moonshot. Treat it as a specialist escalation model today: route the hardest coding, research, and visual-agent tasks to it, measure task completion and total cost, and keep cheaper models underneath.

Kimi K3 FAQ

Sources, methodology, and update policy

We prioritize primary documentation, papers, and live provider pages. Benchmark claims are labeled by evidence type and are not normalized when harnesses differ. Cost examples are arithmetic based on public list prices. We did not claim a WhatLLM hands-on benchmark because we did not have a stable, controlled K3 endpoint for this publication cycle.

• Moonshot AI: Kimi K3 launch and full benchmark notes
• Kimi API: endpoint and OpenAI compatibility
• Kimi Code: model IDs, context, and reasoning modes
• Cloudflare: K3 model card and exact context limit
• OpenRouter: K3 route and provider listing
• Artificial Analysis: independent K3 indices and cost per task
• Kimi Linear paper: Kimi Delta Attention
• Attention Residuals paper
• Mooncake serving architecture paper
• Arena result and launch analysis
• Associated Press: launch-capacity update

Update log

• July 20, 2026: First publication. Added launch specs, complete evidence review, Artificial Analysis indices, pricing calculations, API examples, capacity notice, and pre-release weight tracker.
• Scheduled after July 27: Verify weights, license, model card, file size, inference recipes, and independent benchmark availability.