Chat Completions API

POST

chat

completions

创建聊天补全

curl --request POST \
  --url https://api.moonshot.cn/v1/chat/completions \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": "你好",
      "name": null,
      "partial": false
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "<string>",
        "parameters": {},
        "description": "<string>",
        "strict": true
      }
    }
  ]
}
'

import requests

url = "https://api.moonshot.cn/v1/chat/completions"

payload = {
    "model": "kimi-k3",
    "messages": [
        {
            "role": "user",
            "content": "你好",
            "name": None,
            "partial": False
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "<string>",
                "parameters": {},
                "description": "<string>",
                "strict": True
            }
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    model: 'kimi-k3',
    messages: [{role: 'user', content: '你好', name: null, partial: false}],
    tools: [
      {
        type: 'function',
        function: {name: '<string>', parameters: {}, description: '<string>', strict: true}
      }
    ]
  })
};

fetch('https://api.moonshot.cn/v1/chat/completions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.moonshot.cn/v1/chat/completions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'model' => 'kimi-k3',
    'messages' => [
        [
                'role' => 'user',
                'content' => '你好',
                'name' => null,
                'partial' => false
        ]
    ],
    'tools' => [
        [
                'type' => 'function',
                'function' => [
                                'name' => '<string>',
                                'parameters' => [
                                                                
                                ],
                                'description' => '<string>',
                                'strict' => true
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.moonshot.cn/v1/chat/completions"

	payload := strings.NewReader("{\n  \"model\": \"kimi-k3\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\",\n      \"name\": null,\n      \"partial\": false\n    }\n  ],\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"function\": {\n        \"name\": \"<string>\",\n        \"parameters\": {},\n        \"description\": \"<string>\",\n        \"strict\": true\n      }\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.moonshot.cn/v1/chat/completions")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"kimi-k3\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\",\n      \"name\": null,\n      \"partial\": false\n    }\n  ],\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"function\": {\n        \"name\": \"<string>\",\n        \"parameters\": {},\n        \"description\": \"<string>\",\n        \"strict\": true\n      }\n    }\n  ]\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.moonshot.cn/v1/chat/completions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"kimi-k3\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\",\n      \"name\": null,\n      \"partial\": false\n    }\n  ],\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"function\": {\n        \"name\": \"<string>\",\n        \"parameters\": {},\n        \"description\": \"<string>\",\n        \"strict\": true\n      }\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "object": "chat.completion",
  "created": 123,
  "model": "<string>",
  "choices": [
    {
      "index": 123,
      "message": {
        "role": "assistant",
        "content": "<string>",
        "tool_calls": [
          {
            "id": "<string>",
            "type": "function",
            "function": {
              "name": "<string>",
              "arguments": "<string>"
            }
          }
        ],
        "reasoning_content": "<string>"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 123,
    "completion_tokens": 123,
    "total_tokens": 123,
    "cached_tokens": 123,
    "prompt_tokens_details": {
      "cached_tokens": 123,
      "cache_write_tokens": 123
    }
  }
}

{
  "error": {
    "message": "<string>",
    "type": "<string>",
    "code": "<string>"
  }
}

{
  "error": {
    "message": "<string>",
    "type": "<string>",
    "code": "<string>"
  }
}

{
  "error": {
    "message": "<string>",
    "type": "<string>",
    "code": "<string>"
  }
}

创建一个对话补全请求，模型将根据输入的消息列表生成回复。

Content 字段说明

content 字段支持以下两种形式：纯文本字符串

{ "content": "你好" }

对象数组（用于多模态输入）数组中每个元素通过 type 字段区分类型：

{
    "content": [
        { "type": "text", "text": "描述这张图片" },
        { "type": "image_url", "image_url": { "url": "data:image/png;base64,..." } },
        { "type": "video_url", "video_url": { "url": "data:video/mp4;base64,..." } }
    ]
}

其中 image_url 和 video_url 也支持直接传入字符串，效果等同于对象形式中的 url 字段：

{ "type": "image_url", "image_url": "data:image/png;base64,..." }

参数说明

数组中每个元素的字段说明如下：

参数名称	是否必须	说明	类型
`type`	required	内容类型	`"text"` \| `"image_url"` \| `"video_url"`
`text`	当 `type=text` 时必填	文本内容	string
`image_url`	当 `type=image_url` 时必填	用于传输图片，支持对象形式 `{"url": "..."}` 或直接传入 URL 字符串	object \| string
`video_url`	当 `type=video_url` 时必填	用于传输视频，支持对象形式 `{"url": "..."}` 或直接传入 URL 字符串	object \| string

当 image_url 传入对象时，其字段说明如下：

参数名称	是否必须	说明	类型
`url`	required	使用 base64 编码或通过 file id 指定的图片内容	string

当 video_url 传入对象时，其字段说明如下：

参数名称	是否必须	说明	类型
`url`	required	使用 base64 编码或通过 file id 指定的视频内容，例如 `data:video/mp4;base64,...`	string

无论使用对象形式（url 字段）还是字符串简写，均支持以下两种格式：

base64 编码：data:image/png;base64,... 或 data:video/mp4;base64,...
文件引用：ms://<file_id>

详见使用 Kimi 视觉模型。

调用示例

import os
import base64

from openai import OpenAI
from openai.types.chat import ChatCompletion

client: OpenAI = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.cn/v1",
)

# 对图片进行 base64 编码
with open("您的图片地址", "rb") as f:
    img_base: str = base64.b64encode(f.read()).decode("utf-8")

response: ChatCompletion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{img_base}",
                    },
                },
                {
                    "type": "text",
                    "text": "请描述这个图片",
                },
            ],
        }
    ],
)
print(response.choices[0].message.content)

