Preços da API Kimi K3 (2026): Quanto custa e comparação de código com K2.7

TL;DR

Kimi K3 custa $0.30 por 1M de tokens de entrada com acerto de cache, $3.00 por 1M de tokens de entrada com falha de cache e $15.00 por 1M de tokens de saída, com uma janela de contexto de 1,048,576 tokens.

Comparado ao K2.7 Code, o K3 é significativamente mais caro por token, mas oferece 4× a janela de contexto, além de visão nativa e suporte mais robusto para workloads agentivos de longo horizonte.

Em resumo: K2.7 Code continua sendo a opção mais econômica para tarefas rotineiras de codificação dentro de 256K de contexto. Use o K3 quando precisar de contextos maiores, capacidades multimodais ou como rota de escalonamento para tarefas que o K2.7 não consegue concluir com confiabilidade.

Preços da API Kimi K3: visão geral

Consulte o Kimi K3 quickstart da Moonshot para parâmetros de API atuais e detalhes de integração.

O que o Kimi K3 adiciona em relação ao K2.7 Code

O upgrade mais evidente é o comprimento do contexto.

K2.7 Code suporta 262,144 tokens, enquanto o K3 aumenta esse limite para 1,048,576 tokens. Isso torna o K3 mais prático para grandes repositórios, históricos longos de agentes, documentação extensa e fluxos de trabalho que, de outra forma, exigiriam redução de contexto.

K3 também oferece suporte a:

• compreensão visual nativa
• saída estruturada estrita
• tool_choice
• carregamento dinâmico de ferramentas
• cache de contexto automático
• fluxos longos de trabalho de codificação e conhecimento

O Kimi K3 technical blog da Moonshot reporta 88.3 no Terminal-Bench 2.1, 77.8 no Program Bench e 81.2 no FrontierSWE.

São benchmarks reportados pelo provedor e devem ser tratados como motivos para avaliar o K3 — não como garantias de que ele superará o K2.7 Code em todas as cargas de trabalho de produção.

Para contexto sobre a geração anterior, veja o Kimi K2 API guide da CometAPI.

Preços: Kimi K3 vs Kimi K2.7 Code

As tarifas do K2.7 vêm da documentação oficial de preços do Kimi K2.7 Code da Moonshot.

Comparado ao K2.7 Code padrão, o K3 é:

• 1,58× o preço para entrada com acerto de cache
• 3,16× o preço para entrada com falha de cache
• 3,75× o preço para saída

O ágio do K3 é menor em relação ao K2.7 Code HighSpeed, mas os dois modelos priorizam aspectos diferentes: o HighSpeed foca em saída de código mais rápida, enquanto o K3 visa workloads mais exigentes de longo contexto e agentivos.

A documentação atual de preços da Batch API da Moonshot não lista o K3, portanto, não presuma que os descontos do Batch disponíveis para outros modelos Kimi também se aplicam aqui.

Cache de contexto do Kimi K3: como funciona o desconto de 90% na entrada

O K3 oferece cache de contexto automático.

Os desenvolvedores não precisam criar manualmente um ID de cache ou TTL. Manter prefixos grandes estáveis entre requisições seguidas dá às requisições subsequentes a chance de receber a tarifa de acerto de cache.

A diferença de preço é:

• Falha de cache: $3.00 / 1M tokens de entrada
• Acerto de cache: $0.30 / 1M tokens de entrada

Portanto, tokens de entrada com acerto de cache custam 90% menos do que tokens de entrada com falha de cache.

No entanto, a saída permanece com preço de $15 por milhão de tokens, então o custo total por requisição não cai 90%.

Por exemplo, suponha:

• 600,000 tokens de entrada
• 20,000 tokens de saída

Neste caso simplificado, o custo total cai cerca de 77%.

A economia real depende da parcela de tokens de entrada que recebe a tarifa de acerto de cache.

Exemplo: quanto custa uma tarefa de codificação no K3 vs K2.7

Suponha que uma tarefa de codificação use:

• 200,000 tokens de entrada
• 20,000 tokens de saída

Para essa carga, o K3 custa cerca de 3,33× o K2.7 Code padrão em uma requisição fria.

Dentro do próprio K3, passar de entrada inteiramente com falha de cache para totalmente em cache reduz o custo estimado da requisição de $0.90 para $0.36, uma redução de 60% neste exemplo.

Mas o custo por requisição é apenas parte da equação.

Custo por tarefa bem-sucedida = Gastos totais do fluxo de trabalho ÷ Tarefas que passam nas verificações de aceitação

