Como usar a API Kimi K3

TLDR Kimi K3 é o novo modelo carro-chefe da Moonshot AI, lançado em julho de 2026 para codificação de longo prazo, raciocínio profundo, compreensão multimodal e trabalho de conhecimento de ponta a ponta. A Moonshot o descreve como um modelo aberto de classe 3T com 2,8 trilhões de parâmetros, visão nativa e janela de contexto de 1 milhão de tokens.

Para desenvolvedores que querem acesso rápido sem gerenciar contas de provedores separadas, a CometAPI lista o Kimi K3 como ativo sob o ID de modelo kimi-k3, usando um endpoint compatível com OpenAI /v1/chat/completions e URL base https://api.cometapi.com/v1. A página ao vivo da CometAPI para o Kimi K3 lista preço de entrada de $2,40 por 1M tokens e preço de saída de $12,00 por 1M tokens, comparado às taxas oficiais da API do Kimi de $3,00 para entrada sem cache e $15,00 para saída. Como a demanda pelo Kimi K3 já causou limitação temporária de assinaturas na Moonshot, equipes de produção devem usar a CometAPI não apenas pela configuração fácil, mas também para comparação de modelos, monitoramento de uso e roteamento de fallback.

Principais pontos

• Em produção, preserve mensagens completas do assistente em fluxos de várias etapas, limite max_completion_tokens, rastreie o uso de tokens e crie rotas de fallback.
• Kimi K3 é um modelo Mixture-of-Experts de 2,8T parâmetros da Moonshot AI com janela de contexto de 1M tokens e compreensão visual nativa.
• O ID de modelo da CometAPI Kimi k3 é kimi-k3; o endpoint principal é POST https://api.cometapi.com/v1/chat/completions.
• K3 sempre raciocina. Use reasoning_effort com low, high ou max; max é o padrão na documentação do Kimi.
• Streaming é fortemente recomendado para tarefas longas de codificação, pesquisa e análise, pois os usuários podem ver saída parcial enquanto o modelo ainda está trabalhando.
• Entrada de visão deve usar arrays multimodais content. Os docs do Kimi afirmam que URLs públicas de imagem não são suportadas para rotas de visão do Kimi; use base64 ou referências de arquivos enviados.
• Kimi K3 suporta saída estruturada, modo JSON, chamadas de ferramentas, tool_choice, carregamento dinâmico de ferramentas e cache de contexto.

CometAPI é uma forma prática de avaliar o Kimi K3 ao lado de GPT, Claude, Gemini, DeepSeek, Qwen e outros modelos em uma única camada de API.

O que é Kimi K3: Modelo carro-chefe da Moonshot AI

A Moonshot AI lançou o Kimi K3 em 16 de julho de 2026 como seu modelo mais capaz até agora — uma arquitetura esparsa Mixture-of-Experts (MoE) com ~2,8 trilhões de parâmetros no total (16 de 896 experts ativos por token). Ele apresenta Kimi Delta Attention para até 6,3x de decodificação mais rápida em contextos de um milhão de tokens e Attention Residuals para ~25% de ganhos de eficiência de treinamento.

Especificações principais (fonte: relatórios oficiais e independentes):

Ele se destaca em codificação de longo horizonte, tarefas com agentes, compreensão visual e trabalho de conhecimento. Benchmarks independentes o colocam de forma competitiva (por exemplo, 57.1 no Artificial Analysis Intelligence Index, forte em arenas de codificação frontend).

Contexto de últimas notícias do Business Insider: A demanda aumentou tanto após o lançamento que a Moonshot pausou novas assinaturas temporariamente. Isso sinaliza o impulso da China em modelos de fronteira com pesos abertos, com a Moonshot visando um grande IPO.

Pesos completos agendados para 27 de julho de 2026

A documentação do Kimi K3 da Moonshot diz que os pesos completos do modelo serão lançados até 27 de julho de 2026. Até que esse lançamento seja concluído e as ferramentas de implantação de terceiros amadureçam, a maioria das equipes deve tratar o acesso via API hospedada como a rota prática mais rápida. Mesmo após os pesos estarem disponíveis, servir um modelo MoE de 2,8T parâmetros não é o mesmo que executar um pequeno modelo aberto em uma única estação de trabalho. O blog técnico da Moonshot recomenda configurações de supernó com 64 ou mais aceleradores para implantação do K3, o que significa que uma API hospedada continuará sendo a escolha padrão para muitas equipes de SaaS, agências, construtores de ferramentas internas e equipes de produtos de IA.

Desempenho em benchmarks: dados, fontes e análise

