DEV Community

Cover image for Como Usar a API de Código Kimi K2.7
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Usar a API de Código Kimi K2.7

A API Kimi K2.7 Code expõe o modelo de um trilhão de parâmetros da Moonshot, ajustado para codificação, por meio de um endpoint compatível com OpenAI. Na prática: se seu código já chama a API da OpenAI, você só precisa trocar a URL base, definir o ID do modelo e enviar a mesma estrutura de messages. Também há um endpoint compatível com Anthropic para uso direto com Claude Code.

Experimente o Apidog hoje

Este guia mostra como acessar o modelo via API, quais URLs e IDs usar, como chamar com curl, Python e Node.js, como estimar custos e como testar tudo no Apidog antes de integrar em produção.

TL;DR

  • URL base OpenAI-compatible: https://api.moonshot.ai/v1
  • URL base Anthropic-compatible: https://api.moonshot.ai/anthropic
  • Modelo na API por token: kimi-k2.7-code
  • Modelo na assinatura Kimi Code: kimi-for-coding
  • Preço: US$ 0,95 por milhão de tokens de entrada, US$ 4,00 por milhão de tokens de saída e US$ 0,19 por milhão em acertos de cache.
  • Autenticação: crie uma chave no console da Kimi e envie no header Authorization.
  • Observação importante: o modelo sempre raciocina, então respostas incluem tokens de raciocínio cobrados como saída.

Kimi K2.7 Code

Duas formas de acessar o modelo

Escolha a opção conforme o seu caso de uso.

1. API de desenvolvedor com pagamento por token

Use esta opção para:

  • aplicações em produção;
  • scripts;
  • agentes;
  • automações;
  • backends;
  • integrações com SDKs compatíveis com OpenAI.

Configuração principal:

Base URL: https://api.moonshot.ai/v1
Model ID: kimi-k2.7-code
Enter fullscreen mode Exit fullscreen mode

2. Assinatura Kimi Code

A assinatura Kimi Code é um plano de taxa fixa vinculado ao CLI Kimi Code e ao console.

Nesse caso, o modelo usado é:

kimi-for-coding
Enter fullscreen mode Exit fullscreen mode

Essa opção é mais adequada para codificação interativa pesada, onde o custo por token pode crescer rápido.

Neste artigo, vamos focar na API por token, porque é a opção que você chama diretamente do seu próprio código.

Passo 1: crie uma chave de API

  1. Acesse o console da plataforma Kimi.
  2. Crie uma nova chave.
  3. Copie a chave no momento da criação.
  4. Salve em um gerenciador de segredos ou variável de ambiente.

No terminal:

export MOONSHOT_API_KEY="sk-your-key-here"
Enter fullscreen mode Exit fullscreen mode

Não faça commit dessa chave e não use em código client-side.

Passo 2: faça a primeira chamada com curl

O endpoint segue o formato de chat completions compatível com OpenAI.

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code",
    "messages": [
      {
        "role": "system",
        "content": "You are a careful senior engineer."
      },
      {
        "role": "user",
        "content": "Write a Python function that validates an email and returns a clear error message."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

A resposta segue o formato OpenAI-compatible, com:

  • choices: lista de respostas geradas;
  • choices[0].message.content: conteúdo principal;
  • usage: contagem de tokens de entrada, saída e raciocínio.

Exemplo de leitura útil da resposta:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 100,
    "completion_tokens": 300,
    "total_tokens": 400
  }
}
Enter fullscreen mode Exit fullscreen mode

Passo 3: use com Python

Como a API é compatível com OpenAI, você pode usar o SDK oficial openai mudando apenas a base_url.

Instale o SDK:

pip install openai
Enter fullscreen mode Exit fullscreen mode

Código:

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="kimi-k2.7-code",
    messages=[
        {
            "role": "user",
            "content": "Refactor this loop for readability and explain why."
        },
    ],
)

print(resp.choices[0].message.content)
print(resp.usage)
Enter fullscreen mode Exit fullscreen mode