curl https://api.moonshot.cn/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $MOONSHOT_API_KEY" \
    -d '{
        "model": "kimi-k2.6",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": "data:image/jpeg;base64,/9j/4AAQ..."
                        }
                    },
                    {
                        "type": "text",
                        "text": "请描述这个图片"
                    }
                ]
            }
        ]
    }'

const fs = require("fs");
const OpenAI = require("openai");

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

async function main() {
    // 对图片进行 base64 编码
    const imgBase = fs.readFileSync("您的图片地址").toString("base64");

    const response = await client.chat.completions.create({
        model: "kimi-k2.6",
        messages: [
            {
                role: "user",
                content: [
                    {
                        type: "image_url",
                        image_url: {
                            url: `data:image/jpeg;base64,${imgBase}`,
                        },
                    },
                    {
                        type: "text",
                        text: "请描述这个图片",
                    },
                ],
            },
        ],
    });
    console.log(response.choices[0].message.content);
}

main();

响应格式

非流式响应

{
    "id": "cmpl-04ea926191a14749b7f2c7a48a68abc6",
    "object": "chat.completion",
    "created": 1698999496,
    "model": "kimi-k2.6",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "你好，李雷！1+1等于2。如果你有其他问题，请随时提问！"
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "completion_tokens": 21,
        "total_tokens": 40,
        "cached_tokens": 10,
        "prompt_tokens_details": {
            "cached_tokens": 10,
            "cache_write_tokens": 0
        }
    }
}

流式响应

data: {"id":"cmpl-xxx","object":"chat.completion.chunk","created":1698999575,"model":"kimi-k2.6","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"cmpl-xxx","object":"chat.completion.chunk","created":1698999575,"model":"kimi-k2.6","choices":[{"index":0,"delta":{"content":"你好"},"finish_reason":null}]}

...

data: {"id":"cmpl-xxx","object":"chat.completion.chunk","created":1698999575,"model":"kimi-k2.6","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":19,"completion_tokens":13,"total_tokens":32,"cached_tokens":12,"prompt_tokens_details":{"cached_tokens":12,"cache_write_tokens":0}}}

data: [DONE]

响应示例中的模型名称会根据请求中的 model 参数返回。当使用 kimi-k2.6 模型时，响应中的 "model" 字段将显示为 "kimi-k2.6"。

上下文缓存（Cache Write）

Kimi API 会对重复的请求前缀自动启用上下文缓存，命中部分以更低价格计费且响应更快。通过 prompt_cache_options 可以控制缓存写入行为：

