Blog

Como Usar a API Kimi K2.6: Tutorial Completo

Ashley Innocent

Ashley Innocent

21 abril 2026

Como Usar a API Kimi K2.6: Tutorial Completo

Apidog para empresas

Implantação local

SSO & RBAC

Conforme SOC 2

Explorar Apidog Enterprise

O anúncio do Kimi K2.6 da Moonshot AI o posiciona como o novo estado da arte de código aberto para codificação, execução de longo prazo e enxames de agentes. A API que o alimenta é compatível com OpenAI, hospedada em https://api.moonshot.ai/v1, e documentada na plataforma. Se você tiver o SDK do OpenAI instalado, poderá enviar requisições reais em cerca de cinco minutos.

Este guia aborda autenticação, sua primeira requisição, streaming, chamada de ferramentas, entrada de visão e vídeo, modo de pensamento e como operar um Enxame de Agentes (Agent Swarm) com 300 sub-agentes, além de mostrar como testar cada endpoint com o Apidog antes de escrever o código de integração.

💡
Caminho rápido: Teste a API Kimi K2.6 visualmente no Apidog antes de aplicar qualquer código de integração. Uma importação, um token Bearer, e você estará fazendo requisições reais em streaming com histórico completo e validação de esquema. Baixe o Apidog gratuitamente.
button

TL;DR: API Kimi K2.6 em 60 segundos

Curl mínimo:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'

É isso. O restante deste guia detalha, incluindo o Agent Swarm e o limite de execução de 4.000 passos que a Moonshot menciona.

O que você realmente pode fazer com esta API

A partir do anúncio do Kimi K2.6, a API libera tudo isso em produção:

Se você está construindo ferramentas na mesma categoria que uso de computador Claude Code, construa seu próprio Claude Code, ou Cursor Composer 2, a API K2.6 é uma substituição direta na camada do modelo.

Passo 1: Obtenha uma chave de API

  1. Vá para platform.moonshot.ai (ou platform.kimi.ai) e inscreva-se. E-mail ou Google OAuth funcionam.
  2. Verifique sua conta. Usuários internacionais podem precisar de verificação por SMS.
  3. Adicione informações de cobrança. A Moonshot geralmente credita novas contas com um pequeno saldo gratuito.
  4. Abra API Keys no painel e clique em Create Key.
  5. Copie a chave imediatamente (ela é mostrada apenas uma vez).
  6. Exporte-a:
export KIMI_API_KEY="sk-..."

Adicione-a a .zshrc, .bashrc, ou a um gerenciador de segredos para produção. Nunca a comite.

Quer evitar pagar durante o desenvolvimento? Como usar o Kimi K2.6 gratuitamente abrange Cloudflare Workers AI, pesos auto-hospedados e programas de crédito gratuitos.

Passo 2: Escolha seu SDK

A API é compatível com OpenAI, então os SDKs oficiais do OpenAI funcionam após você alterar a URL base.

Opção Instalação Melhor para
curl embutido Testes rápidos, CI
OpenAI Python pip install openai Serviços Python
OpenAI Node npm install openai Aplicativos JS/TS

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

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

Node.js

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

curl

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'

Todos os três retornam o mesmo formato de resposta.

Passo 3: Entenda o corpo da requisição

Os mesmos campos das completações de chat do OpenAI:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}

Duas observações específicas da Moonshot:

Passo 4: Streaming

Streaming é o padrão certo para qualquer UI ou geração longa. A saída máxima para tarefas de raciocínio pode atingir 98.304 tokens; você não vai querer esperar por tudo isso de uma vez.

Python

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

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

Node.js

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}

O streaming também funciona com chamadas de ferramentas; os argumentos chegam como deltas JSON que você concatena.

Passo 5: Chamada de Ferramentas

A Moonshot relata uma pontuação Toolathlon de 50,0% e 96,60% de sucesso na invocação de ferramentas em testes com parceiros. O formato é o esquema padrão de chamada de função do OpenAI, então os fluxos de trabalho de teste de API existentes para engenheiros de QA se aplicam.

Definir ferramentas

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

Primeira chamada (modelo decide)

import json

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })

Segunda chamada (resposta final)

final = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)

O K2.6 é forte em cadeias de ferramentas multi-passos, o que torna viáveis agentes de codificação de longa duração como o Kimi Code. Para uma comparação de frameworks, fluxos de trabalho do Claude Code abordam o mesmo loop com um backend diferente.

Passo 6: Entrada de Visão

O K2.6 pontua 79,4% no MMMU-Pro e 96,9% no V* (com Python). As imagens são inseridas na mensagem do usuário usando o formato de conteúdo image_url do OpenAI:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)

Para arquivos locais, codifique-os em base64:

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/jpeg;base64,{b64}"