Se você já tem uma abstração para OpenAI no seu backend, normalmente basta parametrizar:

base_url = "https://api.moonshot.ai/v1"
model = "kimi-k2.7-code"
Enter fullscreen mode Exit fullscreen mode

Passo 4: use com Node.js

Instale o SDK:

npm install openai
Enter fullscreen mode Exit fullscreen mode

Exemplo com ESM:

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "kimi-k2.7-code",
  messages: [
    {
      role: "user",
      content: "Write a Jest test for an empty-input edge case.",
    },
  ],
});

console.log(resp.choices[0].message.content);
console.log(resp.usage);
Enter fullscreen mode Exit fullscreen mode

Para produção, valide se a variável existe antes de iniciar a aplicação:

if (!process.env.MOONSHOT_API_KEY) {
  throw new Error("MOONSHOT_API_KEY is required");
}
Enter fullscreen mode Exit fullscreen mode

O que considerar ao implementar

O raciocínio está sempre ativado

O Kimi K2.7 Code força o raciocínio em todas as interações. Isso significa que cada resposta inclui tokens de raciocínio, cobrados como tokens de saída.

A vantagem em relação ao Kimi K2.6 é que o K2.7 Code raciocina cerca de 30% mais eficientemente, reduzindo o volume de tokens de raciocínio para tarefas equivalentes.

Chamadas de ferramentas seguem o padrão OpenAI

Você pode enviar um array tools com schemas de função. O modelo retorna chamadas de ferramenta, você executa a função no seu backend e envia o resultado de volta em uma nova mensagem.

Estrutura simplificada:

