Kimi K2.5 is Moonshot AI's open-source, native multimodal agentic model, built by continual pretraining on roughly 15T mixed visual and text tokens atop Kimi-K2-Base.
- Input
- text image video $0.574/M
- Output
- text $3.011/M
- Cache read
- $0.115/M
- Context
- 262K
- vs GPT-4o
- ~89% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 60 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) | 256,000 |
|---|
Prompt caching
| How it caches | automatic |
|---|
Thinking
| Vendor control | thinking.type |
|---|---|
| Accepted values | enabled · disabled |
| Default | enabled on Moonshot's own platform; note that Alibaba Model Studio documents its deployment of this model as thinking disabled by default applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Trace returns in reasoning_content, which counts against max_tokens and always streams before content; Preserved Thinking is not supported, but historical reasoning_content should be kept in messages or the model loses reasoning context. |
| 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 | 1T total · 32B active MoE |
| License | Modified-MIT |
- 1T/32B active MoE, 256K context, native multimodal (MoonViT encoder, image + video input), instant + thinking modes, Agent Swarm up to 100 sub-agents
- native INT4 quantization
One prompt, measured through the gateway
Kimi K2.5 passed · 3 sentences
Enabling reasoning causes the model to perform extended internal deliberation, generating substantially more tokens per query than standard responses. Each reasoning chain consumes compute credits equivalent to multiple regular completions, and user query volume remained constant while per-query costs multiplied. The doubling reflects usage of a more expensive capability tier, not an operational error or billing anomaly.
out 67 tok latency 1.9 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Kimi K2.5 passed · 8/8 cases
The bug has two causes: the loop starts at index 1 and `cur` counts *additional* matching elements rather than the run length itself, so a single element run returns 0 instead of 1, and runs ending at the final element aren't properly captured because `best` is only updated inside the loop when elements match—meaning if the last run is just one element or if `cur` was never updated for the final position, the correct value gets lost. To fix this, initialize `best` and `cur` to 1 (since every run has at least one element), start the loop at 1, keep the same logic for incrementing `cur` when elements match and resetting otherwise, and update `best` after both branches or at the end to ensure the last run is considered. […]
out 250 tok latency 5.0 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Kimi K2.5 passed · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ```
out 51 tok latency 1.6 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Kimi K2.5 passed · 113 words, 0 banned, 1 question
**Announcing Prompt Cache: One Store, Every Provider** Stop rewriting the same prompts for different AI platforms. Our new API gateway feature stores your prompts in a unified cache, making them instantly available across OpenAI, Anthropic, Google, and more. Switch providers without touching your prompt library. Compare outputs side-by-side using identical inputs. Your team maintains one source of truth while gaining the flexibility to route requests wherever performance or pricing demands. Version history tracks every edit. Access controls keep sensitive prompts secure. And with sub-10ms retrieval times, latency won't slow you down. Why maintain separate prompt libraries when one intelligent cache does it all? Prompt Cache is available today for Enterprise and Scale plans.
out 141 tok latency 3.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Kimi K2.5 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-k2.5",
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-k2.5",
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-k2.5",
"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-k2.5",
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-k2.5")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Kimi K2.5
- Its Mixture-of-Experts design totals 1T parameters with 32B activated (384 experts, eight routed per token plus one shared), adds the 400M-parameter MoonViT vision encoder, and supports a 256K context.
- Versus Kimi K2, it introduces vision-language understanding, code generation from visual specifications, and Agent Swarm, moving from single-agent execution to coordinated swarm-like operation, with both thinking and instant modes; Moonshot's launch post describes swarms of up to 100 sub-agents working across as many as 1,500 tool calls.
- Moonshot names the workloads it built this for: document generation and conversion, slide creation, spreadsheet formulas and analysis, building websites from visual designs, and deep research with report synthesis.
- Modes are a parameter, not a separate model id: thinking is enabled by default and instant mode is thinking disabled, with reasoning returned in reasoning_content and counted against max_tokens.
- Unlike Moonshot's later coding models it does not carry reasoning across turns: preserved thinking is unsupported here.
- Function calling, partial-mode prefills, JSON and JSON-schema responses, and automatic prompt caching are all available, and Moonshot ships native INT4 quantization.
- Weights ship under a Modified MIT license whose one addition is an attribution requirement for very large commercial deployments.
- Synthorai makes Kimi K2.5 callable through its OpenAI-compatible API surface.
FAQ
Is the Kimi K2.5 API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.574/M input tokens, that credit alone covers roughly 217 requests of ~8K tokens against Kimi K2.5.
What is Kimi K2.5 best at?
Vision-language understanding and code from visual specs; agent swarm for coordinated multi-agent operation; 1T-parameter MoE under modified MIT license. See the About section for the full picture from the vendor's own release notes.
How much does Kimi K2.5 cost?
Kimi K2.5 costs $0.574 per million input tokens and $3.011 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.115/M.
Does Kimi K2.5 support prompt caching?
Yes, automatically: Moonshot-served prompts cache with no code changes. Cached input tokens bill at $0.115/M vs $0.574/M uncached. Prompt caching guide →
How do I get access to Kimi K2.5?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="kimi-k2.5", and you're done. One API key covers every model on the gateway.
Is Kimi K2.5 open source?
Yes: the weights are published under the Modified-MIT 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.