Kimi K3 entrega resultados de fronteira, especialmente em codificação e áreas com agentes, permanecendo competitivo no geral. Laboratórios independentes como a Artificial Analysis confirmam as alegações do fornecedor com algumas ressalvas (por exemplo, taxas de alucinação).

Inteligência geral

• Artificial Analysis Intelligence Index v4.1: 57.1 (4º no geral; atrás de Fable 5 ~60, GPT-5.6 Sol ~59; à frente de Claude Opus 4.8 ~55.7).
• GDPval-AA v2 Elo: 1.668 (grande salto em relação aos 1.190 do K2.6; supera o Opus 4.8, fica atrás do Fable 5).

Fonte: reddit

Benchmarks de código (Fornecedor + Independentes)

K3 se destaca aqui, liderando a Frontend Code Arena (1.679 Elo, #1 à frente de Fable 5 e Sol).

Fonte: Kimi

Índice de Codificação (Artificial Analysis): Forte ~76, competitivo com líderes.

K3 se destaca em trabalho em escala de repositório, frontend com iteração visual e agentes que usam ferramentas. Desenvolvedores relatam que ele está em nível "Opus 4.8+" para muitas tarefas de codificação.

O que é a API do Kimi K3?

Kimi K3 em termos simples para desenvolvedores

A API do Kimi K3 dá aos desenvolvedores acesso hospedado ao modelo K3 da Moonshot AI por meio de uma interface estilo chat-completions. Uma requisição típica envia uma lista de mensagens, seleciona model: "kimi-k3" e recebe uma resposta do assistente. Além do formato básico de chat, K3 adiciona recursos que importam em produção: esforço de pensamento configurável, contexto longo, entrada visual, streaming, saída JSON e restrita por esquema, chamadas de ferramentas e cache de contexto.

Kimi K3 não deve ser entendido como um “chatbot geral barato”. Sua proposta de valor mais forte é trabalho pesado. Se seu produto precisa alimentar um modelo com um grande repositório, um pacote de documentos longo, uma exportação de planilha densa, múltiplas capturas de tela, um transcript de depuração ou um plano complexo de ferramentas, K3 foi projetado para esse tipo de sessão. Se seu app só precisa de respostas curtas de FAQ ou classificação sobre entradas pequenas, um modelo menor pode ser mais econômico.

Novos recursos e uso da API do K3

Kimi K3 se baseia em modelos Kimi anteriores com aprimoramentos de nível de fronteira:

• Contexto de 1M: Processa repositórios inteiros, livros ou conversas longas sem truncamento.
• Visão nativa: Analisa imagens diretamente nas mensagens (base64 ou URLs).
• Raciocínio sempre ativo: Esforço máximo por padrão; suporta rastros de pensamento estruturados (streaming expõe deltas).
• Chamadas de ferramentas e agentes: Chamadas de função no estilo OpenAI para fluxos de trabalho complexos.
• Saída estruturada: Modo JSON para parsing confiável.
• Cache: Cache automático de prefixo reduz custos em contextos repetidos (relatados >90% em codificação).

Principais capacidades da API Kimi K3 na CometAPI

Contexto de 1M tokens para documentos longos e grandes bases de código

A CometAPI lista o Kimi K3 com uma janela de contexto de 1,000k tokens. Esse tamanho muda como os desenvolvedores podem desenhar fluxos. Em vez de dividir cada documento em muitos blocos, você pode testar fluxos que mantêm um contexto muito maior em uma única requisição: documentos de arquitetura mais trechos de código, requisitos de produto mais relatórios de bugs, artigos de pesquisa mais notas, ou históricos longos de suporte ao cliente.

Isso não significa que toda requisição deve usar o contexto completo. Contextos longos são caros e podem reduzir a latência do primeiro token. Use quando o modelo precisa de visibilidade global, não como substituto de um bom design de recuperação. Um padrão forte em produção na CometAPI é roteamento híbrido: use embeddings ou busca para recuperar os trechos mais relevantes, mas mantenha o K3 disponível para as tarefas raras em que um contexto amplo melhora genuinamente a qualidade da resposta.

Raciocínio sempre ativo com reasoning_effort configurável

A documentação do Kimi diz que o K3 sempre raciocina e suporta o campo de nível superior reasoning_effort com low, high e max. Use esforço menor para tarefas leves em que latência e custo importam; use alto ou máximo para tarefas como depuração, derivações matemáticas, revisão de arquitetura, migração de código, síntese de documentos longos e planejamento multi-ferramentas.

Na CometAPI, passe reasoning_effort na requisição de Chat Completions quando a rota do Kimi K3 suportar parâmetros específicos do provedor. Se sua versão do SDK rejeitar o campo de nível superior, envie via extra_body ou use HTTPS bruto.

Respostas em streaming para melhor experiência do usuário

Os docs de streaming do Kimi explicam que streaming envia tokens via Server-Sent Events em vez de esperar a resposta completa. Isso é especialmente útil para o K3 porque raciocínio profundo e saídas longas podem demorar mais do que tarefas pequenas de chat. Em uma ferramenta para desenvolvedores, faça stream de um plano primeiro, depois o código. Em um assistente de pesquisa, faça stream de resumos de seções. Em um app interno de analytics, faça stream de observações preliminares enquanto a resposta estruturada final ainda está sendo gerada.

Entrada de visão para capturas de tela, gráficos e vídeos

Kimi K3 suporta compreensão visual. Os docs de visão do Kimi afirmam que o K3 entende conteúdo de imagem e vídeo, e que mensagens de visão devem usar arrays content com partes image_url ou video_url. Os mesmos docs dizem que imagens em formato URL não são suportadas; use URLs de dados base64 ou referências a arquivos enviados. Para usuários da CometAPI, comece com entrada de imagem base64 em staging porque é simples, portátil e fácil de registrar com segurança sem depender de um host público de imagem.

Saída estruturada, modo JSON e chamadas de ferramentas

Kimi K3 suporta saída estruturada via response_format, além de chamadas de ferramentas por declarações de função em JSON Schema. Os recursos mais novos da API do K3 incluem tool_choice e carregamento dinâmico de ferramentas. Isso é importante para produtos de agentes porque o inventário de ferramentas pode se tornar enorme. Em vez de enviar todas as definições de ferramentas em cada requisição, seu app pode primeiro expor uma pequena função search_tools, recuperar apenas as ferramentas relevantes e inserir dinamicamente essas definições de ferramentas na conversa.

A decisão prática é simples: não escolha apenas pela tabela de benchmarks. Use a CometAPI para construir um conjunto de avaliação repetível a partir de seus próprios prompts. Inclua pelo menos 20 a 50 tarefas reais: correções de bugs, trabalhos de extração, capturas de tela, PDFs, perguntas de clientes, rastros de chamadas de ferramentas e requisições sensíveis a custo. Direcione o Kimi K3 para os trabalhos em que seu contexto longo, raciocínio e suporte a visão se pagam.

Preços da API: quanto custa o Kimi K3

Preços do Kimi K3 na CometAPI

A página do modelo Kimi K3 na CometAPI lista:

A mesma página compara esses números com os preços oficiais de $3.00 para entrada e $15.00 para saída por 1M tokens, mostrando um desconto de 20% na listagem ao vivo da CometAPI. Os preços podem mudar, então verifique a página de modelo ao vivo da CometAPI antes de publicar textos de preços de alto tráfego ou comprometer orçamento de produção.

Preços oficiais da API Kimi

O blog técnico da Moonshot lista os preços da API do Kimi em $0.30 por 1M tokens de entrada com cache-hit, $3.00 por 1M tokens de entrada com cache-miss e $15.00 por 1M tokens de saída. Também diz que a API oficial do Kimi alcança taxa de cache hit acima de 90% em workloads de codificação. Trate esse número de 90% como uma alegação específica do workload pelo provedor, não uma garantia para todo aplicativo. Sua taxa de cache hit depende de quão estáveis são seus prompts, definições de ferramentas, prefixos de repositório e históricos de sessão.

Exemplos simples de custo na CometAPI

Fórmula: (input_tokens / 1,000,000 * 2.40) + (output_tokens / 1,000,000 * 12.00).

Duas notas importam. Primeiro, tokens de raciocínio tipicamente são cobrados como tokens de saída quando gerados por modelos de raciocínio, então defina max_completion_tokens com cuidado. Segundo, contexto longo deve ser intencional. É poderoso enviar 500,000 tokens, mas raramente é sábio enviar tanto contexto quando 20,000 tokens de alto sinal produziriam a mesma resposta.

Como usar a API do Kimi K3 na CometAPI

Passo 1: Crie uma chave da CometAPI

Crie ou acesse sua conta na CometAPI, abra a página de chaves de API e crie uma chave. Armazene-a como variável de ambiente no servidor chamada COMETAPI_KEY. Não coloque chaves de produção em JavaScript de navegador, apps móveis, repositórios públicos, capturas de tela ou logs no cliente.

PowerShell:

$env:COMETAPI_KEY = "your_cometapi_key_here"

macOS ou Linux:

export COMETAPI_KEY="your_cometapi_key_here"

Passo 2: Instale o SDK da OpenAI

A CometAPI suporta SDKs compatíveis com OpenAI. Em Python, instale o SDK uma vez:

python -m pip install --upgrade openai

Passo 3: Faça sua primeira chamada à API do Kimi K3

Use a URL base da CometAPI e o ID de modelo kimi-k3:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "You are a precise technical assistant for API developers.",
        },
        {
            "role": "user",
            "content": "Explain when I should use Kimi K3 for a coding agent.",
        },
    ],
    max_completion_tokens=1200,
)