参数	类型	说明
`prompt_cache_options`	object	上下文缓存写入选项。不传时默认开启缓存写入（`5m` 档）
`prompt_cache_options.mode`	`"implicit"`	缓存写入模式，仅支持 `implicit`：自动将请求前缀写入缓存
`prompt_cache_options.ttl`	`"5m"` \| `"1h"`	缓存写入的有效期，仅支持 `5m`、`1h` 两档（默认 `5m`），两档缓存相互独立

{
    "model": "kimi-k3",
    "messages": [{"role": "user", "content": "你好"}],
    "prompt_cache_options": { "mode": "implicit", "ttl": "1h" }
}

行为说明

缓存以组织（org）为粒度隔离，组织之间不共享缓存。
相同前缀的请求在缓存有效期内命中后，缓存的有效期会按原 TTL 刷新；命中部分只收取缓存读取费用，不再收取缓存写入费用。
缓存写入按 TTL 档位分别计费，价格详见产品定价。
不支持手动清除缓存，已缓存的前缀在至少 5 分钟不活动后自动过期。
暂不支持显式缓存断点：content 中出现 prompt_cache_breakpoint 时请求会被拒绝（HTTP 400）。

用量字段usage.prompt_tokens 始终为总输入 Token 数，其内部分类通过 prompt_tokens_details 返回：

字段	说明
`usage.prompt_tokens_details.cached_tokens`	命中缓存的 Token 数量（缓存读取）
`usage.prompt_tokens_details.cache_write_tokens`	本次写入缓存的 Token 数量（缓存写入）

cached_tokens、cache_write_tokens 与未缓存部分互斥，三者之和等于 prompt_tokens，即未缓存部分 = prompt_tokens − cached_tokens − cache_write_tokens。流式请求中，完整的缓存读写明细仅在最后一个 chunk 的 usage 字段中返回（需设置 stream_options.include_usage=true）。Chat Completions 的响应不回显实际应用的 mode/ttl（与 Responses API 不同），请从请求发起侧记录所用取值。

Context Caching 的机制背景详见上下文缓存指南。

多轮对话

Kimi API 是无状态的，本身不具有记忆功能。要实现多轮对话，需在每次请求时把前一轮的 assistant 回复（以及工具执行结果，如适用）原样追加到 messages 数组中再发送。

messages = [
    {"role": "system", "content": "你是 Kimi。"},
    {"role": "user", "content": "你好，我叫李雷。"}
]

completion = client.chat.completions.create(model="kimi-k2.6", messages=messages)
reply = completion.choices[0].message

# 将 assistant 回复追加回 messages，供下一轮使用
messages.append({"role": "assistant", "content": reply.content})
messages.append({"role": "user", "content": "1+1 等于多少？"})

当对话历史过长时，建议只保留最近的若干条消息，或做消息压缩，以避免超出模型的上下文长度限制。

详见配置多轮对话参数。

JSON Mode

通过 response_format 参数可约束模型输出格式：

{"type": "text"}（默认）：普通文本输出
{"type": "json_object"}：强制输出合法 JSON Object
{"type": "json_schema", "json_schema": {...}}：按给定 JSON Schema 输出结构化数据（Structured Output）

使用 json_object 时，必须在 system prompt 或 user prompt 中明确描述期望的 JSON 字段和类型，否则模型可能输出不符合预期的结果。

{
  "model": "kimi-k2.6",
  "messages": [
    {"role": "system", "content": "请输出 JSON，包含 title、author、summary 字段。"},
    {"role": "user", "content": "总结这篇文章..."}
  ],
  "response_format": {"type": "json_object"}
}

详见使用 Kimi API 的 JSON Mode。

工具调用 Tool Use

通过 tools 参数传入 JSON Schema 定义的外部工具，模型可决定在适当时机调用它们。请求示例

{
  "model": "kimi-k2.6",
  "messages": [{"role": "user", "content": "北京今天天气怎么样？"}],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "获取指定城市的天气",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {"type": "string", "description": "城市名称"}
          },
          "required": ["city"]
        }
      }
    }
  ]
}

响应中的 tool_calls当 finish_reason 为 "tool_calls" 时，模型返回 tool_calls 数组，包含 id、function.name 和 function.arguments：

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "",
      "tool_calls": [{
        "id": "call_xxx",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"city\":\"北京\"}"
        }
      }]
    },
    "finish_reason": "tool_calls"
  }]
}

