🎁 Novo Cadastre-se grátis, 10 chamadas por nossa conta. Até US$ 1, sem cartão.

Kimi K2.7 Code vs Qwen3.7 Plus

vs

Qual usar, quando — veredito curado, não uma tabela de benchmark

Ambos aceitam texto, imagem e vídeo na entrada e devolvem texto, e ambos cobrem chat, código, raciocínio e ferramentas, então a diferença é preço e folga: o qwen3.7-plus fica em $0.4 de entrada e $1.6 de saída contra $0.95 e $4 do kimi-k2.7-code, cerca de 2.4x mais barato na entrada e 2.5x na saída, com contexto de 1000000 tokens, 65536 de saída máxima e um sinalizador de contexto longo. Escolha o qwen3.7-plus para execuções de repositório inteiro ou documentos longos, por leituras de cache mais baratas ($0.08 contra $0.19), e quando precisar desligar o pensamento. Escolha o kimi-k2.7-code se quiser seu raciocínio sempre ativo e 256000 tokens bastarem.

Preços

Kimi K2.7 Code Qwen3.7 Plus Δ
Entrada / 1M tokens $0.95 $0.4 2.4×
Saída / 1M tokens $4 $1.6 2.5×
Leitura de cache / 1M tokens $0.19 $0.08 2.4×
Escrita de cache 1.25x

Tarifas do catálogo em tempo real no momento do build; a página de cada modelo contém o cartão atual.

Onde eles se posicionam — preço de entrada por 1M tokens entre todos os 63 modelos de chat nesta unidade de cobrança (escala logarítmica)

Kimi K2.7 Code · $0.95 Qwen3.7 Plus · $0.4
$0.05 · Qwen3 VL Flash $30 · GPT-5.4 Pro

Capacidades

Kimi K2.7 Code Qwen3.7 Plus
Uso de ferramentas sim sim
Controle de raciocínio sempre ativo configurável
Saída estruturada sim
Cache de prompt implícito (automático) implícito + explícito
Tempo de vida do cache não publicado explicit: 5m, reset on hit
Prefixo mínimo em cache não publicado 1024 tokens

Especificações

Kimi K2.7 Code Qwen3.7 Plus
Modalidades de entrada texto imagem vídeo texto imagem vídeo
Modalidades de saída texto texto
Lançamento 2026-06 2026-06-01
Janela de contexto 256K 1M
Saída máxima 33K 66K
Parâmetro de raciocínio
  • thinking.type
  • thinking.keep
  • enable_thinking
  • thinking_budget
  • preserve_thinking
Valores aceitos
type
  • accepts only enabled
keep
  • accepts only all
enable_thinking
  • true
  • false
thinking_budget
  • in tokens
preserve_thinking
  • true
  • false
Padrão thinking on with Preserved Thinking on

on

the Qwen3.7 Plus series is hybrid thinking with thinking enabled by default, and preserve_thinking is off

As especificações são transcritas da documentação de cada fornecedor; uma linha que um fornecedor não publica é omitida em vez de ser inferida. Fontes completas: Kimi K2.7 Code · Qwen3.7 Plus

Um prompt, ambos os modelos — medidos pelo gateway

PROMPT Explain to a CFO, in exactly three sentences, why our LLM bill doubled after we enabled reasoning. VERIFICAR exatamente 3 frases

Kimi K2.7 Code passou · 3 sentences

Enabling reasoning mode causes the model to generate an internal chain-of-thought before producing each answer, and that hidden reasoning text is billed like any other output. Those extra reasoning tokens typically add up to much more than the final response itself, so every API call now costs significantly more than before. Because our overall usage volume did not change, the doubled bill reflects that each query consumes roughly twice as many billable tokens.

saída 259 tok (+174 pensamento) latência 5.4 s

Qwen3.7 Plus passou · 3 sentences

Enabling reasoning requires the model to generate extensive internal "thinking" tokens to process complex logic before delivering a final answer. Because our vendor charges us per token consumed, this hidden computational overhead effectively doubles our output volume for the exact same number of user requests. Consequently, our costs have doubled because we are now paying for the model's increased processing time to achieve higher-quality, more accurate results.

saída 1428 tok (+1345 pensamento) latência 25.2 s

Cumprimento da instrução (exatamente três frases — contáveis), ajuste ao público (registro de CFO), e a lacuna de cobrança do pensamento oculto que os medidores de tokens abaixo expõem.

PROMPT This function is supposed to return the longest run of consecutive equal items, but callers report it is off by one on single-element inputs and misses runs that end at the last index. Fix it and explain the bug in one paragraph. VERIFICAR a correção passa nos testes

Kimi K2.7 Code passou · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is that the function counts *transitions* between equal neighbors instead of counting the items themselves, so a single-element list never enters the loop and returns `0` instead of `1`. Likewise, resetting `cur` to `0` on a mismatch forgets the current item that starts a new run, which causes runs that end at the last index to be undercounted. Initializing both `best` and `cur` to `1` and resetting `cur` to `1` fixes both issues.

