Which Kimi models we serve in Europe
You can run Kimi models in Europe through our API. Kimi is the model family from Moonshot AI. Its models are open-weight: anyone can download and run the trained model files. We serve the two current ones: Kimi K3 and Kimi K2.7 Code.
Where can you run Kimi K3 or Kimi K2.7 Code through a European API? Teams ask this when a customer wants to know where prompts are processed. If you call Kimi through another API today, check what it says about where prompts go.
Lyceum is a sovereign European AI inference provider for open-source models. Put plainly, we are a European company that runs open models for you on GPUs in European data centres. Serverless models are the ones you call per token, with no servers to manage, and ours run in Paris and Finland. Each Kimi model page shows its processing region as EU-hosted. We don't keep your prompts or outputs, and we never use them for training.
Open models are also close to the frontier now. Since January 2026, the best open-weight models have reached the scores of the best closed models about four months later, on average. The score is the Epoch Capabilities Index, Epoch AI's combined measure of model capability. Epoch AI published that measure on 29 May 2026.
The table lists both models with the prices on our models page, read on 23 October 2026. Prices are in US dollars per million tokens. Cached input is the price for repeated text at the start of a prompt (more on that below).
| Model | Model ID | Context window | Input | Cached input | Output | Speed (7-day median) |
|---|---|---|---|---|---|---|
| Kimi K3 | moonshotai/kimi-k3 | 1M tokens | $3.00 | $0.75 | $15.00 | 252 ms to first token, 57 tokens/s |
| Kimi K2.7 Code | moonshotai/kimi-k2.7-code | 256K tokens | $1.25 | $0.31 | $4.50 | 336 ms to first token, 110 tokens/s |
The context window is the most text one request can hold, prompt and answer together. The speeds come from our own status checks with short requests, measured on 23 October 2026. Time to first token is the wait before the first token arrives, and tokens per second is the writing speed. Reasoning tokens count in both figures. So the first token can be part of the model's working, and the visible answer starts later. The status page shows live availability.
Kimi K3: the large model with a 1M-token context
Kimi K3 is Moonshot's largest open model. Moonshot built it for long coding sessions, agent work and reasoning. It reads text and images, and one request can hold up to 1M tokens.
It is a mixture-of-experts (MoE) model: each token runs through only a few specialised parts of the network. Of its 2.8 trillion parameters, 104 billion work on each token. So each token costs far less computing than the model's full size suggests.
Kimi K3 reasons before it answers, and that is on by default. The reasoning is the model's written working, and it is billed as output. You can switch it off with `reasoning_effort: "none"`. Kimi K3 also enforces `tool_choice: "required"`, and you can force one tool by naming it. Your agent can then rely on a tool call when the next step must be one.
One request can write up to 131,072 tokens and run for up to 300 seconds. Set `stream: true` for long answers, so tokens arrive as they are written.
Kimi K2.7 Code: the coding model built on K2.6
Kimi K2.7 Code is Moonshot's coding model, built on Kimi K2.6. It is smaller than Kimi K3: 1 trillion parameters, with 32 billion working on each token. Its context window is 256K tokens. It reads text, images and PDFs.
Moonshot says it uses about 30% fewer thinking tokens than Kimi K2.6 on coding tasks. Fewer thinking tokens means less billed output per task. Moonshot also reports a higher score on Kimi Code Bench v2, its own in-house set of real coding tasks: 62.0 against 50.9 for Kimi K2.6. That is the vendor's own test, so check it on your code.
Reasoning is always on for Kimi K2.7 Code. If you send a setting to switch it off, we accept the request and ignore the setting. Leave room for the reasoning when you set `max_tokens`, the cap on output tokens per request.
What one coding-agent turn costs on each
On Kimi K2.7 Code, one coding-agent turn in our example costs $0.0346 when the cache hits. On Kimi K3, the same turn costs $0.0960. The token counts are an example we chose. The agent resends 60,000 tokens of earlier context: its instructions, tool definitions, files and history. It adds 2,000 new tokens and writes 3,000 tokens of reasoning and answer.
Prompt caching is what makes the repeated part cheaper: when a request starts exactly like a recent one, we reuse that start. A cache hit is a request where that reuse works. You then pay the cached-input price for those 60,000 tokens. A cache miss is a request where it does not, so they are billed at the full input price.
Kimi K3, cache hit: 60,000 x $0.75 + 2,000 x $3.00 + 3,000 x $15.00, per 1M tokens = $0.0960
Kimi K3, cache miss: 62,000 x $3.00 + 3,000 x $15.00, per 1M tokens = $0.2310
Kimi K2.7 Code, cache hit: 60,000 x $0.31 + 2,000 x $1.25 + 3,000 x $4.50, per 1M tokens = $0.0346
Kimi K2.7 Code, cache miss: 62,000 x $1.25 + 3,000 x $4.50, per 1M tokens = $0.0910The code block shows each step. With a cache hit, Kimi K3 costs about 2.8 times as much for the same turn ($0.0960 divided by $0.0346). Over a 40-turn session with every turn a hit, that is $3.84 against $1.38.
Speed changes the picture too. At the measured output speeds, 3,000 tokens take about 53 seconds on Kimi K3. They take about 27 seconds on Kimi K2.7 Code.
The 300-second limit caps long answers. At 57 tokens per second, Kimi K3 writes about 17,100 tokens in 300 seconds. At 110 tokens per second, Kimi K2.7 Code writes about 33,000. Both figures are far below the 131,072-token maximum, so plan long outputs as several requests.
This example favours both models in two ways: every turn hits the cache, and the context never grows. It assumes the same token counts on both models, which real tasks will not match. The speeds come from short requests, so long prompts will start later.
Kimi K2.6 and K2.5 are retired: what to use instead
Our models page lists retired models with a model to use instead. It names Kimi K3 for Kimi K2.6. For Kimi K2.5 it names GLM-5.3 Flash (`z-ai/glm-5.3-flash`), Z.ai's low-cost model.
| Retired model | Former model ID | Use instead |
|---|---|---|
| Kimi K2.6 | moonshotai/kimi-k2.6 | Kimi K3 (moonshotai/kimi-k3) |
| Kimi K2.5 | Not published | GLM-5.3 Flash (z-ai/glm-5.3-flash) |
If you used Kimi K2.6 for coding, test Kimi K2.7 Code as well. It is built on Kimi K2.6, and it costs less per token than Kimi K3.
Calling Kimi through our OpenAI-compatible API
The API accepts requests in the same format as OpenAI's API. So you keep the OpenAI SDK and change two settings: the base URL and the model ID. Create an API key in your dashboard and set it as `LYCEUM_API_KEY`.
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-k2.7-code",
messages=[{"role": "user", "content": "Write a unit test for parse_date()."}],
max_tokens=8000,
)
print(response.choices[0].message.content)
print(response.usage)Prompt caching is automatic on both models. To get it, keep the stable part of the prompt at the front. Put the system prompt and tool definitions first, and append new turns at the end. A cache hit is best effort. Read `usage.prompt_tokens_details.cached_tokens` to see it: the field is missing on a miss.
Coding tools work the same way. Point them at the same base URL and model ID. Our inference page lists the tools we support. For more on each model, read our Kimi K3 API guide and our Kimi K2.7 Code article.