{
  "model": "kimi-k2.7-code",
  "messages": [
    {
      "role": "user",
      "content": "Search my orders and summarize delayed shipments."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "search_orders",
        "description": "Search orders by status",
        "parameters": {
          "type": "object",
          "properties": {
            "status": {
              "type": "string"
            }
          },
          "required": ["status"]
        }
      }
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

O modelo é multimodal

Você também pode enviar conteúdo de imagem no array messages, útil para casos como:

  • ler uma captura de tela de erro;
  • interpretar um diagrama;
  • revisar uma UI;
  • analisar uma imagem relacionada a uma tarefa de codificação.

Preços

Tabela de preços da API por token:

Tipo de token Preço por milhão
Entrada US$ 0,95
Saída, incluindo raciocínio US$ 4,00
Acerto de cache US$ 0,19

Para controlar custos:

  1. Reutilize prompts de sistema sempre que possível.
  2. Aproveite cache para contexto repetido.
  3. Monitore usage em cada resposta.
  4. Defina limites por requisição no seu backend.
  5. Registre custo estimado por usuário, projeto ou workflow.

Exemplo de logging simples em Node.js:

const usage = resp.usage;

console.log({
  promptTokens: usage.prompt_tokens,
  completionTokens: usage.completion_tokens,
  totalTokens: usage.total_tokens,
});
Enter fullscreen mode Exit fullscreen mode

Para mais estratégias, veja o guia sobre redução de custos de token de agente. Se quiser comparar com outros modelos, consulte também o guia da API Kimi K2.6 e o guia da API DeepSeek V4.

Use no Claude Code, Cline, RooCode ou Cursor

Você não precisa escrever um cliente próprio para usar o Kimi K2.7 Code no editor.

Claude Code

Configure o endpoint compatível com Anthropic:

export ANTHROPIC_BASE_URL="https://api.moonshot.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="$MOONSHOT_API_KEY"
export ANTHROPIC_MODEL="kimi-k2.7-code"
Enter fullscreen mode Exit fullscreen mode

Cline e RooCode

Configure assim:

  1. Selecione Moonshot como provedor.
  2. Use o endpoint api.moonshot.ai.
  3. Cole sua chave de API.
  4. Selecione kimi-k2.7-code como modelo.
  5. Desative a ferramenta do navegador se quiser uma execução mais estável.

Cursor

No Cursor, adicione um modelo usando endpoint customizado compatível com OpenAI:

Base URL: https://api.moonshot.ai/v1
Model: kimi-k2.7-code
Enter fullscreen mode Exit fullscreen mode

A configuração é semelhante ao guia Kimi no Cursor; apenas o ID do modelo muda.

Teste e depure a API no Apidog

Antes de conectar a API a um agente ou serviço em produção, valide o contrato da resposta. O Apidog permite enviar requisições, inspecionar JSON, salvar exemplos e criar testes.

Configuração da requisição

Crie uma requisição:

POST https://api.moonshot.ai/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Headers:

Authorization: Bearer {{MOONSHOT_API_KEY}}
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

Body:

{
  "model": "kimi-k2.7-code",
  "messages": [
    {
      "role": "system",
      "content": "You are a careful senior engineer."
    },
    {
      "role": "user",
      "content": "Write a short TypeScript function that validates a UUID."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Testes úteis

Crie assertions para garantir que:

  • o status HTTP é 200;
  • choices[0].message.content não está vazio;
  • usage.total_tokens existe;
  • usage.completion_tokens fica dentro do orçamento esperado.

Exemplos de validação:

pm.test("status is 200", function () {
  pm.response.to.have.status(200);
});

pm.test("assistant returned content", function () {
  const json = pm.response.json();
  pm.expect(json.choices[0].message.content).to.not.be.empty;
});

pm.test("token usage is within budget", function () {
  const json = pm.response.json();
  pm.expect(json.usage.completion_tokens).to.be.below(2000);
});
Enter fullscreen mode Exit fullscreen mode

Com isso, você transforma uma chamada manual em um teste de regressão para rodar novamente quando mudar prompt, modelo ou configuração.

Se você estiver testando chamadas de ferramenta via MCP, o manual de testes de servidor MCP mostra como validar contratos de ferramentas. Você também pode baixar o Apidog para configurar esse fluxo localmente.

FAQ

Qual é a URL base da API?

Para chamadas compatíveis com OpenAI:

https://api.moonshot.ai/v1
Enter fullscreen mode Exit fullscreen mode

Para Claude Code via endpoint compatível com Anthropic:

https://api.moonshot.ai/anthropic
Enter fullscreen mode Exit fullscreen mode

Qual ID de modelo devo usar?

Na API por token:

kimi-k2.7-code
Enter fullscreen mode Exit fullscreen mode

Na assinatura Kimi Code:

kimi-for-coding
Enter fullscreen mode Exit fullscreen mode

É compatível com OpenAI?

Sim. O formato de requisição e resposta segue o padrão de chat completions compatível com OpenAI. SDKs existentes podem funcionar com a troca da URL base.

Quanto custa?

  • US$ 0,95 por milhão de tokens de entrada;
  • US$ 4,00 por milhão de tokens de saída;
  • US$ 0,19 por milhão em acertos de cache.

Sempre pago por tokens de raciocínio?

Sim. O raciocínio é forçado, então cada resposta inclui tokens de raciocínio cobrados como tokens de saída. Ainda assim, o K2.7 Code usa cerca de 30% menos tokens de raciocínio do que o K2.6.

Posso enviar imagens?

Sim. O modelo é multimodal e aceita conteúdo de imagem no array messages.

Resumo

Para usar o Kimi K2.7 Code via API, configure seu cliente compatível com OpenAI com:

Base URL: https://api.moonshot.ai/v1
Model: kimi-k2.7-code
Enter fullscreen mode Exit fullscreen mode

Depois, envie requisições no formato de chat completions, monitore usage e valide os custos com base nos tokens de entrada, saída e cache. Para uso interativo, a assinatura Kimi Code com kimi-for-coding pode ser uma alternativa. Para produção, teste primeiro no Apidog, crie assertions para o contrato da resposta e só então conecte ao seu agente, CLI ou aplicação.

Top comments (0)