Kimi K3.1 Pro Highspeed is a faster serving tier of Kimi K3.1 Pro.
- Input
- text image $4/M
- Output
- text $20/M
- Cache read
- $0.2/M
- Context
- 1M
- vs GPT-4o
- ~20% 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) | 131,072 |
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 Highspeed passed · 3 sentences
Enabling reasoning makes the model generate extra “thinking” tokens before each answer, so every request consumes more compute and output tokens even when the visible response stays short. Those reasoning tokens are typically billed, and the new configuration may also use a more expensive model or processing tier, raising both usage and unit cost. To control spend, we should verify reasoning-token volume and model pricing on the invoice, then cap reasoning effort and reserve it for high-value tasks.
out 410 tok (+410 thinking) latency 8.6 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 Highspeed 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 else: cur = 1 best = max(best, cur) return best ``` The bug is counter bookkeeping, not the loop bounds: `cur` starts at zero, so the original counts equal adjacent pairs rather than items and never records a run for a single-element input. Runs are therefore reported one short, with singleton runs appearing as zero, including runs reaching the last index. The fix treats each item as a run of length one, resets `cur` to one on a mismatch, and updates `best` after every step, so a trailing run is recorded without needing a following mismatch; empty input returns `0`.
out 2102 tok (+2079 thinking) latency 31.7 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Kimi K3.1 Pro Highspeed passed · 5/5 fields, guidance "Formal guidance withheld pending the Q4 "
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "Formal guidance withheld pending the Q4 close" }
out 2170 tok (+2170 thinking) latency 29.3 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Kimi K3.1 Pro Highspeed passed · 120 words, 0 banned, 1 question
Introducing Cross-Provider Prompt Cache, a new API gateway feature that stores prompt responses and serves them across model providers. By reusing responses, teams can reduce latency, cut duplicate inference costs, and keep applications responsive during traffic spikes. You choose cache lifetime, scope, and eligibility rules, while provider credentials and routing policies remain under your control. Built-in metrics show hit rates, savings, and response times, helping you tune performance with confidence. Sensitive workloads can bypass caching, and entries expire according to your retention settings. Ready to spend less on repeated prompts? Enable the feature from your gateway configuration, define a cache policy, and start measuring results today. Cross-Provider Prompt Cache is available now, with documentation and examples in the developer console.
out 2161 tok (+2151 thinking) latency 23.5 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Kimi K3.1 Pro Highspeed 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-highspeed",
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-highspeed",
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-highspeed",
"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-highspeed",
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-highspeed")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Kimi K3.1 Pro Highspeed
- Through Synthorai this tier uses a fixed temperature of 0.6.
- Measure the latency benefit with your own prompts.
FAQ
Is the Kimi K3.1 Pro Highspeed API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $4/M input tokens, that credit alone covers roughly 31 requests of ~8K tokens against Kimi K3.1 Pro Highspeed.
What is Kimi K3.1 Pro Highspeed best at?
Faster serving tier; Image understanding; Long-context tool use. See the About section for the full picture from the vendor's own release notes.
How much does Kimi K3.1 Pro Highspeed cost?
Kimi K3.1 Pro Highspeed costs $4 per million input tokens and $20 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 Highspeed's context window?
Kimi K3.1 Pro Highspeed has a context window of 1M tokens on Synthorai. A single response can be up to 131,072 tokens long.
Does Kimi K3.1 Pro Highspeed support prompt caching?
Yes, automatically: Moonshot-served prompts cache with no code changes. Cached input tokens bill at $0.2/M vs $4/M uncached. Prompt caching guide →
How do I get access to Kimi K3.1 Pro Highspeed?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="kimi-k3.1-pro-highspeed", 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.