提交工具执行结果在本地执行工具后，将结果通过 role="tool" 消息追加到 messages 中（tool_call_id 必须与请求中的 id 对应）：

{"role": "tool", "tool_call_id": "call_xxx", "content": "晴，25°C"}

详见使用 Kimi API 完成工具调用。

思考模式与 Preserved Thinking

kimi-k3 始终进行推理，使用顶层 reasoning_effort（支持 "low"、"high"、"max"，默认 "max"）。kimi-k2.6 和 kimi-k2.7-code 支持思考模式，模型在输出最终答案前会先输出推理过程（reasoning_content）。K2.x 请求参数

字段	类型	说明
`thinking.type`	`"enabled"` \| `"disabled"`	思考开关（`kimi-k2.7-code` 始终为 `enabled`，不可关闭）
`thinking.keep`	`null` \| `"all"`	Preserved Thinking：是否将历史轮次的 `reasoning_content` 保留在上下文。`kimi-k2.6` 默认 `null`（不保留），可选 `"all"`；`kimi-k2.7-code` 固定为 `"all"`（保留），传入其他值报错

响应字段非流式响应中，choices[0].message 包含：

字段	说明
`content`	最终答案
`reasoning_content`	推理过程（仅在思考模式启用时返回）

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "1+1 等于 2。",
      "reasoning_content": "用户问的是基础数学问题，直接相加即可。"
    }
  }]
}

多轮对话中若使用思考模式，请务必将每一轮 assistant 消息的 reasoning_content 原样保留在 messages 中，否则模型可能丢失推理上下文。

详见配置思考模式。

流式输出 Streaming

设置 stream: true 可启用流式输出，模型会以 Server-Sent Events (SSE) 格式逐段返回生成的内容。推荐在聊天、代码生成、长文本输出等实时性要求高的场景中使用。

completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "请解释什么是递归。"}],
    stream=True
)

for chunk in completion:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

SSE 响应格式每一行以 data: 开头，内容为 JSON 对象。当 finish_reason 为 null 时，内容在 delta.content 中累加；当 finish_reason 不为 null 时，表示输出结束：

data: {"id":"cmpl-xxx","object":"chat.completion.chunk","created":1698999575,"model":"kimi-k2.6","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"cmpl-xxx","object":"chat.completion.chunk","created":1698999575,"model":"kimi-k2.6","choices":[{"index":0,"delta":{"content":"你好"},"finish_reason":null}]}

data: {"id":"cmpl-xxx","object":"chat.completion.chunk","created":1698999575,"model":"kimi-k2.6","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":19,"completion_tokens":13,"total_tokens":32,"cached_tokens":12,"prompt_tokens_details":{"cached_tokens":12,"cache_write_tokens":0}}}

data: [DONE]

stream_options通过 stream_options: {"include_usage": true} 可在最后一个 chunk（data: [DONE] 之前）额外获取 usage 字段，显示本次请求的 Token 消耗：

stream=True,
stream_options={"include_usage": True}

详见利用 Kimi API 的流式输出功能。

Partial Mode

Partial Mode（Prefill）允许你在 messages 的最后一条 assistant 消息中预填输出前缀，从而引导模型按照你期望的格式或方向继续生成。开启方式在 messages 数组末尾添加一条 role="assistant" 的消息，并设置 partial: true：

completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {"role": "user", "content": "用 Python 实现快速排序。"},
        {"role": "assistant", "content": "```python\n", "partial": True}
    ]
)

模型会从 ````python\n` 之后继续生成代码，而不是先输出解释文字再写代码。常见用途

强制模型以特定格式开头（如 JSON 的 {、代码块的 ````python`）
角色扮演中保持角色名称前缀（配合 name 字段）
在 finish_reason="length" 时，用相同的前缀续写被截断的内容