print(completion.choices[0].message.content)
print(completion.usage)

A requisição cURL equivalente:

curl https://api.cometapi.com/v1/chat/completions \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "system", "content": "You are a precise technical assistant for API developers."},
      {"role": "user", "content": "Explain Kimi K3 in one paragraph."}
    ],
    "max_completion_tokens": 800
  }'

Novos recursos e uso da API do K3

Esforço de raciocínio

Use reasoning_effort para controlar quanto orçamento de raciocínio o K3 aplica. Os docs do Kimi listam low, high e max, com max como padrão. Em produção, escolha com base no tipo de tarefa:

Exemplo em Python:

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="high",
    messages=[
        {
            "role": "user",
            "content": (
                "Review this migration plan for hidden risks. "
                "Return the top 5 issues and a safer rollout sequence."
            ),
        }
    ],
    max_completion_tokens=2000,
)

message = completion.choices[0].message
print(message.content)

Se sua versão do SDK da OpenAI não aceitar reasoning_effort como argumento nomeado, passe via extra_body:

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Solve this scheduling problem."}],
    extra_body={"reasoning_effort": "high"},
)

Detalhe importante de implementação: os docs de pensamento do Kimi dizem que conversas multi-turn com K3 devem preservar a mensagem completa do assistente retornada pela API, incluindo campos como reasoning_content e tool_calls. Se você armazenar apenas o content visível, pode degradar a continuidade do raciocínio em sessões longas.