Uma comparação de produção também deve incluir novas tentativas, chamadas de fallback, execuções de ferramentas e tempo de revisão humana.

Uma requisição ao K3 que acerta de primeira pode ser mais econômica do que várias tentativas mais baratas que falham.

Um caso-limite do mundo real: custo de tokens de raciocínio

O K3 sempre usa raciocínio, então o consumo de tokens de saída pode se tornar uma parte relevante da fatura.

Em um teste no dia de lançamento por Simon Willison, um prompt pedindo ao K3 para gerar um SVG consumiu 13,241 tokens de raciocínio antes de produzir 3,417 tokens de resposta, por um custo total de aproximadamente $0.25.

Foi um teste informal de prompt único, não um benchmark, mas destaca um ponto importante de custo: a resposta final visível pode representar apenas parte da saída faturada.

Como o K3 atualmente oferece apenas esforço de raciocínio máximo, as equipes devem medir o uso real de tokens de saída em suas próprias cargas.

Um padrão melhor: K2.7 primeiro, K3 por escalonamento

Para cargas de trabalho de codificação mistas, o roteamento pode ser mais econômico do que enviar todas as requisições diretamente ao K3.

Uma estratégia simples é:

Start with K2.7 Code
        ↓
Task exceeds 256K context?
        → Yes: use K3
        ↓ No
Run task and validation
        ↓
Validation failed?
        → Yes: escalate to K3
        ↓ No
Return result

Usando o exemplo anterior:

• K2.7 Code custa $0.27 por tentativa fria
• K3 custa $0.90
• K2.7 conclui com sucesso 70% das tarefas
• 30% são tentadas novamente uma vez no K3

O custo médio torna-se:

$0.27 + (30% × $0.90) = $0.54 per task

Enviar todas as tarefas diretamente ao K3 custaria $0.90 por tarefa sob as mesmas suposições de tokens.

Isso torna a estratégia roteada 40% mais barata neste cenário simplificado.

As economias exatas variam, mas o princípio é útil: roteie o trabalho rotineiro para o modelo mais barato e escale quando a capacidade adicional for realmente necessária.

Quando o Kimi K3 vale o upgrade?

K3 é mais convincente quando:

• O contexto necessário excede o limite de 262,144 tokens do K2.7 Code.
• A tarefa combina código com entrada visual.
• Um agente de longa duração precisa trabalhar em grandes repositórios e ferramentas externas.
• O K2.7 exige tentativas frequentes ou chamadas de fallback.
• A tarefa é valiosa o suficiente para que a qualidade da conclusão importe mais do que minimizar o custo da primeira chamada.

K2.7 Code continua sendo uma forte opção para tarefas de codificação repetitivas e bem delimitadas que já alcançam alta taxa de sucesso dentro de 256K de contexto.

Para aplicações de codificação sensíveis à latência, o K2.7 Code HighSpeed também deve ser testado separadamente.

Migrando do K2.7 para o K3: cinco verificações de engenharia

1. O raciocínio do K3 não pode ser reduzido no momento

K3 sempre raciocina, e a API atual suporta apenas:

reasoning_effort="max"

Como max é o padrão, o parâmetro também pode ser omitido.

1. Remova parâmetros thinking específicos do K2

Não use o parâmetro thinking do K2.x com o K3.

Use o campo de nível superior reasoning_effort em seu lugar.

1. Omita parâmetros de amostragem fixos

O K3 atualmente usa valores fixos para parâmetros incluindo:

temperature=1.0
top_p=0.95
n=1
presence_penalty=0
frequency_penalty=0

A Moonshot recomenda omitir esses campos em vez de sobrescrevê-los.

1. Preserve mensagens completas do assistente

Para conversas multi-turn e loops de chamadas de ferramentas, passe a mensagem completa do assistente na próxima requisição em vez de reter apenas o content visível.

1. Valide visão e busca antes da produção

A API de visão atual do K3 não oferece suporte direto a URLs públicas de imagem. Use um formato de imagem compatível, como dados base64 ou o mecanismo de referência de arquivos da Moonshot.

A Moonshot também aconselha não depender de sua funcionalidade atual de Web Search para uso em produção no curto prazo enquanto o recurso está sendo atualizado.

Exemplo da API Kimi K3 em Python

K3 pode ser chamado por meio de uma interface de API compatível com OpenAI:

from openai import OpenAI

