Kimi K3 is Moonshot's most capable flagship model to date and, at 2.8 trillion parameters, what its documentation calls the world's first open-source model in the three-trillion-parameter class.
- Input
- text image video $3/M
- Output
- text $15/M
- Cache read
- $0.3/M
- Context
- 1M
- vs GPT-4o
- ~40% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 65 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,048,576 |
|---|---|
| Max output (vendor spec) | 1,048,576 |
Prompt caching
| How it caches | automatic |
|---|
Thinking
| Vendor control | reasoning_effort (top-level; the thinking object is not accepted) |
|---|---|
| Accepted values | low · high · max |
| Default | max applied when the request sets nothing |
| Can be turned off | No |
| Thinking behaviour | K3 always reasons, so turn it down with low rather than off; the complete assistant message including reasoning_content and tool_calls must be passed back on multi-turn and tool-calling turns, and switching effort mid-session invalidates prefix-cache hits. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image + video → text |
|---|---|
| Parameters | 2.8T total · 104B active MoE - Kimi Delta Attention (KDA) + Attention Residuals, 16 of 896 experts active per token |
| License | Kimi K3 License |
Thinking mode is always on - reasoning cannot be disabled, only turned down via effort levels (low / high / max). max_completion_tokens defaults to 131,072 and can be raised to the full 1,048,576. Context caching is automatic with no cache id, TTL or extra parameter, and engages once the previous request's prompt exceeds 256 tokens. Open weights (MXFP4 weights / MXFP8 activations, quantization-aware training) published to Hugging Face under the Kimi K3 License.
One prompt, measured through the gateway
Kimi K3 passed · 3 sentences
Reasoning models don't just answer questions—they "think" first, generating long internal chains of step-by-step logic before producing a response. Those hidden thinking steps are billed as output tokens (the most expensive kind, typically 3–5x the price of input tokens), and a single query can generate thousands of them even when the visible answer is only a paragraph long. So you're paying for dramatically more compute per request: the bill doubled because the model does far more work behind the scenes, not because usage increased.
out 755 tok (+637 thinking) latency 20.8 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Kimi K3 passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is a fencepost error: `cur` counts *matching adjacent pairs* rather than *items in the run*, because it starts at 0 and only increments when `xs[i] == xs[i - 1]`. A run of length L contains L−1 equal pairs, so every run was undercounted by exactly one. For a single-element list (a run of length 1) the loop never runs and the function returns 0 instead of 1; likewise any run ending at the last index — e.g. the two `2`s in `[1, 2, 2]` — reported 1 instead of 2, making it look like no run existed at all. […]
out 1837 tok (+1547 thinking) latency 47.2 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Kimi K3 passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 924 tok (+863 thinking) latency 25.9 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Kimi K3 passed · 120 words, 0 banned, 1 question
Meet Prompt Cache, a new API gateway capability that stores prompt responses and serves them across OpenAI, Anthropic, Google, and Azure endpoints. It matches requests by model, prompt hash, tools, temperature, and tenant policy, so repeated work returns fast while sensitive contexts stay isolated. Teams set TTLs, stale rules, encryption scopes, and bypass flags per route. Analytics show hit rate, latency saved, token spend avoided, and drift risk by provider. What changes for developers? Keep one integration, add cache headers, and watch fallback logic respect consent, residency, and audit needs. During rollout, canary keys compare fresh answers with cached copies before promotion. Prompt Cache cuts vendor calls, steadies p95 latency, and gives platform owners controls for cost, quality, and compliance.
out 1527 tok (+1354 thinking) latency 37.9 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Kimi K3 in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="kimi-k3",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "kimi-k3",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k3",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "kimi-k3",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("kimi-k3")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Kimi K3
- The architecture pairs Kimi Delta Attention, a hybrid linear attention mechanism, with Attention Residuals, and pushes Mixture-of-Experts sparsity further through the Stable LatentMoE framework, activating 16 of 896 experts; Moonshot credits those changes with roughly 2.5 times the overall scaling efficiency of K2.
- It ships native visual understanding and a 1M-token context window, and is aimed at frontier intelligence scenarios including long-horizon coding, knowledge work, and reasoning: sustaining long engineering tasks with minimal supervision, working across large codebases, driving terminal tools, and using screenshots and visual feedback in game development, frontend engineering, and CAD workflows.
- Thinking is not optional here.
- K3 always reasons, and the only control is the top-level reasoning_effort field at low, high, or max, which defaults to max, so a latency-sensitive deployment has to turn it down explicitly.
- Several other limits are worth coding for: max_completion_tokens defaults to 131,072 against a 1,048,576 ceiling, sampling parameters are fixed and should be omitted from requests, the complete assistant message must be returned unchanged on multi-turn and tool-calling turns, and vision input rejects public image URLs in favour of base64 or an uploaded file reference.
- Context caching is automatic with no cache id, TTL, or extra parameter, engaging once the previous request's prompt exceeds 256 tokens, and pricing is flat with no tiering by context length.
- Structured output, partial-mode prefills, and dynamic tool loading are supported, and the weights are published under the Kimi K3 License.
- Synthorai makes Kimi K3 callable through its OpenAI-compatible chat completions endpoint.
FAQ
Is the Kimi K3 API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $3/M input tokens, that credit alone covers roughly 41 requests of ~8K tokens against Kimi K3.
What is Kimi K3 best at?
First open-source model in the three-trillion-parameter class; native visual understanding with a 1M-token context window; always reasons, with reasoning_effort defaulting to max. See the About section for the full picture from the vendor's own release notes.
How much does Kimi K3 cost?
Kimi K3 costs $3 per million input tokens and $15 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.3/M.
Does Kimi K3 support prompt caching?
Yes, automatically: Moonshot-served prompts cache with no code changes. Cached input tokens bill at $0.3/M vs $3/M uncached. Prompt caching guide →
How do I get access to Kimi K3?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="kimi-k3", and you're done. One API key covers every model on the gateway.
Is Kimi K3 open source?
Yes: the weights are published under the Kimi K3 License (official repository linked in the About section). Or skip the GPUs: the hosted version here is pay-as-you-go with no infrastructure to run. Running open-weight models →
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.