请勿将 Partial Mode 与 response_format={"type": "json_object"} 混用，否则可能获得预期外的模型回复。如需引导 JSON 输出，建议直接使用 Structured Output 或单独设置 partial: true 并预填 {。

详见使用 Kimi API 的 Partial Mode。

授权

Authorization

string

header

必填

Authorization 请求头需要一个 Bearer 令牌。使用 MOONSHOT_API_KEY 作为令牌。这是一个服务端密钥，请在 API 密钥页面生成。

请求头

X-Msh-Request-Nonce

string

客户端生成的随机 nonce（推荐使用 UUID v4），携带后即开启请求签名：Kimi API 会在响应头中返回 Msh-Request-Timestamp 与 Msh-Request-Signature，用于事后证明该请求确实由 Kimi API 处理。只允许一个非空的 Header 值；值不合法时请求照常执行，但不返回上述响应头。详见校验请求签名。

Minimum string length: 1

示例:

"7d929748-0ae6-41c2-ab5d-a186498ad721"

请求体

application/json

kimi-k3
kimi-k2.7-code
kimi-k2.6

model

enum<string>

默认值:kimi-k3

必填

模型 ID

可用选项:

kimi-k3

messages

(标准消息 · object | 动态工具消息 · object)[]

必填

Kimi K3 对话消息列表。除标准消息外，还可在任意对话位置插入 {"role": "system", "tools": [...]} 消息动态加载工具；该动态工具消息不包含 content 字段，并且只影响后续对话。

Kimi K3 对话消息。既支持标准消息，也支持不含 content、通过 tools 声明动态工具的 system 消息。

标准消息
动态工具消息

Show child attributes

logprobs

boolean

默认值:false

是否返回输出 Token 的对数概率。设置为 true 时，在响应 message 的 logprobs 字段中返回每个输出 Token 的对数概率信息

top_logprobs

integer

指定在每个 Token 位置返回概率最高的候选 Token 数量（0-20），各候选 Token 附带对数概率。使用此参数时必须将 logprobs 设置为 true

必填范围: 0 <= x <= 20

prediction

object

Predicted Output 配置。当模型响应的大部分内容可以提前预知时（例如重新生成仅有少量修改的文件），可显著降低响应延迟

Show child attributes

max_tokens

integer

已弃用

已弃用，请使用 max_completion_tokens

max_completion_tokens

integer

聊天补全生成的最大 Token 数量。默认值因模型而异：Kimi K3 默认为 131072，最大可设置为 1048576。如果结果达到最大 Token 数而未结束，finish reason 将为 "length"；否则为 "stop"。此值为期望返回的 Token 长度，而非输入加输出的总长度。如果输入加 max_completion_tokens 超出模型上下文窗口，将返回 invalid_request_error。

response_format

object

控制模型输出格式。默认值为 {"type": "text"}，即纯文本输出。设置为 {"type": "json_object"} 可启用 JSON 模式，确保输出为合法 JSON 对象（需在 prompt 中引导模型输出 JSON 并指定格式）。设置为 {"type": "json_schema"} 可启用 Structured Output，按指定的 JSON Schema 约束输出结构（推荐，需配合 json_schema 字段使用）。如果您在使用 JSON Schema 时遇到校验问题，欢迎到 walle GitHub Issues (https://github.com/MoonshotAI/walle/issues) 提交反馈。

Show child attributes

stop

停用词，完全匹配时将停止输出。匹配到的词本身不会被输出。最多允许 5 个字符串，每个不超过 32 字节

stream

boolean

默认值:false

是否以流式方式返回响应，默认 false

stream_options

object

流式响应选项

Show child attributes

tools

object[]

模型可调用的工具列表

Show child attributes

prompt_cache_key

string

用于缓存相似请求的响应以优化缓存命中率。对于 Coding Agent，通常是代表单个会话的 session id 或 task id；退出并恢复会话时应保持不变。对于 Kimi Code Plan，此字段为必填以提高缓存命中率。对于其他多轮对话 Agent，也建议使用此字段

prompt_cache_options

object

上下文缓存写入选项。不传时默认开启缓存写入（5m 档）：系统自动将请求前缀写入 5m 档缓存

Show child attributes

safety_identifier

string

用于检测可能违反使用政策的用户的稳定标识符。应为唯一标识每个用户的字符串。建议对用户名或邮箱进行哈希处理以避免发送可识别信息

tool_choice

控制模型是否调用工具。auto（默认）：模型自行决定是否调用工具；none：不调用工具；required：强制调用工具；也可传入特定函数对象强制调用指定工具。

可用选项:

auto,

none,

required

reasoning_effort

enum<string>

默认值:max

Kimi K3 始终启用思考，并开启 Preserved Thinking。推理强度支持 low、high 和 max，默认为 max。

可用选项:

low,

high,

max

响应

聊天补全响应

string

补全结果的唯一标识符

object

string

对象类型

示例:

"chat.completion"

created

integer

补全创建时的 Unix 时间戳

model

string

用于补全的模型

choices

object[]

补全选项列表

Show child attributes

usage

object

Show child attributes

创建聊天补全

curl --request POST \
  --url https://api.moonshot.cn/v1/chat/completions \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": "你好",
      "name": null,
      "partial": false
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "<string>",
        "parameters": {},
        "description": "<string>",
        "strict": true
      }
    }
  ]
}
'