Respostas em streaming

Use streaming quando a resposta pode ser longa, quando latência importa ou quando você quer mostrar progresso em uma UI de chat.

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Create a detailed refactor plan for a 200k-line monolith.",
        }
    ],
    stream=True,
    stream_options={"include_usage": True},
    max_completion_tokens=3000,
)

for chunk in stream:
    choice = chunk.choices[0]
    delta = choice.delta

    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        # In most products, store reasoning securely or hide it from end users.
        pass

    if delta.content:
        print(delta.content, end="", flush=True)

    usage = getattr(choice, "usage", None)
    if usage:
        print("\n\nUsage:", usage)

Os docs de streaming do Kimi enfatizam que fluxos SSE terminam com data: [DONE]. Em um cliente SSE bruto, não trate o fluxo como completo até que esse marcador chegue.

Entrada de visão

Kimi K3 pode analisar imagens e vídeos. O primeiro teste mais seguro na CometAPI é uma requisição de imagem base64. Use um array content multimodal, não uma string JSON contendo um array.

import base64
import mimetypes
from pathlib import Path

image_path = Path("dashboard-screenshot.png")
mime_type = mimetypes.guess_type(image_path.name)[0] or "image/png"
image_b64 = base64.b64encode(image_path.read_bytes()).decode("utf-8")

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:{mime_type};base64,{image_b64}",
                    },
                },
                {
                    "type": "text",
                    "text": (
                        "Review this dashboard screenshot. "
                        "Identify UX issues, missing states, and data-quality risks."
                    ),
                },
            ],
        }
    ],
    max_completion_tokens=1800,
)

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

Os docs de visão do Kimi listam formatos de imagem suportados como PNG, JPEG, WebP e GIF, e formatos de vídeo suportados como MP4, MOV, AVI, WebM e outros. Eles também recomendam manter a resolução de imagem em até 4K e a resolução de vídeo em até FHD porque resoluções mais altas podem consumir mais tempo de processamento sem melhorar a compreensão do modelo.

Saída estruturada com JSON Schema

Para pipelines de produção, não faça parsing de prosa livre se a próxima etapa espera dados estruturados. Use response_format com JSON Schema quando suportado pela rota.

import json

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": (
                "Extract implementation tasks from this request: "
                "Add SSO, migrate billing webhooks, and create admin audit logs."
            ),
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "implementation_tasks",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "tasks": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "title": {"type": "string"},
                                "risk": {"type": "string"},
                                "owner": {"type": "string"},
                            },
                            "required": ["title", "risk", "owner"],
                            "additionalProperties": False,
                        },
                    }
                },
                "required": ["tasks"],
                "additionalProperties": False,
            },
        },
    },
)