saída 410 tok (+222 pensamento) latência 9.4 s

Qwen3.7 Plus passou · 8/8 cases

## Fixed Code ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` ## Bug Explanation The function has two related bugs rooted in how it counts run lengths. First, `cur` is initialized to `0` and only incremented on matches, so it counts the number of *transitions* between equal elements rather than the total elements in the run—a run of N identical items only reaches `cur = N − 1`, undercounting by one. This also causes the single-element case to return `0`, since the loop never executes and `cur` never increments. […]

saída 2317 tok (+2005 pensamento) latência 40.5 s

Se a correção é de fato certa (executável), a densidade da explicação, e a eficiência em tokens numa tarefa delimitada.

PROMPT Extract a JSON object with fields {company, quarter, revenue_usd_m, growth_pct, guidance} from this text. Use null for anything not stated; add no other fields. VERIFICAR JSON válido, esquema exato

Kimi K2.7 Code passou · 5/5 fields, guidance "withheld pending the Q4 close"

```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close" } ```

saída 721 tok (+663 pensamento) latência 13.2 s

Qwen3.7 Plus passou · 5/5 fields, guidance null

{ "company": "Meridian Robotics", "quarter": "September", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }

saída 1807 tok (+1750 pensamento) latência 31.6 s

Obediência ao esquema (sem campos inventados), pressão de alucinação (guidance é explicitamente retida), e diferenças no caminho de saída estruturada.

PROMPT Write a 120-word product announcement for an API gateway feature that caches prompts across providers. Forbidden words: "seamless", "unlock", "game-changer", "revolutionize", "empower". Exactly one sentence must be a question. VERIFICAR 120 palavras, 0 palavras proibidas

Kimi K2.7 Code passou · 120 words, 0 banned, 1 question

We're introducing Prompt Cache for our API Gateway, a new capability that stores prompt responses across multiple AI providers. By caching replies, you reduce redundant calls, lower latency, and cut costs without changing how you build. Teams using several model providers can now reuse identical prompt results instantly, keeping traffic consistent and budgets predictable. Responses are keyed by provider, model, and exact prompt, so you always get the right result. Configure TTL, hit thresholds, and eviction rules from a single dashboard. It fits into your existing routing and requires no code changes. Setup takes minutes and works with your current endpoints. Want to see how much latency and spend you can trim? Check the docs to enable Prompt Cache today.

saída 2375 tok (+2235 pensamento) latência 38.6 s

Qwen3.7 Plus passou · 120 words, 0 banned, 1 question

Introducing PromptCache, our new API gateway feature designed to store and reuse prompts across multiple artificial intelligence providers. Have you ever noticed how repeatedly sending identical queries drains your budget and increases latency? PromptCache solves this by intelligently storing responses at the gateway level. When your application requests the same prompt from a different provider, the system instantly returns the cached result. This drastically reduces API costs and accelerates response times for your users. You can configure custom expiration times and set specific fallback rules for each vendor. You must stop paying twice for the exact same computation. Please upgrade your entire infrastructure today and experience much faster and cheaper integrations without changing a single line of your application code.

saída 4453 tok (+4312 pensamento) latência 76.8 s

Obediência às restrições (orçamento de palavras, lista de palavras proibidas, a única pergunta), impressão digital de estilo, e controle de comprimento.

Alterne entre eles com uma linha

Ambos os IDs estão em todas as abas abaixo — o par de linhas destacado é a única edição. Mesmo endpoint, mesma chave, mesmo formato de requisição.

from openai import OpenAI

client = OpenAI(
    base_url="https://synthorai.io/v1",
    api_key="sk-syn-...",
)

resp = client.chat.completions.create(
    model="kimi-k2.7-code",
    # model="qwen3.7-plus",  # descomente esta linha, comente a linha acima
    messages=[{"role": "user", "content": "Summarize this diff"}],
    reasoning_effort="medium",
)
print(resp.choices[0].message.content)

Obter uma chave de API →

FAQ

Qual é mais barato, Kimi K2.7 Code ou Qwen3.7 Plus?

Qwen3.7 Plus é mais barato em entrada / 1m tokens ($0.4 vs $0.95, com 2.4× de diferença). Outras linhas podem apontar para o outro lado — a tabela acima traz o quadro completo, e o custo real depende do seu mix.

Posso fazer um teste A/B de Kimi K2.7 Code contra Qwen3.7 Plus sem duas integrações?

Sim. Ambos são servidos pelo mesmo endpoint compatível com OpenAI com uma única chave de API — a troca é uma alteração de uma linha na string do modelo, de modo que você pode rotear uma fração do tráfego para cada um e comparar as faturas diretamente.

Kimi K2.7 Code e Qwen3.7 Plus suportam prompt caching?

Sim — ambos cobram leituras em cache abaixo da sua taxa de entrada, então cargas de trabalho com warm-prefix custam menos do que as taxas listadas sugerem. As linhas exatas de leitura em cache estão na tabela de preços acima.

Comparações relacionadas

De nossos estudos medidos