client = OpenAI(
    base_url="YOUR_OPENAI_COMPATIBLE_BASE_URL",
    api_key="YOUR_API_KEY",
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "You are an expert software engineer.",
        },
        {
            "role": "user",
            "content": "Analyze this repository logic and identify potential issues.",
        },
    ],
    reasoning_effort="max",  # Optional while "max" is the default
)

assistant_message = response.choices[0].message
print(assistant_message)

Evite sobrescrever os parâmetros de amostragem fixos do K3. Para fluxos multi-turn e de chamadas de ferramentas, preserve a mensagem completa do assistente.

Como avaliar o Kimi K3 antes de fazer o upgrade

Teste o K3 em cargas de trabalho reais em vez de apenas em prompts de benchmark.

Um conjunto prático de avaliação pode incluir:

• edições rotineiras de repositório
• tarefas próximas do limite de 256K de contexto
• tarefas que excedem 256K
• tarefas de engenharia visual
• tarefas agentivas ou de conhecimento de longo horizonte

Compare K3, K2.7 Code e K2.7 Code HighSpeed quando aplicável.

Acompanhe:

• taxa de sucesso das tarefas
• tokens de entrada em cache e sem cache
• tokens de saída e de raciocínio
• novas tentativas e chamadas de fallback
• latência p50 e p95
• erros de chamadas de ferramentas
• tempo de revisão humana
• custo por tarefa bem-sucedida

Em seguida, compare três políticas:

1. Apenas K2.7 Code
2. Apenas K3
3. K2.7 Code com escalonamento para K3

A melhor rota é a que atende aos seus requisitos de qualidade e latência com o menor custo por tarefa bem-sucedida.

Preços do Kimi K3 na CometAPI

Os cálculos acima usam os preços oficiais da API da Moonshot AI para manter a comparação entre K3 e K2.7 consistente.

No momento da publicação, o Kimi K3 na CometAPI está com preço 20% menor do que as tarifas padrão da API da Moonshot AI:

Como os preços da API podem mudar, verifique a página do modelo em tempo real antes de usar esses números para orçamento de produção.

A API compatível com OpenAI da CometAPI facilita testar kimi-k3 ao lado de outras rotas de modelos usando os mesmos prompts e fluxo de avaliação.

Pronto para testar o Kimi K3? Veja o Kimi K3 na CometAPI e compare os preços antes de colocá-lo em produção.

Para exemplos de integração e avaliação, consulte o CometAPI Cookbook no GitHub.

FAQ

Quanto custa a API do Kimi K3?

A Moonshot AI lista o Kimi K3 em $0.30 por 1 milhão de tokens de entrada com acerto de cache, $3.00 por 1 milhão de tokens de entrada com falha de cache e $15.00 por 1 milhão de tokens de saída.

O ID do modelo da API é kimi-k3.

O Kimi K3 é mais barato que o Kimi K2.7 Code?

Não. Com base nas tarifas oficiais da Moonshot, o K3 custa aproximadamente 3,16× para entrada com falha de cache e 3,75× para saída.

Ainda assim, ele pode reduzir os custos do fluxo de trabalho se melhorar a taxa de sucesso das tarefas ou reduzir novas tentativas.

O Kimi K3 tem uma janela de contexto de 1M tokens?

Sim. O Kimi K3 suporta uma janela de contexto de 1,048,576 tokens, em comparação com 262,144 tokens do Kimi K2.7 Code.

O Kimi K3 oferece cache de contexto automático?

Sim. O cache de contexto é automático. Tokens de entrada com acerto de cache custam $0.30 por milhão, contra $3.00 por milhão para tokens de entrada com falha de cache.

Posso desligar o raciocínio do Kimi K3 para reduzir custos?

No momento, não. O K3 sempre usa raciocínio, e reasoning_effort="max" é o único nível de esforço de raciocínio compatível.

Considerações finais

O Kimi K3 oferece substancialmente mais contexto e capacidades mais amplas do que o K2.7 Code, porém a um preço de token maior.

Para codificação rotineira dentro de 256K de contexto, o K2.7 Code geralmente é a escolha mais econômica. Para tarefas de longo contexto, multimodais ou agentivas difíceis, o K3 pode justificar seu ágio — especialmente quando melhora a conclusão bem-sucedida.

Para muitos sistemas de produção, a estratégia mais eficiente não é substituir totalmente o K2.7, mas usar K2.7 como padrão e K3 como rota de escalonamento.

A métrica que realmente importa não é o custo por chamada de API, mas sim o custo por tarefa bem-sucedida.