What a long context costs depends on how much of each prompt repeats. A cached token (one we reuse from a recent identical prompt start) costs a quarter of a fresh one. In our worked example, a 900,000-token agent turn drops from $2.85 to $0.87.
Where can I run Kimi K3 with processing in Europe, and what will a 1M-token context cost me per call? Kimi K3 is Moonshot AI's largest open model, so the answer decides your data path and your bill.
Where to run Kimi K3 with processing in Europe
Lyceum is a sovereign European AI inference provider for open-source models. Our serverless models run in Paris and Finland, and the Kimi K3 model page lists its region as EU-hosted. Prompts and outputs are processed, not stored, and never used for training.
Open models are now a real alternative to a US API. Epoch AI found that since January 2026, the best open-weight models have trailed the best closed ones by about four months. It measures this on its Epoch Capabilities Index, an aggregate measure of model capability. Its data is dated 29 May 2026.
We checked the main routes on the providers' own pages on 20 October 2026. Prices are USD per million tokens.
| Route | What we found on 20 October 2026 |
|---|---|
| Our serverless inference | EU-hosted, serverless in Paris and Finland; $3.00 input, $0.75 cached input, $15.00 output |
| AWS Bedrock | No EU option. Kimi K3 runs only through inference profiles that keep requests in the US or in India, or that send them to any AWS Region worldwide (Global cross-Region inference). |
| OpenRouter | moonshotai/kimi-k3 is not in its EU-region model list of 67 models |
| Runpod public endpoint, kimi-k3 | $3.00 input and $15.00 output, with no cached-input rate listed |
| Scaleway, OVHcloud, IONOS, STACKIT | No Kimi model in their public model lists |
| Self-hosting | Open weights under the Kimi K3 License; you run and size the GPUs |
Moonshot publishes the weights on Hugging Face under the Kimi K3 License. At 2.8 trillion parameters, sizing that hardware is a project of its own. See our guide to long-context inference GPU requirements.
Kimi K3 API pricing next to the other models we serve
Kimi K3 is billed per token, in US dollars, with no base fee. The rates below are from our models page, read on 20 October 2026.
| Model | Model ID | Context window | Input | Cached input | Output |
|---|---|---|---|---|---|
| Kimi K3 | moonshotai/kimi-k3 | 1M | $3.00 | $0.75 | $15.00 |
| Kimi K2.7 Code | moonshotai/kimi-k2.7-code | 256K | $1.25 | $0.31 | $4.50 |
| GLM-5.3 | z-ai/glm-5.3 | 1M | $1.40 | $0.26 | $4.40 |
| DeepSeek V4 Pro 0813 | deepseek/deepseek-v4-pro-0813 | 1M | $2.00 | $0.50 | $4.00 |
| MiniMax M3 | minimax/minimax-m3 | 1M | $0.40 | $0.10 | $2.00 |
Kimi K3 is the highest-priced model here, most of all on output. For coding-only work within 256K tokens, Kimi K2.7 Code is still on our serverless catalogue, as moonshotai/kimi-k2.7-code[[kb:d151645f-bec2-4568-8780-37b29c0178b6]]. Its current price sits on its model page. Kimi K2.6 was retired on 5 October 2026. That model id now routes to Kimi K3 at K3 rates. Our comparison of Kimi K3 vs DeepSeek V4 Pro weighs price against results.
Claude Fable 5.1 and Claude Opus 5.5 cost more per fresh token. Anthropic lists Claude Fable 5.1 at $10 input and $50 output per million tokens, and Claude Opus 5.5 at $4 and $20. We read both prices on 20 October 2026. Both have a 1M-token context window. Anthropic's cache has its own prices for writing a prompt into it and for reading it back, so which model is cheaper depends on how often your prompts hit the cache. Compare on your own traffic, or read our earlier Kimi K3 vs Claude Fable 5 comparison, written for the version before Fable 5.1. Our cost per million tokens comparison covers more providers.
What a 1M-token context costs per request and per session
Each Kimi K3 request is billed across three components, with prices per million tokens:
cost = (fresh input tokens × $3.00 + cached input tokens × $0.75 + output tokens × $15.00) / 1,000,000One request carries at most 1,048,576 input tokens ($3.15) and generates at most 131,072 output tokens ($1.97). So no single request costs more than $5.11 at list prices. That figure is a ceiling: it assumes one request uses both limits in full. Our guide to LLM context length and GPU memory explains why long prompts are heavy to serve.
Our worked example is a hypothetical coding agent. An agent loop is a program that calls the model again and again, resending the repository and conversation each time. Each turn here sends 900,000 input tokens and gets 10,000 output tokens back.
| Calculated example (hypothetical inputs) | Input | Cached input | Output | Cost |
|---|---|---|---|---|
| One turn, nothing cached | 900,000 | 0 | 10,000 | $2.85 |
| One turn, 880,000 tokens cached | 20,000 | 880,000 | 10,000 | $0.87 |
| 20-turn session, nothing cached | 18,000,000 | 0 | 200,000 | $57.00 |
| 20-turn session, cached after turn 1 | 1,280,000 | 16,720,000 | 200,000 | $19.38 |
The cached turn is $0.66 of cached input, $0.06 of fresh input and $0.15 of output. Over the session, caching saves 66%. The same uncached turn costs $9.50 on Claude Fable 5.1 and $3.80 on Claude Opus 5.5 at Anthropic's list prices.
The cached session row adds turn 1 at full price (900,000 input tokens) to 19 turns of 20,000 fresh and 880,000 cached input tokens each. Every turn returns 10,000 output tokens. The example favours caching: it assumes every turn after the first hits the cache, and it keeps the prompt at 900,000 tokens. In a real session each turn appends new messages, so the prompt gets longer and every turn costs more than shown.
How prompt caching cuts Kimi K3 input costs
Prompt caching means a repeated prompt start that is still in GPU memory bills at the cached input price. On Kimi K3 it is automatic and best effort, so a hit is likely but not guaranteed.
We tested it on 20 October 2026 with three requests that shared one 8,857-token system prompt. The first was a cache miss (no reusable prompt start in memory) and took 0.76 seconds. The second and third read 8,704 of the 8,857 tokens from the cache and took 0.28 seconds each. The uncached rest includes the question at the end, which changed each time. Each call returned 10 output tokens. At list prices, each cached call cost $0.0071 against $0.0267 for the first. It was one short test, not a benchmark.
The response reports hits in usage.prompt_tokens_details.cached_tokens, a field that is missing on a cache miss. In the dashboard, Inference → Serverless → Usage splits input, output and cached tokens per model, member and API key.
Put the system prompt, tools and repository first, and append new turns at the end. The cache is held only in GPU memory. Our trust page states that recent prompt prefixes stay in GPU memory until newer requests replace them, never on disk or in a database.
Calling the Kimi K3 API: code, Claude Code and limits
Kimi K3 runs on our serverless inference through an OpenAI-compatible API. Your OpenAI SDK needs our base URL, your Lyceum API key and the model ID.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["LYCEUM_API_KEY"],
base_url="https://api.lyceum.technology/openai/v1",
)
response = client.chat.completions.create(
model="moonshotai/kimi-k3",
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)For Claude Code, we run an Anthropic-compatible endpoint. Our recommended route is the Lyceum CLI, which starts Claude Code preconfigured:
pip install lyceum-cli
lyceum auth login --api-key "$LYCEUM_API_KEY"
lyceum codeFor a quick test in one terminal, set three environment variables instead. ANTHROPIC_AUTH_TOKEN carries your Lyceum API key. Our Claude Code documentation prefers it to ANTHROPIC_API_KEY, which makes Claude Code ask you to approve the key on first run.
export ANTHROPIC_BASE_URL="https://api.lyceum.technology/anthropic"
export ANTHROPIC_AUTH_TOKEN="$LYCEUM_API_KEY"
export ANTHROPIC_MODEL="moonshotai/kimi-k3"
claudeClaude Code marks extended-context Claude models with a [1m] suffix, as in sonnet[1m]. The suffix only works with Anthropic, and Claude Code will not connect through our endpoint while it is set. Use a model name without it, such as moonshotai/kimi-k3.
The model page and our serverless documentation set the limits for moonshotai/kimi-k3:
- Output: up to 131,072 tokens per request. Our test call on 20 October 2026 accepted max_tokens 100000 and rejected 140000.
- Generation time: up to 300 seconds per request, so stream long outputs.
- Reasoning: on by default. The reasoning trace (the model's written steps before its answer) bills as output, and reasoning_effort "none" switches it off.
- Tool calling: OpenAI format, and Kimi K3 honours tool_choice "required" and a named function.
- Input: text and images, each image sent as an image_url content part (one piece of the message content). PDF parts are rejected. If you need PDF input, use Kimi K2.7 Code, which reads them.
- Multi-turn: Moonshot's model card asks you to pass back the complete assistant message, including reasoning_content (the field that holds the model's reasoning).
Our status checks measured a median 251 ms to the first token for short Kimi K3 requests. Output ran at 57 tokens per second (median, measured 20 October 2026, 16:09 UTC). Live figures are on our status page.
Moving from Kimi K2.6 to Kimi K3
Kimi K2.6 was retired on 5 October 2026, and its model ID now routes to Kimi K3 at Kimi K3 rates. In our test call on 20 October 2026, a request for moonshotai/kimi-k2.6 came back from moonshotai/kimi-k3.
Change the model ID to moonshotai/kimi-k3. Old traffic that sent PDFs or was coding-only fits Kimi K2.7 Code better. It reads PDFs and costs $1.25 input and $4.50 output per million tokens.
Summary
Kimi K3 gives you a 1M-token window, EU-hosted in Paris and Finland, at $3.00 input, $0.75 cached input and $15.00 output per million tokens. What you pay depends mostly on the cache and on reasoning: a stable prompt start cut our example 20-turn session from $57.00 to $19.38, and reasoning bills as output, so set max_tokens for reasoning plus the answer.
We recommend Kimi K3 when your job needs the 1M-token window or long agentic work beyond code. Send your first request from the Kimi K3 model page.