Kimi K2.7 Code API

MODEL NAMES

kimi-k2.7-code
kimi-k2.7-code-highspeed

BASE URL

https://api.moonshot.ai/v1

WORKS WITH

The OpenAI SDK. An Anthropic-style address is also offered

CONTEXT

262,144 tokens, input and output together

DEFAULT OUTPUT LIMIT

32,768 tokens (max_tokens)

THINKING

Always on. It cannot be switched off

INPUT

Text and images. Video too, through Moonshot's API

PRICE PER MILLION TOKENS

$0.95 in · $0.19 cached · $4.00 out

From Moonshot's Kimi K2.7 Code quickstart, models page and price page. Prices exclude tax.

1. Sign in to Moonshot's API platform at platform.kimi.ai and add a small balance. The minimum is $1.
2. Create an API key in the console. Copy it straight away.
3. Save it as an environment variable named MOONSHOT_API_KEY. Do not paste it into your code.
4. For Python, install the OpenAI SDK: pip install --upgrade "openai>=1.0". For Node, run npm install openai.

Need more detail on keys and accounts? See Kimi API setup.

All three examples do the same thing: ask Kimi K2.7 Code to write a small function and print its answer.

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -d '{
    "model": "kimi-k2.7-code",
    "max_tokens": 4096,
    "messages": [
      {"role": "user", "content": "Write a Python function that checks if a number is prime."}
    ]
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.7-code",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Write a Python function that checks if a number is prime."}
    ],
)

print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k2.7-code",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Write a Python function that checks if a number is prime." },
  ],
});

console.log(response.choices[0].message.content);

The Python example follows Moonshot's quickstart. The curl and Node versions use the same request in the standard OpenAI format. Notice what is missing: no temperature setting.

Because the model always thinks first, each reply has two parts.

This is the most common source of errors. Moonshot fixes several settings for this model. Sending any other value returns an error, so the simplest approach is to leave them out.

On a small screen, swipe the table sideways to see every column.

Many coding tools and libraries send a temperature by default. If yours does, look for a way to remove it. Need thinking switched off for fast, simple calls? Use kimi-k2.6 for those.

Tools are how a coding model does real work: reading files, running tests, searching a project. You describe each tool, the model asks to use one, your code runs it and sends the result back.

• Keep the whole assistant message. After each reply, add the full message to your history, including reasoning_content. Moonshot says leaving the thinking out will not cause an error but can make later steps worse.
• Answer every tool call. Add one tool message for each call, with the matching tool_call_id.
• Loop until there are no more calls. When a reply has no tool calls, it is the final answer.

import json, os
from openai import OpenAI

client = OpenAI(api_key=os.environ["MOONSHOT_API_KEY"],
                base_url="https://api.moonshot.ai/v1")

tools = [{
    "type": "function",
    "function": {
        "name": "read_file",
        "description": "Read a text file from the project",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    },
}]

def read_file(path):
    with open(path, encoding="utf-8") as f:
        return f.read()

messages = [{"role": "user", "content": "Explain what main.py does."}]

while True:
    response = client.chat.completions.create(
        model="kimi-k2.7-code",
        messages=messages,
        tools=tools,
        tool_choice="auto",
        max_tokens=8192,
    )
    message = response.choices[0].message
    # Keep the whole assistant turn, including its thinking
    messages.append(message.model_dump(exclude_none=True))

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": read_file(**args),
        })

A teaching example written for this guide, based on the pattern in Moonshot's quickstart. In real use, limit which files a tool may read and add a cap on the number of loops.

{
  "role": "user",
  "content": [
    {"type": "image_url",
     "image_url": {"url": "data:image/png;base64,PASTE_BASE64_HERE"}},
    {"type": "text", "text": "Write the HTML and CSS for this screen."}
  ]
}

No code needed for this in the app: see Visual Coding and Design to Code.

To use the faster version, change one thing: the model name.

More: K2.7 Code HighSpeed.

You do not have to write your own agent. Moonshot documents how to connect its API to several existing coding tools, including Claude Code, OpenCode and its own Kimi Code CLI.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.moonshot.ai/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_MOONSHOT_API_KEY",
    "ANTHROPIC_MODEL": "kimi-k2.7-code",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "kimi-k2.7-code",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "kimi-k2.7-code",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "kimi-k2.7-code",
    "ANTHROPIC_DEFAULT_FABLE_MODEL": "kimi-k2.7-code",
    "CLAUDE_CODE_SUBAGENT_MODEL": "kimi-k2.7-code"
  }
}

Adapted from Moonshot's Claude Code guide. Moonshot's own example uses kimi-k3 for most lines and kimi-k2.7-code for the lightest one. This version uses kimi-k2.7-code throughout to keep costs low.

Prefer Moonshot's own tool? See Kimi Code setup. Paying monthly instead of per token? See API vs subscription.

On a small screen, swipe the table sideways to see every column.

• Cached input is text the model has seen before. Coding sessions resend a lot of the same context, so this lower price matters.
• Batch is for jobs that can wait. You submit many requests together and collect the results later, at 60% of the standard price. Batch jobs are not held to the live rate limits.
• Thinking counts as output. Budget for it.
• Prices exclude tax.

Estimate a monthly bill with the calculator on the Kimi K2.7 Code page. More: API pricing · rate limits and enterprise pricing

On a small screen, swipe the table sideways to see every column.

From Moonshot's error code page and Kimi K2.7 Code quickstart. More help: Kimi not working?