data = json.loads(completion.choices[0].message.content)
print(data["tasks"])

Chamadas de ferramentas e tool_choice

Os docs de melhores práticas de chamadas de ferramentas do K3 recomendam evitar inventários enormes de ferramentas em uma única requisição. O padrão é: exponha primeiro uma função de busca de ferramentas, force a recuperação com tool_choice: "required" na primeira etapa, depois carregue dinamicamente apenas as ferramentas que o modelo precisa.

Exemplo mínimo estilo clima:

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Look up a customer's order status.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    }
]

messages = [
    {"role": "user", "content": "Where is order A1024?"},
]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="required",
)

assistant_message = first.choices[0].message
messages.append(assistant_message.model_dump(exclude_none=True))

for call in assistant_message.tool_calls or []:
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "Shipped", "eta": "2026-07-24"}
    messages.append(
        {
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        }
    )

final = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
)

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

Melhores práticas do Kimi K3 para equipes de produção

Use o Kimi K3 onde seus pontos fortes são óbvios

Kimi K3 é um forte candidato para análise de repositórios, codificação de frontend, reprodução de bugs, síntese de documentos longos, raciocínio em planilhas, QA assistido por visão e fluxos de trabalho com agentes que precisam de ferramentas. Ele pode ser mais do que você precisa para geração de textos curtos, classificação simples ou macros de suporte de baixo risco. Na CometAPI, crie regras de roteamento de modelos para que o K3 receba o trabalho difícil enquanto modelos de menor custo lidam com o tráfego rotineiro.

Construa fallbacks porque o lançamento tem capacidade limitada

O relato da AP sobre a Moonshot pausando novas assinaturas é um lembrete de que disponibilidade faz parte da seleção do modelo. Construa fallbacks no nível do aplicativo. Se o Kimi K3 retornar um erro de capacidade do provedor, faça roteamento para outro modelo da CometAPI com forças semelhantes, reduza o tamanho do contexto ou tente novamente com backoff. Mantenha a experiência do usuário elegante: mostre progresso, preserve rascunhos e torne falhas recuperáveis.

Preserve o contexto cuidadosamente em sessões de várias etapas

Kimi K3 foi treinado com histórico de pensamento preservado. O blog técnico da Moonshot alerta que mudar para o K3 no meio da sessão ou não passar a mensagem histórica completa do assistente pode reduzir a estabilidade. Na prática, armazene o objeto completo da mensagem do assistente retornada pela API para ferramentas de desenvolvedor e agentes. Não comprima tool_calls ou campos de raciocínio específicos do provedor, a menos que você tenha testado o impacto.

Controle o custo de saída e raciocínio

Sempre defina max_completion_tokens. A referência da API do Kimi diz que o K3 tem padrão de 131,072 tokens máximos de conclusão e pode ser definido até 1,048,576, sujeito ao limite de contexto do modelo. Isso é poderoso, mas pode surpreender um painel de cobrança se seu prompt convidar uma resposta enorme. Para a maioria dos fluxos de produto, defina limites separados: 800 a 1.500 tokens para resumos, 2.000 a 4.000 para análise detalhada, e limites maiores apenas para geração de longa forma explícita.

Projete para cache

O cache de contexto do Kimi funciona melhor quando o contexto inicial repetido permanece estável. Os docs atuais de cache de contexto do Kimi descrevem como automático: não é necessário criar cache manualmente, ID de cache ou gerenciamento de TTL. Para agentes de codificação, mantenha instruções de repositório, definições de ferramentas e políticas de projeto em um prefixo consistente. Para QA de documentos, mantenha o pacote de documentos estável em perguntas relacionadas. Evite reescrever o prompt do system a cada etapa e coloque contextos grandes fixos perto do início do array messages para que o cache reconheça prefixos repetidos.

Use visão de forma deliberada

Entrada de visão é valiosa, mas imagens e vídeos consomem tokens com base no conteúdo e na resolução. Use imagens quando elas adicionam informações que o texto não captura: layout de UI, gráficos, anotações manuscritas, mocks de design, capturas de CAD e telas de erro. Reduza a escala de imagens grandes demais, recorte espaços em branco irrelevantes e combine a imagem com uma pergunta precisa.

Conclusão e Recomendações

Kimi K3 na CometAPI oferece capacidades de fronteira — contexto massivo, visão e raciocínio — a preços acessíveis com mínima fricção de integração. Seja construindo agentes de codificação, apps multimodais ou serviços de IA escaláveis, comece com a CometAPI para acesso unificado, economia e confiabilidade. Cadastre-se, experimente os quickstarts acima e escale com confiança.