Kimi K3

Kimi K3 is Moonshot AI's flagship model for long-horizon coding, agents and knowledge work. It always reasons before it answers, and you choose how hard with reasoning_effort. Send the official Kimi request to TokLab: change the base URL and the API key, keep the body.

Model ID

Input: text and images. Output: text. See the pricing page for current prices.

Quick example

curl https://api.toklab.ai/v1/chat/completions \
  -H "Authorization: Bearer $TOKLAB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [{"role": "user", "content": "Explain context caching in one sentence."}]
  }'

Endpoints

All three return Kimi's official response format, streaming or not. Keep the API key in server-side code.

Parameters

Chat Completions fields:

Reasoning and effort

Kimi K3 always reasons; there is no way to turn it off. reasoning_effort sets how much: max (the default) for the hardest work, high for most tasks, low for fast, simple steps. The reasoning comes back in reasoning_content, next to content. Reasoning tokens are billed as output tokens and count toward max_completion_tokens.

In multi-turn conversations and tool calls, send each assistant message back unchanged, including its reasoning_content.

Image input

Kimi K3 takes images as base64 data URIs. A public image URL is not accepted and returns 400, as on Kimi's own API.

{"role": "user", "content": [
  {"type": "image_url", "image_url": {"url": "data:image/png;base64,<BASE64_DATA>"}},
  {"type": "text", "text": "Describe this image."}
]}

Context caching

Caching is automatic: a repeated prompt prefix is read from the cache at the lower cached-input rate. prompt_cache_options.ttl chooses how long a written prefix stays cached, 5m (the default) or 1h; choose 1h when your requests are more than five minutes apart. usage.prompt_tokens_details.cached_tokens reports the tokens read from the cache and cache_write_tokens the cache writes billed for the request.

Billing dimensions

See the current rates on the pricing page. A request is billed by the tokens it uses:

• input tokens,
• cached input tokens (cached_tokens),
• cache-write tokens (cache_write_tokens),
• output tokens, including reasoning.

Prices do not change with context length. The charge is taken from the usage reported with the finished response. A request that fails is not charged. Your account's usage records show the exact charge for every request.

Output

A non-streaming Chat Completions request returns:

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1790585961,
  "model": "kimi-k3",
  "choices": [{
    "index": 0,
    "finish_reason": "stop",
    "message": {"role": "assistant", "reasoning_content": "...", "content": "..."}
  }],
  "usage": {
    "prompt_tokens": 90,
    "completion_tokens": 57,
    "total_tokens": 147,
    "cached_tokens": 90,
    "prompt_tokens_details": {"cached_tokens": 90, "cache_write_tokens": 0}
  }
}

With "stream": true each chunk carries a delta with reasoning_content or content. With stream_options.include_usage a last chunk with an empty choices array carries the usage before data: [DONE].

Responses API and Codex

POST /v1/responses takes the Responses body: input, instructions, max_output_tokens, reasoning.effort (low, high, max), text.format (json_schema), tools (function and the apply_patch custom tool), tool_choice, stream, prompt_cache_options, prompt_cache_key and safety_identifier. The reasoning comes back as a reasoning item with a summary_text part, and a stream carries numbered events from response.created to response.completed. The API is stateless: previous_response_id and conversation are ignored, so send the whole conversation in input. The web_search tool is ignored.

To use Kimi K3 in Codex, add a provider to ~/.codex/config.toml and set TOKLAB_API_KEY:

model = "kimi-k3"
model_provider = "toklab"
model_context_window = 1048576

[model_providers.toklab]
name = "TokLab"
base_url = "https://api.toklab.ai/v1"
env_key = "TOKLAB_API_KEY"
wire_api = "responses"

Anthropic Messages format

Code written for the Anthropic Messages API can call Kimi K3 too: send the Messages body to /v1/messages with "model": "kimi-k3". system, max_tokens, tools, tool_choice (auto, none) and output_config.effort (low, high, max) are applied, and metadata.user_id and cache_control are accepted. stop_sequences (up to 5), tool_choice any and output_config.format are accepted but have no effect. The reasoning comes back as thinking blocks. Images go in as base64 sources.

Errors

Errors use {"error": {"code": ..., "message": "..."}} (the Messages endpoint uses Anthropic's error shape). The code is a code from the common error catalog. Failed requests are not charged.

Tips

• Start with high effort and move to max only for the hardest problems; low suits quick, simple steps.
• Set max_completion_tokens high enough for the reasoning as well as the answer: it is one budget for both.
• Keep long, reused context at the start of the prompt so later requests read it from the cache, and use the 1h TTL when requests are spread out.

Related

• Kimi K3 pricing
• Download OpenAPI
• Copyable Markdown

Optional LLM group

The groups you can use depend on your account permissions and the model. The pricing page lists each group's prices.

API calls keep your API key and model ID. To select a group, send its exact name in the optional X-SeedRouter-Group request header, or append it to the model ID as model:<group> (see Model tiers). Replace GROUP_NAME below with one of your groups. Omit the header or use auto to keep the key's default behavior.

X-SeedRouter-Group: GROUP_NAME

A restricted API key may have fewer group options than your account. Requests use the selected group's pricing and do not switch to another group if it is unavailable. This option supports HTTP LLM calls, including SSE; it does not apply to WebSocket, image or video calls.

To see the groups your key can use, call GET /v1/models: it lists model:<group> next to the model ID for every model your key can call in more than one group.