import requests

url = "https://api.moonshot.cn/v1/chat/completions"

payload = {
    "model": "kimi-k3",
    "messages": [
        {
            "role": "user",
            "content": "你好",
            "name": None,
            "partial": False
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "<string>",
                "parameters": {},
                "description": "<string>",
                "strict": True
            }
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    model: 'kimi-k3',
    messages: [{role: 'user', content: '你好', name: null, partial: false}],
    tools: [
      {
        type: 'function',
        function: {name: '<string>', parameters: {}, description: '<string>', strict: true}
      }
    ]
  })
};

fetch('https://api.moonshot.cn/v1/chat/completions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.moonshot.cn/v1/chat/completions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'model' => 'kimi-k3',
    'messages' => [
        [
                'role' => 'user',
                'content' => '你好',
                'name' => null,
                'partial' => false
        ]
    ],
    'tools' => [
        [
                'type' => 'function',
                'function' => [
                                'name' => '<string>',
                                'parameters' => [
                                                                
                                ],
                                'description' => '<string>',
                                'strict' => true
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.moonshot.cn/v1/chat/completions"

	payload := strings.NewReader("{\n  \"model\": \"kimi-k3\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\",\n      \"name\": null,\n      \"partial\": false\n    }\n  ],\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"function\": {\n        \"name\": \"<string>\",\n        \"parameters\": {},\n        \"description\": \"<string>\",\n        \"strict\": true\n      }\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.moonshot.cn/v1/chat/completions")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"kimi-k3\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\",\n      \"name\": null,\n      \"partial\": false\n    }\n  ],\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"function\": {\n        \"name\": \"<string>\",\n        \"parameters\": {},\n        \"description\": \"<string>\",\n        \"strict\": true\n      }\n    }\n  ]\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.moonshot.cn/v1/chat/completions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"kimi-k3\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\",\n      \"name\": null,\n      \"partial\": false\n    }\n  ],\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"function\": {\n        \"name\": \"<string>\",\n        \"parameters\": {},\n        \"description\": \"<string>\",\n        \"strict\": true\n      }\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "object": "chat.completion",
  "created": 123,
  "model": "<string>",
  "choices": [
    {
      "index": 123,
      "message": {
        "role": "assistant",
        "content": "<string>",
        "tool_calls": [
          {
            "id": "<string>",
            "type": "function",
            "function": {
              "name": "<string>",
              "arguments": "<string>"
            }
          }
        ],
        "reasoning_content": "<string>"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 123,
    "completion_tokens": 123,
    "total_tokens": 123,
    "cached_tokens": 123,
    "prompt_tokens_details": {
      "cached_tokens": 123,
      "cache_write_tokens": 123
    }
  }
}

{
  "error": {
    "message": "<string>",
    "type": "<string>",
    "code": "<string>"
  }
}

{
  "error": {
    "message": "<string>",
    "type": "<string>",
    "code": "<string>"
  }
}

{
  "error": {
    "message": "<string>",
    "type": "<string>",
    "code": "<string>"
  }
}

使用 API

API Reference

工具接口

文件接口

批处理接口

托管智能体 Beta

参数说明

调用示例

非流式响应

流式响应

授权

请求头

请求体

响应

​参数说明

​调用示例

​非流式响应

​流式响应

授权

请求头

请求体

响应

参数说明

调用示例

非流式响应

流式响应