Para OCR ou leitura de diagramas, combine uma instrução de texto clara com a imagem. Para problemas de matemática, inclua uma ferramenta de interpretador Python; a pontuação MathVision de 93,2% foi medida com acesso Python habilitado.

Passo 7: Entrada de Vídeo

Passe uma URL de vídeo ou sequência de quadros:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)

Clipes curtos (<30s) funcionam em uma única chamada. Vídeos mais longos se beneficiam do streaming porque a inferência quadro a quadro produz muitos tokens.

Passo 8: Modo de Pensamento

kimi-k2.6-thinking produz um rastro de raciocínio visível (semelhante aos modelos estilo o1 do OpenAI). A Moonshot relata 96,4% no AIME 2026 e 90,5% no GPQA-Diamond com o pensamento habilitado.

Pensamento ligado (padrão para o modelo de pensamento):

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)

Pensamento desligado:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)

O rastro de raciocínio retorna em um campo reasoning na resposta. Você pode ocultá-lo dos usuários finais e mostrar apenas a resposta final, ou canalizá-lo para um log de depuração.

Passo 9: Enxame de Agentes

Enxame de Agentes (Agent Swarm) é o recurso que mais vale a pena aprender. Do blog Kimi K2.6: até 300 sub-agentes, mais de 4.000 passos coordenados, 3x a capacidade do K2.5.

Invoque-o através do parâmetro de agente da plataforma:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)

Chamadas de enxame podem levar minutos ou horas. Três dicas práticas:

  1. Use streaming. Você vai querer ver o progresso e encerrar execuções ruins cedo.
  2. Limite max_agents. 300 é o teto; 10 a 30 é mais previsível para a maioria das tarefas.
  3. Defina um orçamento. Tarefas de enxame longas podem consumir tokens rapidamente; registre o usage em cada resposta e canalize-o para suas métricas.

O blog do Kimi descreve execuções de demonstração que modificaram mais de 4.000 linhas de código em 13 horas. A arquitetura é o que as torna possíveis; o flag da API apenas as ativa.

Passo 10: Teste tudo com Apidog

Cada seção acima introduz um formato de corpo, requisito de cabeçalho ou formato de resposta diferente. O Apidog transforma o ciclo de depuração em um fluxo de trabalho visual.

Configuração do Kimi K2.6 no Apidog

  1. Baixe o Apidog e crie um projeto.
  2. Crie um ambiente kimi-prod com duas variáveis: BASE_URL = https://api.moonshot.ai/v1 e KIMI_API_KEY = sk-....
  3. Nova requisição de API: POST {{BASE_URL}}/chat/completions.
  4. Cabeçalhos: Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json.
  5. Corpo (exemplo de streaming):
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
  1. Clique em Send. Os tokens são transmitidos para o painel de resposta em tempo real.

O que o Apidog adiciona

Para testes no editor, o Apidog também é fornecido como uma extensão do VS Code. Se você está atualmente preso ao Postman, como fazer teste de API sem o Postman explica a mudança.

Tratamento de erros que não vai te dar dor de cabeça

A Moonshot usa códigos de status HTTP padrão:

Wrapper de retentativa:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")

Para desconexões no meio do stream, rastreie os tokens recebidos e reinicie com uma instrução de "continuar daqui" se a conexão cair. O teto de 98.304 tokens de saída de raciocínio significa que streams longos são normais, não um erro.

Controle de custos

A Moonshot publica os preços em kimi.com/membership/pricing. Três dicas de nível de produção para manter as contas previsíveis:

Padrão de produção: um resolvedor de issues do GitHub

Aqui está um agente que lê uma issue do GitHub, localiza o código relevante, propõe uma correção e executa testes, estruturado em torno do loop de chamada de ferramentas do Kimi K2.6:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

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

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })

Isso escala para o Enxame de Agentes (Agent Swarm) adicionando a configuração de enxame extra_body. Também funciona bem com a pilha multi-agente Hermes se você quiser checkpoints com intervenção humana.

FAQ

Resumo

A API Kimi K2.6 se encaixa em qualquer conjunto de ferramentas compatível com OpenAI com duas alterações: a URL base e sua chave de API. A partir daí, você obtém uma janela de contexto de 262K, Enxame de Agentes (Agent Swarm) com 300 sub-agentes, chamada de ferramentas ajustada para 96,60% de sucesso na invocação, e os pesos de código aberto como um fallback caso você queira sair da API hospedada.

Se você está construindo uma nova integração, use o Apidog para construir e verificar cada endpoint primeiro. Você pegará erros de esquema, bugs de streaming e problemas de autenticação antes que eles cheguem à sua base de código. Em seguida, porte as requisições funcionando para o seu serviço Python ou Node com confiança.

Referências e leitura adicional

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar