Kimi K3.1 Pro is Moonshot’s multimodal reasoning model for coding and long-running agent tasks. Use it with text and screenshots when your workflow needs a structured response.
- Input
- text image $2/M
- Output
- text $10/M
- Cache read
- $0.2/M
- Context
- 1M
- vs GPT-4o
- ~60% cheaper
Rates by prompt length
The whole request uses the rate for its input-length tier. Prices are USD per million tokens.
| Input tokens | Input | Output | Thinking input |
|---|
Price in context
Where the price sits among 79 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
| Parameter | reasoning_effort |
|---|---|
| Values | minimal · low · medium · high accepted set is the provider's |
Model
| Modalities | text + image → text |
|---|
One prompt, measured through the gateway
Kimi K3.1 Pro passed · 3 sentences
Enabling reasoning makes the model generate extra internal “thinking” tokens before responding, and these are typically billed at output-token rates even though users never see them. If request volume and pricing stayed flat but reasoning substantially increased tokens per request, the total bill could double. Compare pre- and post-change usage reports for reasoning tokens, then control costs with lower reasoning effort, token budgets, cheaper models, and selective use on tasks where the quality gain justifies the spend.
out 471 tok (+366 thinking) latency 14.3 s
Instruction following (exactly three sentences, so countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Kimi K3.1 Pro passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: best = max(best, cur) cur = 1 return max(best, cur) ``` The original `cur` counts matching adjacent pairs rather than items: it starts at 0, so a singleton returns 0, and a run of `k` equal items is recorded as only `k - 1`. Its bookkeeping also never correctly finalizes the current run’s length at end of input. The fix starts every run at 1, records its length when a mismatch ends it, and takes a final `max` after the loop so a run ending at the last index is included; empty input returns 0.
out 2984 tok (+2785 thinking) latency 70.1 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Kimi K3.1 Pro passed · 5/5 fields, guidance null
{"company":"Meridian Robotics","quarter":"September quarter","revenue_usd_m":412,"growth_pct":11,"guidance":null}
out 454 tok (+410 thinking) latency 12.0 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Kimi K3.1 Pro passed · 120 words, 0 banned, 1 question
Meet Prompt Cache, our new API gateway feature for caching prompts and responses across model providers. It cuts token spend, lowers latency, and keeps applications responsive during traffic surges. Define cache keys, expiration rules, and tenant boundaries in one policy, then apply them to OpenAI, Anthropic, Gemini, or custom models without changing application code. Encryption, redaction, and immediate purges help protect sensitive data, while metrics reveal hit rates, savings, and performance by endpoint and provider. Need a faster way to handle repeated requests? Serve eligible results from cache and preserve your existing routing, fallback, and retry behavior. Available today in beta, Prompt Cache gives platform teams controls for cost, speed, and reliability, with no extra infrastructure to deploy or maintain.
out 2740 tok (+2576 thinking) latency 55.8 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Kimi K3.1 Pro 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.1-pro",
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.1-pro",
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.1-pro",
"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.1-pro",
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.1-pro")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));FAQ
Is the Kimi K3.1 Pro API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $2/M input tokens, that credit alone covers roughly 62 requests of ~8K tokens against Kimi K3.1 Pro.
What is Kimi K3.1 Pro best at?
1M-token context; Image understanding; Coding and agent workflows. See the About section for the full picture from the vendor's own release notes.
How much does Kimi K3.1 Pro cost?
Kimi K3.1 Pro costs $2 per million input tokens and $10 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.2/M.
What is Kimi K3.1 Pro's context window?
Kimi K3.1 Pro has a context window of 1M tokens on Synthorai. A single response can be up to 1,048,576 tokens long.
Does Kimi K3.1 Pro support prompt caching?
Yes, automatically: Moonshot-served prompts cache with no code changes. Cached input tokens bill at $0.2/M vs $2/M uncached. Prompt caching guide →
How do I get access to Kimi K3.1 Pro?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="kimi-k3.1-pro", and you're done. One API key covers every model on the gateway.
Related models
Compare
Specifications and vendor benchmarks link to their sources. Gateway support describes the Synthorai implementation. Archived examples are individual gateway requests, not a guarantee of general model performance. Prices use the public feed or its build snapshot.