DEV Community: Lucas

Claude Opus 5 x Sonnet 5: Qual te atende melhor?

Lucas — Sat, 25 Jul 2026 03:32:33 +0000

A Anthropic lançou o Claude Opus 5 em 24 de julho de 2026 e o Claude Sonnet 5 em 30 de junho de 2026. Ambos são modelos de geração atual, com janela de contexto de 1M de tokens, saída máxima de 128k, pensamento adaptativo ativado por padrão e um parâmetro de esforço. À primeira vista, parecem o mesmo modelo em faixas de preço diferentes — mas a escolha deve considerar custo por tarefa concluída, retentativas e requisitos de qualidade.

Experimente o Apidog hoje

A decisão também depende da data. O Sonnet 5 mantém a taxa introdutória de US$ 2 por milhão de tokens de entrada e US$ 10 por milhão de tokens de saída até 31 de agosto de 2026. Em 1º de setembro de 2026, passa para US$ 3 / US$ 15. O Opus 5 custa US$ 5 / US$ 25 e não tem alteração prevista. Portanto, o Opus custa 2,5x mais hoje, mas cerca de 1,67x mais após setembro. Se sua carga entra em produção no quarto trimestre, faça o orçamento com a tarifa de setembro.

Este guia mostra como comparar os dois modelos por especificações, custo por tarefa, uso em agentes de código e automação. Para validar a decisão com seus próprios prompts, execute ambos lado a lado no Apidog e compare os campos usage retornados pela API.

Preços e a mudança de setembro

Estas são as tarifas publicadas na página de preços da Anthropic:

Modelo	Entrada / MTok	Saída / MTok	Status
Claude Opus 5	US$ 5,00	US$ 25,00	Padrão
Claude Sonnet 5, até 31 de agosto de 2026	US$ 2,00	US$ 10,00	Introdutório
Claude Sonnet 5, a partir de 1º de setembro de 2026	US$ 3,00	US$ 15,00	Padrão

Antes de modelar custos do Opus 5, considere também:

Cache de prompt: US$ 6,25 por MTok para gravação de 5 minutos, US$ 10 para gravação de 1 hora e US$ 0,50 para acertos de cache.
API de Lote: US$ 2,50 / US$ 12,50, com desconto fixo de 50%.
Modo rápido: US$ 10 / US$ 50 para 2,5x de velocidade de saída. É uma prévia de pesquisa, disponível apenas na API de primeira parte e não pode ser combinado com lote.
inference_geo: "us": multiplicador de 1,1x para cada categoria de token.

Veja os detalhes nos guias de preços do Opus 5 e preços do Sonnet 5.

Um ponto importante: o Opus 5 custa o mesmo que o Opus 4.8. A Anthropic não elevou o preço do nível Opus para essa geração.

Especificações: quase o mesmo invólucro

Especificação	Claude Opus 5	Claude Sonnet 5
ID do modelo	`claude-opus-5`	`claude-sonnet-5`
Janela de contexto	1M tokens	1M tokens
Saída máxima	128k; 300k na API de Lote com cabeçalho beta	128k
Pensamento adaptativo	Ativado por padrão	Ativado por padrão
Níveis de esforço	Cinco, até `max`; padrão `high`	`low`, `medium`, `high`, `xhigh`
Corte de conhecimento	Maio de 2026	Janeiro de 2026
Nível de Prioridade	Não suportado	Não disponível
Cache, ferramentas, lote e visão	Suportado	Suportado
Tokenizador	Geração 4.7	Geração 4.7

Três diferenças têm impacto prático:

Corte de conhecimento: o Opus 5 inclui conhecimento até maio de 2026; o Sonnet 5 para em janeiro de 2026. Para dependências, APIs ou mudanças recentes, o Opus pode responder melhor sem recuperação. Com RAG bem implementado, essa diferença pode diminuir.
Nível de Prioridade: nenhum dos dois oferece esse recurso. Equipes migrando do Opus 4.8 devem revisar requisitos de latência. Consulte o guia de migração do Opus 4.8 para o Opus 5.
Tokenizador: não há diferença entre Opus 5 e Sonnet 5. Ambos usam o tokenizador de geração 4.7.

Por que custo por token não é custo por tarefa

A Anthropic documenta que modelos Claude 4.7 e posteriores podem produzir aproximadamente 30% mais tokens para o mesmo texto em comparação com Sonnet 4.6 e anteriores. Isso não é uma diferença entre Opus 5 e Sonnet 5: ambos tokenizam a mesma entrada da mesma forma.

Na prática, o custo depende principalmente de:

volume de saída;
uso de cache;
número de chamadas de ferramentas;
taxa de retentativas;
tempo de revisão humana;
validações automáticas e falhas de execução.

O Opus 5 pode gerar respostas visíveis mais longas. Reduzir output_config.effort reduz o pensamento, mas não garante respostas mais curtas. Se a resposta está verbosa, corrija o prompt.

Exemplo de instrução de concisão:

Responda apenas com:
1. o diagnóstico;
2. os arquivos que precisam mudar;
3. um diff mínimo;
4. riscos ou testes necessários.

Não explique conceitos básicos. Limite a resposta a 300 palavras.

O guia de prompting do Opus 5 mostra mais estratégias para controlar a saída.

Use o endpoint de contagem de tokens para medir entradas reais antes de projetar custos.

Exemplo de custo diário

Considere 500k tokens de entrada e 40k tokens de saída por dia:

Cenário	Custo diário	Relação com Sonnet 5
Opus 5	US$ 3,50	Base
Sonnet 5 introdutório, US$ 2 / US$ 10	US$ 1,40	Opus é 2,5x
Sonnet 5 padrão, US$ 3 / US$ 15	US$ 2,10	Opus é 1,67x
Opus 5 com 30% mais saída	US$ 3,80	Opus é 1,81x

A parte decisiva é a retentativa. Com preços padrão:

uma execução do Opus 5: US$ 3,50;
uma execução do Sonnet 5: US$ 2,10;
duas execuções do Sonnet 5: US$ 4,20.

Se o Sonnet precisa repetir uma tarefa que o Opus conclui na primeira tentativa, ele pode se tornar a opção mais cara. Avalie custo por resultado válido, não apenas custo por chamada. Para reduzir despesas em ambos, consulte o guia para reduzir sua conta da API Claude.

Quando o Opus 5 justifica o preço

Os números de lançamento da Anthropic devem ser tratados como resultados publicados pelo fornecedor, não como medições independentes. Até 25 de julho de 2026, esses resultados não haviam sido reproduzidos de forma independente.

As alegações de lançamento incluem:

Frontier-Bench v0.1: Opus 5 supera outros modelos e mais que dobra a pontuação do Opus 4.8, com menor custo por tarefa.
ARC-AGI 3: aproximadamente 3x a pontuação do segundo melhor modelo.
OSWorld 2.0: supera o Fable 5 a cerca de um terço do custo.
CursorBench 3.2: fica a 0,5% do pico do Fable 5 pela metade do preço.
Zapier AutomationBench: taxa de aprovação cerca de 1,5x maior que o segundo melhor modelo.
Ciência: ganhos de 10,2 pontos em química orgânica e 7,7 em análise de proteínas versus Opus 4.8.

O Sonnet 5 ficou abaixo do Opus 4.8 nos números de lançamento: SWE-bench Pro de 63,2% contra 69,2%, Terminal-Bench 2.1 de 80,4% contra 82,7% e OSWorld-Verified de 81,2% contra 83,4%.

Veja atribuições e ressalvas nos posts de benchmarks do Opus 5 e benchmarks do Sonnet 5.

Prefira o Opus 5 quando houver uma ou mais destas condições:

Agentes de código de longa duração: refatorações multi-arquivo, migrações e fluxos com dezenas de chamadas de ferramentas.
Alto custo de erro: alterações em produção, segurança, infraestrutura ou código que exige revisão humana profunda.
Uso de computador e automação de desktop: é o principal cenário destacado pela Anthropic com OSWorld 2.0.
Raciocínio científico ou analítico complexo.
Necessidade de conhecimento até maio de 2026 sem uma camada de recuperação confiável.

Quando o Sonnet 5 é suficiente

Para a maior parte do tráfego de produção, o Sonnet 5 é a escolha prática. Pagar por capacidade que não muda seus critérios de aceitação não melhora o sistema.

Use o Sonnet 5 quando:

O volume é alto e cada chamada é curta: classificação, extração, sumarização, tagging e roteamento.
A saída possui validação automática: schemas, testes, parsers e regras de negócio detectam falhas com baixo custo.
Latência importa mais que profundidade.
Você está prototipando: comece com Sonnet e faça upgrade somente se os dados justificarem.

O Sonnet 5 é o modelo padrão do plano Claude gratuito, permitindo validar prompts reais antes de integrar a API. O Opus 5 está disponível para assinantes Pro e é o padrão para Max. Veja os caminhos no guia de acesso gratuito ao Opus 5.

Tabela de decisão por carga de trabalho

Carga de trabalho	Escolha	Motivo
Refatoração multi-arquivo ou migração em loop de agente	Opus 5	Falhas compostas tornam a confiabilidade por etapa mais importante
Classificação ou extração de alto volume	Sonnet 5	Ambos tendem a atingir o teto de qualidade; preço vence
Chat para clientes com RAG	Sonnet 5	Recuperação reduz a diferença de conhecimento; latência importa
Uso de computador ou automação de desktop	Opus 5	OSWorld 2.0 é a alegação de agente mais forte da Anthropic
Processamento noturno de documentos	Sonnet 5 ou Opus 5 em lote	Lote reduz em 50% o custo do Opus
Revisão de segurança ou código crítico	Opus 5	O custo da falha excede a diferença de tokens
Análise científica ou quantitativa	Opus 5	Maiores ganhos reportados em química e análise de proteínas
Protótipos e ferramentas internas	Sonnet 5	Meça a diferença antes de fazer upgrade
Conhecimento de primavera de 2026 sem RAG	Opus 5	Corte de maio versus janeiro de 2026
UX interativa sensível a latência	Sonnet 5	Ou Opus 5 em modo rápido se profundidade for inegociável

A API de Lote merece atenção: o Opus 5 em lote custa US$ 2,50 / US$ 12,50. Isso fica abaixo da tarifa padrão de setembro do Sonnet 5 para entrada e ligeiramente acima para saída. Se o processamento pode ser assíncrono, o Opus pode caber no orçamento.

O que nenhum dos modelos é

O Opus 5 não é o topo absoluto da linha Claude. O Fable 5 continua sendo o modelo mais capaz e amplamente lançado da Anthropic, por US$ 10 / US$ 50.

Além disso, segundo a própria Anthropic, o Opus 5 ainda fica atrás do Mythos 5 em exploração de segurança cibernética e pesquisa de biologia autônoma.

O enquadramento correto é: capacidade de classe de fronteira por cerca de metade do preço de fronteira, mas com um nível superior para cargas de trabalho que realmente precisam dele. Se esse for seu caso, compare Opus 5 vs Fable 5.

Como testar Opus 5 e Sonnet 5 no Apidog

Benchmarks não substituem seus prompts, ferramentas e critérios de aceitação. Como ambos usam o endpoint de Mensagens, o teste A/B é basicamente uma troca de string no campo model.

Configure o teste no Apidog:

Crie uma requisição para o endpoint de Mensagens da Anthropic.
Salve a chave como variável de ambiente, em vez de colocá-la no body.
Crie duas variantes com o mesmo prompt:
- claude-opus-5
- claude-sonnet-5
Leia o objeto usage em cada resposta.
Adicione asserções para detectar recusas, respostas truncadas e schemas inválidos.
Execute uma varredura de output_config.effort no Opus 5 e compare qualidade, latência e custo.

Exemplo de requisição:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "Refatore este handler para usar I/O assíncrono."
      }
    ]
  }'

Ao analisar a resposta, armazene as métricas:

{
  "model": "claude-opus-5",
  "input_tokens": 0,
  "output_tokens": 0,
  "cache_read_input_tokens": 0,
  "cache_creation_input_tokens": 0,
  "passed": true,
  "latency_ms": 0
}

Depois, compare os resultados por taxa de sucesso e custo por execução válida:

custo_por_resultado_valido =
  custo_total_das_execucoes / numero_de_resultados_aprovados

Duas armadilhas importantes:

O pensamento adaptativo está ativado por padrão nos dois modelos. max_tokens limita pensamento e resposta visível juntos; um limite que funcionava em modelos anteriores pode causar truncamento.
No Opus 5, combinar thinking: {type: "disabled"} com esforço xhigh ou max retorna HTTP 400.

Use o Apidog para executar as duas variantes lado a lado. Para o fluxo completo, consulte o passo a passo da API do Opus 5 e o guia do parâmetro de esforço.

Perguntas frequentes

O Claude Opus 5 vale 2,5x o preço do Sonnet 5?

Para agentes de código de longa duração, uso de computador e tarefas caras de errar, pode valer. Para classificação, extração e chat de alto volume, geralmente não. A diferença é de 2,5x até 1º de setembro de 2026 e de aproximadamente 1,67x depois disso.

Quando o preço do Claude Sonnet 5 muda?

A tarifa introdutória de US$ 2 / US$ 10 vai até 31 de agosto de 2026. Em 1º de setembro de 2026, muda para US$ 3 / US$ 15. O Opus 5 permanece em US$ 5 / US$ 25.

Opus 5 e Sonnet 5 tokenizam texto de forma diferente?

Não. Ambos usam o tokenizador de geração 4.7. Texto idêntico produz a mesma contagem de tokens de entrada nos dois modelos. O aumento aproximado de 30% documentado pela Anthropic se aplica em comparação com Sonnet 4.6 e modelos anteriores.

Posso alternar entre Opus 5 e Sonnet 5 sem mudanças no código?

Na maior parte dos casos, sim. Ambos adotam pensamento adaptativo por padrão e rejeitam parâmetros de amostragem não padrão. Observe as diferenças de esforço: o Opus 5 inclui max, usa high como padrão e retorna 400 se o pensamento estiver desativado com xhigh ou max.

Qual modelo a Anthropic recomenda por padrão?

A documentação recomenda começar pelo Opus 5 em caso de dúvida. Isso é uma recomendação de capacidade, não uma análise de custo. Teste se o Sonnet 5 atinge os mesmos critérios por menos. A comparação Sonnet 5 vs Opus 4.8 também ajuda a entender o posicionamento entre os níveis.

Para especificações, benchmarks e disponibilidade, comece em o que é Claude Opus 5, além da postagem de lançamento do Opus 5 e da visão geral de modelos da Anthropic.

Otimize seus Prompts para Claude Opus 5: Pare de Pedir a Dupla Verificação

Lucas — Sat, 25 Jul 2026 03:30:20 +0000

A maioria dos guias de migração informa o que quebra no código. Este mostra o que pode quebrar nos seus prompts.

Experimente o Apidog hoje

O Claude Opus 5 foi lançado em 24 de julho de 2026, e a Anthropic publicou um guia de prompt dedicado. O ponto central: algumas instruções que melhoravam o Opus 4.8 pioram o Opus 5 — com mais custo, mais verbosidade e, em um caso, comportamento potencialmente quebrado em loops de agentes.

O motivo é simples: o Opus 5 já executa por padrão várias ações que antes precisavam ser solicitadas. Se o prompt legado também pede essas ações, você acumula instruções sobre comportamentos nativos do modelo. O resultado não é o dobro da precisão, mas verificações redundantes e mais tokens.

Este guia mostra o que remover, o que restringir e como validar as mudanças em produção. Para alterações de código, consulte o guia de migração do Opus 4.8 para o Opus 5. Para comparar solicitações e respostas reais com configurações diferentes, use o Apidog.

Resumo

O Opus 5 tende a:

verificar mais o próprio trabalho;
produzir respostas mais longas;
delegar mais para subagentes;
narrar mais as próprias correções.

Portanto, a migração de prompts é principalmente subtrativa. Remova instruções redundantes e adicione limites explícitos de tamanho, escopo e delegação.

1. Remova instruções globais de verificação

A Anthropic afirma que o Opus 5 verifica o próprio trabalho sem ser solicitado: relê respostas, confere cálculos, repete testes e procura casos de borda.

No Opus 4.8, era comum incluir regras como estas:

Double-check your work before responding.
Verify each step before moving to the next one.
Review your answer for errors, then revise it.
Check your reasoning carefully.
Make sure the output is correct before returning it.

No Opus 5, mantenha essas linhas fora do prompt de sistema. Elas podem induzir passagens extras de verificação que o modelo já faria, aumentando o consumo de tokens em especial em fluxos agentic longos.

Como manter verificações realmente necessárias

Se uma etapa for de alto risco, limite a verificação a ela:

Do not add general verification passes; you already verify by default.
The only exception: after writing the migration SQL, run it against the
schema dump once and report any mismatch. Do not re-verify anything else.

Use este padrão:

Desative verificações genéricas.
Nomeie a única etapa que exige conferência extra.
Defina quantas vezes ela deve ocorrer.
Proíba novas verificações fora desse escopo.

Para otimizar custos além do prompt, combine essa mudança com cache e lote descritos no detalhamento de preços do Opus 5 e no guia para reduzir uma conta da API Claude.

2. Defina limites de saída explicitamente

As respostas e os artefatos escritos do Opus 5 tendem a ser mais longos do que no Opus 4.8.

Reduzir effort não resolve a verbosidade visível. Esse parâmetro controla quanto o modelo pensa, não quanto ele escreve. Ao reduzir de xhigh para medium, você pode diminuir tokens de raciocínio sem reduzir proporcionalmente o tamanho da resposta.

Consulte o guia do parâmetro de esforço do Opus 5 para os efeitos de cada nível.

Limite respostas de chat

Evite instruções vagas como “seja breve”. Prefira números e formato:

Response format: at most 150 words unless I ask for more.
No preamble, no restatement of my question, no summary at the end.
Lead with the answer, then the reasoning if it is needed.

Limite documentos e entregáveis

Defina tamanho, conteúdo obrigatório e conteúdo proibido:

Write the migration doc at 800 words maximum.
Include: the breaking changes, the fix for each, and a rollback step.
Exclude: background on the old system, a glossary, and a conclusion section.
If a section would exceed its share, cut examples before cutting steps.

Limite explicações em mudanças de código

Para tarefas de código, controle comentários e texto adicional:

Return the diff and nothing else.
No explanation of what you changed unless the change is non-obvious,
in which case one sentence above the hunk.

3. Limite a delegação para subagentes

O Opus 5 delega para subagentes mais facilmente do que o Opus 4.8 quando o framework oferece esse recurso.

Isso pode ser útil, mas cada subagente adiciona contexto, chamadas e tokens. Para fluxos sensíveis a custo ou latência, estabeleça uma regra explícita.

Para impedir delegação

Do not spawn subagents for this task. Handle it in this conversation.

Para permitir delegação controlada

You may delegate to at most 2 subagents, and only for independent
file-level work that can run in parallel.
Do research, planning, and final synthesis yourself in this thread.

Evite delegar tarefas que o thread principal já consegue resolver com o contexto atual, como ler um único arquivo ou tomar uma decisão local.

Se você usa subagentes de forma intencional, veja o guia para criar subagentes de código Claude.

4. Restrinja o escopo de tarefas cirúrgicas

O Opus 5 pode expandir uma tarefa pequena. Ao pedir uma correção de teste, ele pode refatorar auxiliares, alterar assinaturas e adicionar novos testes. Em tarefas abertas, isso pode ajudar. Em correções pontuais, aumenta o diff e o risco de regressões.

Declare explicitamente o que pode e o que não pode mudar:

Scope: change only the retry-count constant in src/client/http.ts.
Do not refactor surrounding code, do not rename anything, do not add
tests, do not update docs. If you believe another change is required,
stop and tell me instead of making it.

A última frase é importante. Ela dá ao modelo uma forma de apontar uma dependência ou risco sem modificar arquivos fora do escopo.

5. Desative a narração de correções quando a saída for consumida por máquinas

O Opus 5 tende a explicar quando muda de abordagem no meio da resposta. Isso é útil no trabalho interativo, mas pode poluir respostas consumidas por parsers, interfaces ou outros modelos.

Para retornar apenas o resultado final:

Do not narrate corrections or changes of approach.
Return only the final answer. If you revised your thinking, that
revision belongs in your reasoning, not in the response.

Em pipelines estruturados, combine essa instrução com saída estruturada. Não dependa apenas do prompt para preservar o formato.

Modos de falha com pensamento desabilitado

Os itens anteriores são ajustes de qualidade e custo. Esta seção trata de correção.

A Anthropic documenta dois artefatos que podem ocorrer quando o pensamento é desabilitado com:

{
  "thinking": {
    "type": "disabled"
  }
}

Chamadas de ferramenta retornadas como texto

O modelo pode emitir algo que parece uma chamada de ferramenta no texto da resposta, em vez de retornar um bloco estruturado tool_use.

Nesse caso:

nenhuma ferramenta é executada;
um loop de agente pode não perceber a falha;
o texto vazado pode entrar no histórico;
interações futuras podem interpretar a falsa chamada como uma ação concluída.

Em um chat isolado, o erro é visível. Em um agente com múltiplos turnos, ele pode se propagar silenciosamente.

Tags XML internas na resposta

Tags como <thinking> podem aparecer na saída visível. Isso é problemático para interfaces, renderização HTML e parsers.

Não adicione instruções como “nunca exiba tags <thinking>”. Nomear essas sequências no prompt pode aumentar a chance de vazamento.

Mitigação recomendada

Em vez de desabilitar o pensamento, mantenha-o habilitado e reduza o esforço:

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "output_config": { "effort": "low" },
  "messages": [
    { "role": "user", "content": "..." }
  ]
}

Isso reduz custos sem introduzir os artefatos associados ao pensamento desabilitado.

Também observe:

combinar thinking: {type: "disabled"} com esforço xhigh ou max retorna erro 400;
com pensamento desabilitado, o limite é esforço high;
no Opus 5, o pensamento é ativado por padrão;
omitir o campo thinking usa pensamento adaptativo, diferentemente do comportamento esperado no Opus 4.8.

Se desabilitar o pensamento for obrigatório, implemente validação defensiva no loop do agente:

Inspecione cada turno do assistente antes de gravá-lo no histórico.
Detecte padrões que representem chamadas de ferramenta não estruturadas.
Rejeite o turno e registre o erro.
Não permita que a resposta inválida entre na transcrição.

Falhe de forma explícita em vez de aceitar uma chamada fantasma no histórico.

Teste os prompts em vez de adivinhar

Mudanças de prompt não devem ser avaliadas apenas pela leitura. Comprimento de resposta, tokens de raciocínio, cache e chamadas de ferramenta precisam ser medidos em solicitações reais.

Você pode configurar essa comparação no Apidog:

Crie uma solicitação para o endpoint Messages da Anthropic com "model": "claude-opus-5".
Armazene a chave de API em uma variável de ambiente, nunca no corpo da solicitação.
Salve o prompt de sistema antigo do Opus 4.8 e a versão simplificada para Opus 5 como duas solicitações separadas.
Execute ambas com a mesma entrada.
Compare o bloco usage de cada resposta.
Execute variações com níveis diferentes de effort.
Inspecione a resposta de streaming para confirmar que chamadas de ferramenta chegam como blocos estruturados tool_use, não como texto.

Ao comparar usage:

tokens de saída mostram se o limite de concisão funcionou;
tokens de entrada ajudam a identificar crescimento desnecessário do prompt;
campos de cache mostram se alterações quebraram um prefixo cacheável;
respostas de streaming ajudam a detectar chamadas de ferramenta serializadas incorretamente.

O último teste detecta chamadas de ferramenta em texto puro antes da produção. Baixe o Apidog para executar comparações lado a lado e consulte o tutorial da API Opus 5 para a solicitação completa.

O limite honesto

O Opus 5 não é o topo da pilha Claude. O Fable 5 mantém a designação de “mais capaz amplamente lançado”, e o Opus 5 ainda está atrás do Mythos 5 em exploração de segurança cibernética e pesquisa de biologia autônoma.

A Anthropic menciona ambos no próprio post de lançamento. A posição precisa é capacidade de classe de fronteira pela metade do preço de fronteira, com um limite claramente definido acima dele.

Os benchmarks de lançamento — Frontier-Bench, ARC-AGI 3, OSWorld 2.0 e CursorBench — são números publicados pela própria Anthropic e não haviam sido reproduzidos independentemente até 25 de julho de 2026. Trate-os como relatórios do fornecedor e execute avaliações com seus prompts e cargas de trabalho reais.

Prompt de sistema base para tarefas sensíveis a custo

Use este ponto de partida para migrar um agente do Opus 4.8:

Do not add verification passes; you verify by default.
Responses: 150 words maximum, no preamble, no closing summary.
Do not spawn subagents. Handle this in one thread.
Stay strictly within the task I state. If another change seems
required, stop and tell me rather than making it.
Do not narrate corrections or changes of approach.

São seis linhas, quase todas restrições. Nenhuma pede que o modelo se esforce mais.

No Opus 4.8, os prompts frequentemente buscavam elevar o comportamento do modelo. No Opus 5, o objetivo é definir limites operacionais claros.

Faça uma varredura de effort com suas próprias avaliações, pois os níveis foram recalibrados. Para detalhes adicionais, consulte:

FAQ

Devo excluir “verifique seu trabalho” dos prompts?

Sim. O guia da Anthropic informa que o Opus 5 verifica o trabalho sem solicitação. Remova regras globais de verificação e use exceções estritamente limitadas para etapas de alto risco.

Por que o Opus 5 continua prolixo com effort baixo?

Porque effort controla o pensamento, não o tamanho da resposta visível. Defina limites de palavras, formato e conteúdo diretamente no prompt.

Como impedir a criação de subagentes?

Use uma instrução direta:

Do not spawn subagents for this task. Handle it in this conversation.

Se precisar permitir delegação, imponha um limite numérico e restrinja-a a tarefas independentes que possam rodar em paralelo.

Por que tags <thinking> aparecem na saída?

Esse artefato pode ocorrer quando o pensamento está desabilitado. Não escreva um prompt citando as tags. Mantenha o pensamento habilitado e reduza effort para controlar custos.

O que fazer se uma chamada de ferramenta vier como texto simples?

Considere o turno inválido: nenhuma ferramenta foi executada. Valide a resposta antes de adicioná-la ao histórico do agente, rejeite formatos de chamada não estruturados e prefira manter o pensamento habilitado.

Como Usar Claude Opus 5 de Graça

Lucas — Sat, 25 Jul 2026 03:27:27 +0000

O Anthropic lançou o Claude Opus 5 em 24 de julho de 2026. A resposta curta para “posso usá-lo gratuitamente?” depende de como você acessa o modelo: nos aplicativos Claude, ele está incluído em assinaturas pagas — padrão no Max e como modelo de maior desempenho no Pro. Pela API, não existe acesso gratuito e ilimitado ao claude-opus-5.

Experimente o Apidog hoje

A API cobra $5 por milhão de tokens de entrada e $25 por milhão de tokens de saída, o mesmo preço do Opus 4.8 e metade do Fable 5 ($10 / $50). A boa notícia é que você pode reduzir esse custo com Batch API, cache de prompts e configuração de esforço. Use o Apidog para enviar, salvar e comparar as requisições enquanto mede o consumo real.

Para a especificação completa, consulte o que é o Claude Opus 5. Veja também a publicação de lançamento do Opus 5 e a visão geral dos modelos.

“Grátis” nos aplicativos Claude significa que o uso está coberto pela assinatura, sujeito aos limites do plano. “Grátis” na API significa usar créditos promocionais ou de teste até o saldo acabar.

Caminho gratuito 1: assinatura Claude Pro ou Max

Segundo os materiais de lançamento da Anthropic:

Max: o Opus 5 é o modelo padrão.
Pro: o Opus 5 é o modelo de maior desempenho disponível.

Os materiais não confirmam o Opus 5 no plano gratuito. Antes de montar um fluxo em torno dele, abra o seletor de modelos da sua conta e confirme a disponibilidade.

O Opus 5 também está disponível no Claude Code, Claude Cowork e GitHub Copilot. Se você já paga por um desses produtos, verifique se o acesso está incluído no seu plano.

Atenção ao consumo: o Opus 5 ativa thinking por padrão, tende a gerar respostas mais longas e delega tarefas a subagentes com mais facilidade que o Opus 4.8. Isso pode esgotar sua franquia mais rapidamente.

Para controlar esse uso no ambiente de desenvolvimento, consulte como usar o Claude Opus 5 no Claude Code. Para a geração anterior, veja como usar o Claude Opus 4.8 gratuitamente.

Caminho gratuito 2: créditos de teste e promoções de nuvem

Na API da Anthropic, o ID do modelo é:

claude-opus-5

Não há sufixo de data. A API é cobrada por uso, mas há duas formas legítimas de começar sem pagar antecipadamente:

Créditos para novas contas da API Anthropic

Novas contas podem receber um pequeno saldo promocional. Use-o para validar a integração e medir tokens antes de adicionar um cartão.
Créditos promocionais em provedores de nuvem

O Opus 5 está disponível em:
- Amazon Bedrock: anthropic.claude-opus-5
- Claude Platform na AWS
- Google Cloud
- Microsoft Foundry

Os créditos, valores e termos mudam com frequência. Consulte diretamente a oferta vigente de cada plataforma.

Use esses créditos para medir sua carga real, não para tráfego de produção. Em cada resposta, registre o bloco usage para calcular o custo por tarefa. A tabela atual está na documentação de preços da Anthropic.

Cuidado: `thinking` é ativado por padrão

No Opus 4.8, uma requisição sem o campo thinking era executada sem thinking. No Opus 5, a mesma requisição usa thinking adaptativo.

Como tokens de thinking são cobrados como saída — $25 por milhão de tokens na tarifa padrão — migrar testes do 4.8 sem revisar a configuração pode esgotar seus créditos mais rápido.

Veja os detalhes em migrando do Opus 4.8 para o Opus 5.

Não existe API gratuita e ilimitada

Nenhum plano gratuito da API Claude fornece chamadas ilimitadas para claude-opus-5.

Evite proxies, pools de chaves ou revendedores que prometem acesso gratuito a modelos de fronteira. Além de potencialmente violarem os termos da Anthropic, eles podem encaminhar seus prompts por infraestrutura que você não controla.

Quando seus créditos promocionais terminarem, você paga por token ou interrompe o uso.

O caminho pago mais barato

A tarifa base é:

Tipo de token	Preço por milhão
Entrada	$5
Saída	$25

Para reduzir a fatura, aplique as alavancas abaixo.

1. Use a Batch API para tarefas assíncronas

Tudo que não precisa de resposta em segundos deve ir para a API Batch.

A Batch API cobra exatamente metade da tarifa padrão:

Tipo de token	Preço Batch por milhão
Entrada	$2,50
Saída	$12,50

Use Batch para:

avaliações noturnas;
classificação em massa;
processamento de documentos;
suites de regressão;
geração de conteúdo;
pipelines assíncronos.

A qualidade não muda: é o mesmo modelo executando a mesma solicitação. A diferença é a latência.

A Batch API também aceita até 300.000 tokens de saída por requisição com o cabeçalho beta:

output-300k-2026-03-24

Na API Messages padrão, o limite é 128.000 tokens. O modo rápido não é compatível com Batch.

2. Ajuste `output_config.effort`

O Opus 5 oferece output_config.effort, que controla o esforço de raciocínio e, consequentemente, o volume de tokens de thinking.

O padrão é high. Para workloads que toleram menor custo, compare:

{
  "output_config": {
    "effort": "low"
  }
}

Níveis disponíveis para testar incluem:

low
medium
high

A Anthropic afirma que low e medium são consideravelmente mais fortes no Opus 5 que em modelos Opus anteriores. Portanto, não reutilize automaticamente as decisões de esforço do Opus 4.8: execute suas próprias avaliações.

Duas regras práticas:

Reduzir effort reduz tokens de thinking, não necessariamente o tamanho da resposta visível.

Se quiser respostas curtas, defina isso no prompt.
Não desative thinking apenas para economizar.

Combinar thinking: { "type": "disabled" } com effort xhigh ou max retorna erro 400. A recomendação da Anthropic é manter thinking ativo e baixar o esforço quando necessário.

Com thinking desativado, o modelo pode escrever chamadas de ferramentas como texto simples ou expor tags XML internas na resposta.

Veja uma análise dos níveis em parâmetro de esforço do Claude Opus 5.

3. Ative cache de prompts para contexto repetido

Tokens lidos do cache custam $0,50 por milhão, um décimo da entrada padrão.

Operação	Preço por milhão de tokens
Entrada padrão	$5,00
Leitura de cache	$0,50
Escrita de cache de 5 minutos	$6,25
Escrita de cache de 1 hora	$10,00

No Opus 5, o prefixo mínimo armazenável em cache caiu de 1.024 para 512 tokens. Isso permite cachear prompts menores sem alterar a estrutura do contexto.

Exemplo: uma chamada com 40.000 tokens estáveis e 10.000 tokens variáveis.

Sem cache: 50.000 tokens de entrada × $5/MTok = $0,25
Gravação de cache: 40.000 tokens × $6,25/MTok = $0,25
Leitura de cache posterior:
- 40.000 tokens cacheados × $0,50/MTok = $0,02
- 10.000 tokens novos × $5/MTok = $0,05
- Total: $0,07

Confirme o funcionamento do cache no retorno da API:

{
  "usage": {
    "cache_read_input_tokens": 40000
  }
}

Se cache_read_input_tokens permanecer em zero na segunda chamada, revise a posição do ponto de interrupção de cache.

4. Evite o modo rápido quando custo for prioridade

O modo rápido custa o dobro:

Tipo de token	Tarifa padrão	Modo rápido
Entrada	$5/MTok	$10/MTok
Saída	$25/MTok	$50/MTok

Em troca, ele oferece aproximadamente 2,5x mais velocidade de saída.

Use-o apenas quando a latência for crítica, como interfaces em que o usuário acompanha a resposta sendo gerada. O modo rápido é uma prévia de pesquisa, funciona apenas na API de primeira parte e não está disponível no Bedrock, Google Cloud, Microsoft Foundry ou Batch API.

5. Não defina `inference_geo` sem necessidade

Adicionar:

{
  "inference_geo": "us"
}

aplica um multiplicador de 1,1x a todas as categorias de tokens.

Essa configuração existe para requisitos de residência de dados. Se você não tem esse requisito, não a envie.

Uma economia marginal vem do overhead de ferramentas: no Opus 5, o prompt de sistema para uso de ferramentas consome 286 tokens quando tool_choice é auto ou none, abaixo dos 290 tokens do Opus 4.8 e dos 675 tokens do Opus 4.7.

Para estratégias aplicáveis a toda a linha Claude, leia corte sua conta da API Claude.

Comparação de custos em um relance

Configuração	Entrada / MTok	Saída / MTok	Melhor para
Padrão, esforço `high`	$5,00	$25,00	Uso interativo padrão
API Batch	$2,50	$12,50	Processamento assíncrono
Leitura de cache em prefixo estável	$0,50	n/a	Contexto longo repetido
Modo rápido	$10,00	$50,00	Latência crítica
`inference_geo: "us"`	1,1x em todas as categorias	1,1x em todas as categorias	Residência de dados

O desconto de 50% do Batch se aplica às tarifas padrão de token. Confirme na sua própria fatura como ele interage com tokens em cache antes de projetar uma economia combinada.

Veja exemplos detalhados em preços do Claude Opus 5.

Testando os caminhos baratos no Apidog

Você consegue verificar cada otimização usando uma resposta HTTP. Comece com uma chamada base:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "output_config": {"effort": "low"},
    "messages": [
      {
        "role": "user",
        "content": "Resuma esta especificação OpenAPI em três frases."
      }
    ]
  }'

No Apidog, salve a chamada como uma requisição POST e armazene a chave em uma variável de ambiente. Nunca deixe a chave no body, em exemplos compartilhados ou no repositório.

Em seguida, valide cada ponto:

Compare níveis de esforço Duplique a requisição e altere effort entre low, medium e high. Compare:

   usage.output_tokens

Confirme o cache Envie duas vezes a mesma requisição com prefixo longo. Na segunda execução, valide:

   usage.cache_read_input_tokens

Detecte truncamento por max_tokens Thinking e resposta visível compartilham o orçamento de max_tokens. Adicione uma asserção para detectar:

   {
     "stop_reason": "max_tokens"
   }

Esse retorno indica que você pagou por uma saída que pode ter sido interrompida antes de concluir.

Inspecione streaming e chamadas de ferramentas Analise respostas SSE e payloads de ferramentas. Isso é especialmente importante em loops de agentes, nos quais chamadas extras podem aumentar o custo rapidamente.

Baixe o Apidog para acompanhar as requisições e consulte como usar a API do Claude Opus 5 para o guia de integração.

O Opus 5 é mesmo o modelo que você deve otimizar?

Às vezes, o menor custo vem da escolha de outro modelo.

O Sonnet 5 tem preço introdutório de $2 / $10, subindo para $3 / $15 em 1º de setembro de 2026, e compartilha a janela de contexto de 1 milhão de tokens. Se seu workload não exige codificação agêntica ou raciocínio complexo em múltiplas etapas, compare os dois antes de otimizar o Opus 5.

Veja Claude Opus 5 vs Sonnet 5 e como usar o Claude Sonnet 5 gratuitamente.

As afirmações da Anthropic posicionam o Opus 5 com mais do que o dobro da pontuação Frontier-Bench do Opus 4.8, a menos de 0,5% do Fable 5 no CursorBench 3.2 pela metade do preço e à frente do Fable 5 no OSWorld 2.0 por um terço do custo.

Esses são números publicados pelo fornecedor, não reproduzidos de forma independente em 25 de julho de 2026. Trate-os como hipóteses para testar nas suas próprias tarefas.

O Fable 5 continua sendo o modelo mais capaz da Anthropic amplamente lançado. O Opus 5 também fica atrás do Mythos 5 em exploração de segurança cibernética e pesquisa autônoma em biologia. Para workloads próximos desse teto, consulte o que é o Claude Fable 5.

Qual caminho escolher

Objetivo	Caminho recomendado	Desvantagem
Chat, escrita e pesquisa	Claude Pro ou Max	Limites medidos; o Opus 5 pode consumi-los mais rápido que o 4.8
Codificação agêntica	Claude Code em plano pago	Prompts longos e subagentes consomem a franquia
Protótipo de integração	Créditos de teste ou promoção de nuvem	Saldo finito; depois, cobrança por token
API de produção com menor custo	Batch + cache + esforço `low`	Batch adiciona latência e cache exige prefixo estável
API interativa com menor custo	Tarifa padrão + cache + esforço por tarefa	Não há desconto Batch

FAQ

O Claude Opus 5 é gratuito?

Não pela API. Nos aplicativos Claude, ele está disponível em assinaturas pagas: padrão no Max e como modelo de maior desempenho no Pro. Os materiais de lançamento não confirmam o plano gratuito como superfície do Opus 5.

Posso acessar gratuitamente a API do Claude Opus 5?

Somente por créditos de teste em novas contas ou créditos promocionais no Amazon Bedrock, Google Cloud ou Microsoft Foundry. Todos têm saldo finito. Não existe um nível de API gratuito e ilimitado.

Qual é a forma legítima mais barata de usar o Opus 5 em volume?

Use API Batch ($2,50 / $12,50), cache de prompt para prefixos estáveis acima de 512 tokens e effort low ou medium quando suas avaliações permitirem. Mantenha o modo rápido desativado e não envie inference_geo sem exigência de residência de dados.

Devo desativar thinking para economizar tokens?

Não. Combinar thinking desativado com effort xhigh ou max retorna erro 400. A orientação da Anthropic é manter thinking ativo e reduzir o esforço.

Além disso, com thinking desativado, o Opus 5 pode gerar chamadas de ferramentas como texto simples ou vazar tags XML internas. Meça o impacto lendo usage em cada resposta e crie asserções em uma requisição salva no Apidog.

Claude Opus 5 Benchmarks: O Que os Números Realmente Dizem

Lucas — Sat, 25 Jul 2026 03:24:02 +0000

A Anthropic lançou o Claude Opus 5 em 24 de julho de 2026 com alegações de benchmark muito fortes: mais que o dobro da pontuação do Opus 4.8 em uma avaliação, cerca de 3x o próximo melhor modelo em outra e vantagem sobre o Fable 5 com menor custo em uma terceira.

Experimente o Apidog hoje

Essas alegações não são necessariamente incorretas. Mas devem ser lidas como qualquer benchmark publicado por fornecedor: verificando o que foi medido, qual configuração foi usada, contra qual baseline e quais dados ficaram de fora. Este guia reúne as alegações publicadas para o Opus 5, explica como interpretá-las e mostra como reproduzir uma avaliação prática no Apidog.

Para o modelo em si — claude-opus-5, contexto de 1M, saída máxima de 128k e corte de conhecimento em maio de 2026 — comece por o que é o Claude Opus 5. A fonte primária das alegações é o post de lançamento do Claude Opus 5 da Anthropic.

Todas as alegações publicadas em uma tabela

A tabela abaixo consolida as alegações de benchmark divulgadas no lançamento. Observe especialmente a coluna Declarado como: uma proporção ou posição relativa normalmente fornece menos informação do que uma pontuação absoluta.

Benchmark	Alegação da Anthropic	Declarado como	Comparado com
Frontier-Bench v0.1	Supera todos os outros modelos; mais que o dobro da pontuação do Opus 4.8, a um custo menor por tarefa	Proporção + custo	Opus 4.8 e outros modelos
ARC-AGI 3	Aproximadamente 3x a pontuação do próximo melhor modelo	Proporção	Próximo melhor modelo não nomeado
OSWorld 2.0	Supera o Fable 5 a um terço do custo	Posição + custo	Fable 5
CursorBench 3.2	Dentro de 0.5% do pico do Fable 5, pela metade do preço	Lacuna + custo	Fable 5
Zapier AutomationBench	Taxa de aprovação aproximadamente 1.5x a do próximo melhor modelo	Proporção	Próximo melhor modelo não nomeado
Química orgânica	+10.2 pontos sobre o Opus 4.8	Delta absoluto	Opus 4.8
Análise de proteínas	+7.7 pontos sobre o Opus 4.8	Delta absoluto	Opus 4.8
Exploração de segurança cibernética	Atrás do Mythos 5	Posição	Mythos 5
Pesquisa biológica autônoma	Atrás do Mythos 5	Posição	Mythos 5

A fonte dessas declarações é o post de lançamento e a documentação da Anthropic. No momento da escrita, nenhuma terceira parte publicou uma reprodução independente desses resultados.

Antes de analisar cada benchmark, há dois sinais importantes:

Apenas duas das nove alegações apresentam variação absoluta em pontos.
A própria Anthropic informa os cenários nos quais o Opus 5 fica atrás de outro modelo.

Como interpretar alegações em proporção

Quatro alegações — Frontier-Bench, ARC-AGI 3, AutomationBench e parcialmente CursorBench — são apresentadas como proporções ou lacunas. Isso limita o que você consegue concluir.

1. Uma proporção esconde o denominador

No ARC-AGI 3, “aproximadamente 3x a pontuação do próximo melhor modelo” pode representar situações muito diferentes:

Se o concorrente marcou 8%, 3x equivale a 24%.
Se o concorrente marcou 25%, 3x equivale a 75%.

As duas afirmações podem ser descritas como “3x melhor”, mas têm impactos práticos completamente distintos. Sem a pontuação de base, não é possível avaliar a magnitude absoluta do avanço.

2. Dobrar uma pontuação é mais fácil em escalas baixas

A afirmação de que o Opus 5 obteve “mais que o dobro” do Opus 4.8 no Frontier-Bench v0.1 também exige contexto.

Se o Opus 4.8 estava em uma faixa de um dígito, dobrar a pontuação pode ser um avanço absoluto moderado. Se já estivesse perto de 40%, dobrar seria um salto extraordinário. Como se trata da versão v0.1 de um benchmark sem histórico público consolidado, ainda não há uma referência de saturação ou reproduções da comunidade.

3. “Próximo melhor modelo” não identifica o baseline

Nas alegações para ARC-AGI 3 e AutomationBench, o concorrente não é nomeado. Pode ser Fable 5, Mythos 5 ou outro modelo.

Sem saber qual foi o modelo de comparação, você não consegue responder perguntas essenciais:

O Opus 5 superou o modelo mais forte disponível?
A comparação usou a mesma configuração?
O concorrente teve acesso às mesmas ferramentas?
O resultado foi obtido com o mesmo orçamento de tokens?

4. Lacunas precisam de unidade e configuração

No CursorBench 3.2, “dentro de 0.5% do pico do Fable 5” deixa duas ambiguidades:

0.5% significa 0.5 ponto percentual ou 0.5% relativo?
“Pico” representa uma execução padrão ou uma configuração maximizada?

Em benchmarks de código, parâmetros como esforço, orçamento de tokens e número de tentativas podem mudar bastante o resultado. A análise dos benchmarks do Fable 5 mostra por que a configuração importa tanto quanto a pontuação.

As alegações científicas são mais fáceis de interpretar:

+10.2 pontos em química orgânica;
+7.7 pontos em análise de proteínas.

São deltas absolutos contra um baseline nomeado: o Opus 4.8. Ainda faltam as pontuações iniciais, mas pelo menos o tamanho do avanço está explicitamente definido.

Alegações de custo por tarefa dependem da configuração

Três resultados combinam capacidade e custo:

menor custo por tarefa no Frontier-Bench;
um terço do custo no OSWorld 2.0;
metade do preço no CursorBench 3.2.

O preço de tabela é simples de verificar. Segundo a página de preços da Anthropic, o Opus 5 custa:

Tipo de token	Preço por milhão
Entrada	US$ 5
Saída	US$ 25

Isso é igual ao Opus 4.8 e corresponde à metade dos US$ 10/US$ 50 atribuídos ao Fable 5. Para detalhes sobre cache, processamento em lote e modo rápido, consulte a análise de preços do Opus 5.

Mas custo por tarefa resolvida não é igual ao preço por token.

Ele depende de fatores como:

tokens de entrada e saída;
leituras e gravações de cache;
nível de effort;
uso de pensamento;
número de turnos no loop agêntico;
quantidade de subagentes;
quantidade de chamadas de ferramentas;
número de tentativas até a tarefa passar.

A orientação de prompt da Anthropic indica que o Opus 5 pode gerar respostas padrão mais longas, delegar mais para subagentes e expandir o escopo das tarefas com maior frequência. Todos esses fatores podem elevar o consumo em produção.

A conclusão prática é direta: preço de tabela é uma informação útil, mas não substitui a medição do seu custo por tarefa concluída. A comparação Opus 5 vs Fable 5 detalha onde a diferença de preço pode compensar.

O teto que a Anthropic declara

A parte mais útil do material de lançamento é uma que não representa vitória: a Anthropic afirma que o Opus 5 ainda fica atrás do Mythos 5 em:

exploração de segurança cibernética;
pesquisa biológica autônoma.

O Fable 5 também mantém a designação de “modelo amplamente lançado mais capaz”.

Portanto, o resumo correto não é “Opus 5 é o melhor modelo da Anthropic”. É:

O Opus 5 oferece capacidade de classe de fronteira por um preço de tabela menor, mas há um teto nomeado acima dele para segurança de fronteira e pesquisa científica autônoma.

Para esses casos, consulte o explicador de modelo de classe Mythos e a comparação Fable 5 vs Mythos 5.

Há também uma consequência operacional. A Anthropic disponibilizou fallbacks: "default" por trás do cabeçalho beta server-side-fallback-2026-07-01, que faz fallback automático para o Opus 4.8 quando o Opus 5 recusa solicitações relacionadas a categorias cibernéticas.

Se sua aplicação processa esse tipo de carga, trate o fallback como requisito de arquitetura e teste-o explicitamente.

O que benchmarks não medem

Benchmarks normalmente avaliam conclusão de tarefa. Eles não avaliam vários fatores que afetam diretamente uma integração de produção.

Variação de comportamento na migração

O Opus 5 verifica o próprio trabalho sem ser solicitado. Se seus prompts herdados do Opus 4.8 incluem instruções como “verifique sua resposta antes de responder”, você pode induzir verificações redundantes e aumentar o uso de tokens.

O guia de prompt da Anthropic para Opus 5 recomenda remover esse tipo de instrução redundante.

Comprimento da saída

As respostas e os entregáveis escritos podem ser maiores do que no Opus 4.8. Reduzir effort reduz tokens de raciocínio, mas não garante uma resposta visível mais curta.

Se a sua UI, API ou pipeline exige respostas compactas, declare isso no prompt:

Responda em no máximo 5 bullets.
Não repita o contexto.
Forneça somente o patch e uma explicação de até 2 frases.

Falhas quando o pensamento está desabilitado

Com:

{
  "thinking": {
    "type": "disabled"
  }
}

podem ocorrer comportamentos que benchmarks não mostram, como:

chamadas de ferramenta aparecendo como texto simples;
chamadas não executadas contaminando turnos posteriores de um loop agêntico;
tags XML internas vazando para a saída visível.

Teste esses casos com suas ferramentas reais conectadas.

Recalibração de esforço

Os níveis de esforço foram recalibrados no Opus 5. Não copie automaticamente os parâmetros usados no Opus 4.8.

Faça uma nova varredura entre:

low
medium
high
xhigh

O guia do parâmetro de esforço detalha essa configuração.

Erro 400 em combinações inválidas

A combinação abaixo retorna erro 400 por solicitação:

{
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "xhigh"
  }
}

O mesmo vale para effort: "max" quando usado com pensamento desabilitado. Esse é um detalhe de migração, tratado no guia de migração do Opus 4.8 para o Opus 5.

O que testar no seu ambiente

Use benchmarks de fornecedor como hipótese inicial, não como critério final. Você pode executar a avaliação abaixo em uma tarde.

1. Monte um conjunto de tarefas reais

Selecione entre 20 e 50 tarefas do seu histórico:

tickets fechados;
pull requests mesclados;
incidentes resolvidos;
conversas de suporte;
bugs reproduzíveis;
tarefas de automação.

Evite depender apenas de prompts sintéticos. Dados reais carregam ambiguidade, formatação inconsistente e casos extremos que aparecem em produção.

2. Fixe a configuração

Registre todos os parâmetros usados:

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "output_config": {
    "effort": "medium"
  },
  "thinking": {
    "type": "enabled"
  }
}

Você precisa controlar pelo menos:

ID exato do modelo;
output_config.effort;
configuração de pensamento;
max_tokens;
ferramentas disponíveis;
prompt de sistema;
número máximo de turnos;
regra de aceitação.

Sem isso, comparações posteriores não serão confiáveis.

3. Meça custo por tarefa resolvida

Não compare apenas custo por token. Compare:

custo por tarefa resolvida =
gasto total / número de tarefas aprovadas

Para cada execução, registre os campos do bloco usage:

{
  "usage": {
    "input_tokens": 0,
    "output_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0
  }
}

Depois, associe o custo ao resultado da validação da tarefa.

Uma planilha simples já é suficiente:

Tarefa	Modelo	Effort	Aprovada	Tokens de entrada	Tokens de saída	Cache	Custo estimado
Corrigir teste	Opus 5	medium	Sim	...	...	...	...
Corrigir teste	Opus 4.8	medium	Sim	...	...	...	...

4. Execute uma varredura de esforço

Execute exatamente as mesmas tarefas usando:

low
medium
high
xhigh

Mantenha todo o resto fixo. Compare:

taxa de aprovação;
custo;
latência;
número de turnos;
número de chamadas de ferramenta;
tamanho da saída;
taxa de recusa.

O objetivo não é encontrar o maior score. É encontrar o menor nível de esforço que passa com consistência aceitável para sua carga de trabalho.

5. Teste loops agênticos, não só prompts únicos

OSWorld, CursorBench e AutomationBench são avaliações agênticas. Um único prompt não reproduz esse tipo de cenário.

Teste fluxos completos:

o modelo recebe uma tarefa;
consulta uma ferramenta;
interpreta o resultado;
chama outra ferramenta;
executa uma alteração;
valida o resultado;
responde com um resumo.

Registre o número de turnos e a taxa de sucesso por execução. Não avalie apenas a melhor tentativa.

6. Compare com seu modelo atual

Execute o mesmo harness com o modelo que você usa hoje, como Opus 4.8, Sonnet 5 ou outro.

A comparação relevante é:

Opus 5 no seu backlog
vs.
modelo atual no mesmo backlog

Esse resultado será mais útil para uma decisão de migração do que uma pontuação em um dataset externo.

7. Registre recusas separadamente

Se você processa tarefas ligadas a segurança cibernética, conte recusas como uma categoria própria:

Tarefa	Modelo	Resultado	Recusa	Fallback acionado
Análise de log	Opus 5	Não concluída	Sim	Sim
Análise de log	Opus 4.8	Concluída	Não	Não

Isso permite decidir se o fallback deve ser configurado e qual impacto ele terá em custo, comportamento e rastreabilidade.

Para uma metodologia semelhante, veja o artigo sobre os benchmarks do Sonnet 5. Para os formatos de requisição, consulte o guia da API do Opus 5.

Executando a avaliação no Apidog

A avaliação é composta por requisições HTTP, headers de autenticação, payloads JSON, respostas em streaming e leitura do bloco usage. Esse é exatamente o tipo de fluxo que o Apidog ajuda a organizar e repetir.

Use esta configuração:

Crie uma requisição para o endpoint Messages da Anthropic.
Armazene a chave em uma variável de ambiente, nunca diretamente no body.
Duplique a requisição para cada nível de effort.
Mantenha o prompt, as ferramentas e max_tokens fixos.
Habilite streaming quando precisar inspecionar eventos SSE.
Adicione asserções para registrar os campos de usage.
Salve tudo em uma collection para reutilizar no próximo lançamento de modelo.

Requisição base:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 8192,
    "output_config": {
      "effort": "medium"
    },
    "messages": [
      {
        "role": "user",
        "content": "Fix the failing test in this diff."
      }
    ]
  }'

Em cada execução, altere apenas um campo. Por exemplo, para comparar esforço:

{
  "output_config": {
    "effort": "low"
  }
}

Depois:

{
  "output_config": {
    "effort": "medium"
  }
}

E então:

{
  "output_config": {
    "effort": "high"
  }
}

Para validar o formato de uso, adicione uma asserção que confirme a presença de tokens na resposta:

pm.test("A resposta contém usage", function () {
  const body = pm.response.json();

  pm.expect(body).to.have.property("usage");
  pm.expect(body.usage).to.have.property("input_tokens");
  pm.expect(body.usage).to.have.property("output_tokens");
});

Em fluxos com ferramentas, valide também se o modelo emitiu uma chamada estruturada, em vez de descrevê-la em texto:

pm.test("A resposta contém conteúdo estruturado", function () {
  const body = pm.response.json();

  pm.expect(body).to.have.property("content");
  pm.expect(body.content).to.be.an("array");
});

Baixe o Apidog para montar esse harness com ambientes, collections e asserções reutilizáveis.

Resumo honesto

A história de benchmark do Opus 5 é forte: a Anthropic afirma um salto relevante sobre o Opus 4.8 mantendo o mesmo preço de tabela.

Mas os resultados:

são publicados pelo próprio fornecedor;
não tinham reprodução independente até 25 de julho de 2026;
são apresentados principalmente como proporções;
não revelam todos os denominadores, configurações e baselines;
não substituem testes de comportamento, custo e falhas no seu ambiente.

Trate a tabela como a hipótese da Anthropic sobre o modelo. Em seguida, execute o mesmo tipo de avaliação nas tarefas que definem sua operação. A decisão de migração acontece na diferença entre o gráfico de lançamento e sua carga de trabalho real.

Para o restante das mudanças do modelo, consulte o guia principal do Opus 5.

FAQ

Os benchmarks do Claude Opus 5 são verificados independentemente?

Não. Em 25 de julho de 2026, todos os resultados de benchmark publicados do Opus 5 vinham da Anthropic. Nenhum laboratório de terceiros ou avaliador independente havia divulgado uma reprodução.

Qual é a maior alegação de benchmark do Opus 5?

É o Frontier-Bench v0.1. A Anthropic afirma que o Opus 5 mais que dobra a pontuação do Opus 4.8 com menor custo por tarefa. As pontuações subjacentes não foram publicadas, apenas a proporção.

O Claude Opus 5 é o modelo Claude mais capaz?

Não. O Fable 5 mantém a designação de modelo amplamente lançado mais capaz, e a Anthropic declara que o Opus 5 fica atrás do Mythos 5 em exploração de segurança cibernética e pesquisa biológica autônoma.

Quanto melhor é o Opus 5 em tarefas científicas?

A Anthropic relata +10.2 pontos em química orgânica e +7.7 pontos em análise de proteínas contra o Opus 4.8. Essas são as alegações mais fáceis de interpretar porque usam deltas absolutos.

O Opus 5 vence o Fable 5?

Segundo os números da Anthropic, o Opus 5 supera o Fable 5 no OSWorld 2.0 a um terço do custo e fica dentro de 0.5% do pico do Fable 5 no CursorBench 3.2 pela metade do preço. O Fable 5 ainda mantém a designação de capacidade geral. Veja a comparação completa.

O que devo testar por conta própria?

Teste custo por tarefa resolvida em 20 a 50 tarefas reais do seu backlog, usando múltiplos níveis de esforço, ferramentas reais, loops multi-turn e o mesmo harness para o Opus 5 e seu modelo atual.

Parâmetro de Esforço do Claude Opus 5: Trocando Custo por Capacidade

Lucas — Sat, 25 Jul 2026 03:20:28 +0000

Todo artigo principal sobre o lançamento do Claude Opus 5 em 24 de julho de 2026 destacou a mesma funcionalidade: uma forma de alternar entre custo e capacidade. Mas poucos explicaram o que ela controla, quais níveis existem, como afeta a requisição ou o impacto na conta.

Experimente o Apidog hoje

Essa funcionalidade é o parâmetro effort. No Opus 5, ele tem cinco níveis e o padrão é high. A Anthropic recalibrou esses níveis para o modelo, então configurações ajustadas no Opus 4.8 não devem ser reutilizadas sem avaliação. Além disso, uma combinação específica de parâmetros gera erro 400 durante migrações.

💡 Para comparar os cinco níveis contra um endpoint real, envie a mesma requisição com valores diferentes de effort e registre custo, latência e qualidade da resposta.

O que o parâmetro `effort` realmente faz

O effort fica dentro de output_config em uma requisição para a API de Mensagens:

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "output_config": {
    "effort": "high"
  },
  "messages": [
    {
      "role": "user",
      "content": "Refatorar este módulo e explicar os trade-offs."
    }
  ]
}

Ele controla quanto raciocínio interno o modelo executa antes de responder.

No Opus 5, o pensamento adaptativo está ativado por padrão. O valor de effort define o orçamento usado nesse raciocínio:

effort mais alto: mais tokens de raciocínio, maior custo e maior latência.
effort mais baixo: menos tokens de raciocínio, menor custo e menor latência.

Nas interfaces de consumidor, a mesma opção pode aparecer como um seletor entre custo e capacidade. Na API, o controle efetivo é o campo output_config.effort.

Consulte o formato completo da requisição no guia da API do Opus 5 e a documentação da Anthropic na visão geral de modelos.

`effort` não controla verbosidade

effort não é um controle de tamanho da resposta.

Segundo o guia de prompting da Anthropic para o Opus 5, reduzir o effort diminui o raciocínio interno, não o comprimento do texto visível.

Se você precisa de respostas curtas, inclua essa restrição no prompt:

Responda em no máximo 5 bullets. Não inclua introdução, justificativas longas ou exemplos adicionais.

Não espere que usar low reduza automaticamente a saída textual.

Os cinco níveis de `effort`

Nível	O que faz	Aplicação típica
`low`	Raciocínio mínimo antes de responder	Classificação de alto volume, extração, roteamento e resumos curtos
`medium`	Raciocínio moderado	Perguntas e respostas sobre contexto recuperado, edições de arquivo único e transformações estruturadas
`high`	Padrão. Raciocínio substancial	Trabalho de propósito geral quando você ainda não mediu resultados
`xhigh`	Raciocínio estendido	Codificação e loops agênticos; ponto de partida recomendado pela Anthropic
`max`	Orçamento máximo de raciocínio	Problemas difíceis de uma única tentativa, quando errar custa mais que os tokens

Dois detalhes são especialmente importantes:

O padrão é high.

Se você não enviar output_config, a requisição usa high. Isso afeta previsões de custo: uma requisição sem configuração explícita no Opus 5 realiza trabalho de raciocínio e cobra por ele.
Para código e agentes, comece em xhigh, não em max.

A Anthropic posiciona xhigh como ponto de partida para essas cargas. Use max apenas quando suas avaliações mostrarem ganho mensurável que justifique o custo adicional.

A mudança do comportamento padrão é uma das alterações relevantes na migração do Opus 4.8 para o Opus 5.

Por que você precisa recalibrar suas configurações

O rótulo de cada nível não representa necessariamente o mesmo orçamento entre modelos.

No Opus 5, medium não corresponde à mesma quantidade de raciocínio que medium no Opus 4.8. A recomendação da Anthropic é executar uma nova varredura de effort em vez de migrar a configuração anterior diretamente.

Na prática, isso pode abrir espaço para redução de custo:

Em modelos Opus anteriores, low e medium frequentemente apresentavam queda perceptível de qualidade em tarefas complexas.
No Opus 5, os níveis inferiores são mais fortes do que eram anteriormente.
Isso torna low e medium opções viáveis para tarefas de produção que não precisam de raciocínio extenso.

O Opus 5 custa US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída, os mesmos valores do Opus 4.8. Tokens de raciocínio entram na cobrança de saída.

Por isso, usar high em um pipeline de classificação onde low já atende aos critérios pode aumentar significativamente o gasto sem melhorar a precisão.

Veja a tabela completa de preços no detalhamento de preços do Opus 5, incluindo desconto de 50% para lote e o mínimo de cache de 512 tokens.

Para otimizações adicionais, consulte como cortar sua conta da API Claude.

Como `xhigh` e `max` interagem com `max_tokens`

max_tokens limita os tokens de raciocínio e os tokens da resposta visível.

Em outras palavras, ele é um teto para toda a saída gerada pela requisição:

tokens de raciocínio + tokens de resposta <= max_tokens

Ao aumentar o effort, o modelo pode gastar mais do orçamento em raciocínio antes de começar a gerar a resposta. Se max_tokens estiver dimensionado para um modelo sem esse comportamento, a resposta pode ser truncada.

Exemplo recomendado para xhigh:

{
  "model": "claude-opus-5",
  "max_tokens": 64000,
  "output_config": {
    "effort": "xhigh"
  },
  "messages": [
    {
      "role": "user",
      "content": "Corrigir o teste de integração com falha e explicar a causa raiz."
    }
  ]
}

A orientação da Anthropic é começar com max_tokens: 64000 ao usar xhigh ou max.

Um valor alto de max_tokens é um teto, não uma compra antecipada. Você é cobrado pelos tokens realmente produzidos. Portanto, definir 64000 não significa pagar por 64000; significa evitar que o modelo interrompa o raciocínio ou a resposta cedo demais.

O erro 400 ao combinar `thinking` desativado com `xhigh` ou `max`

Há uma combinação inválida que deve ser verificada durante a migração.

Desabilitar o pensamento e solicitar um effort alto são instruções contraditórias. Esta requisição falha:

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "xhigh"
  }
}

O Opus 5 retorna 400 quando thinking: { "type": "disabled" } é usado com effort: "xhigh" ou effort: "max".

As combinações válidas são:

Pensamento ativado, que é o padrão, com qualquer um dos cinco níveis.
Pensamento desativado com low, medium ou high.

Um caminho comum para esse erro é:

Migrar thinking: { "type": "disabled" } de uma configuração do Opus 4.8.
Alterar o effort para xhigh, seguindo a recomendação para codificação.
Receber um 400 porque os dois ajustes são incompatíveis.

A recomendação da Anthropic é não desabilitar o pensamento no Opus 5. Com ele desativado, dois problemas podem aparecer:

chamadas de ferramentas podem ser emitidas como texto simples em vez de serem executadas;
tags XML internas podem vazar na saída visível.

Em loops agênticos, esse texto vazado pode contaminar interações posteriores. Para controlar custo, prefira reduzir effort em vez de desabilitar o pensamento.

Veja mais detalhes no guia de prompt do Opus 5.

Como executar uma varredura de `effort` nas suas avaliações

A forma prática de escolher um nível é avaliar sua carga de trabalho real.

1. Monte um conjunto de tarefas reais

Separe de 30 a 50 prompts dos logs de produção. Evite exemplos exclusivamente sintéticos.

Inclua casos difíceis, falhas conhecidas e tarefas com impacto real. Diferenças entre níveis de effort tendem a desaparecer em tarefas simples.

2. Defina o critério de aprovação antes de avaliar

Defina métricas objetivas antes de ler as saídas. Por exemplo:

testes automatizados aprovados;
JSON válido contra um schema;
campo extraído igual ao valor esperado;
resposta aprovada ou reprovada por avaliador humano.

Evite critérios vagos como “parece melhor”.

3. Execute cada prompt em cada nível

Com 40 prompts e 5 níveis, você terá 200 chamadas:

40 prompts × 5 níveis = 200 execuções

Como essa avaliação não é sensível à latência, você pode usar a API Batch para reduzir o custo.

4. Registre qualidade, custo e latência

Para cada execução, capture pelo menos:

aprovação ou reprovação;
usage.output_tokens;
latência total.

O campo usage é importante porque mostra o consumo real de tokens de saída, incluindo os tokens de raciocínio.

Um registro simples pode ter este formato:

{
  "prompt_id": "integration-test-17",
  "effort": "medium",
  "passed": true,
  "output_tokens": 1842,
  "latency_ms": 3280
}

5. Escolha o nível mais barato que atende ao critério

Compare a taxa de aprovação com custo e latência. Escolha o nível mais barato que atinge seus requisitos e valide a decisão em um conjunto separado, que não foi usado para ajustar a configuração.

6. Repita a avaliação ao trocar de modelo

A razão para executar essa varredura é justamente a recalibração entre Opus 4.8 e Opus 5. Não assuma que os rótulos terão o mesmo comportamento no próximo modelo.

Comparando níveis lado a lado no Apidog

A parte mecânica da varredura consiste em enviar o mesmo corpo de requisição cinco vezes, alterando apenas output_config.effort.

Uma configuração prática no Apidog:

Crie uma requisição para o endpoint Anthropic Messages.
Armazene a chave da API em uma variável de ambiente, sem colocá-la diretamente no body.
Salve a requisição em uma coleção.
Duplique-a cinco vezes.
Altere apenas o valor de output_config.effort em cada cópia.
Compare usage.output_tokens, latência e resultado funcional.
Verifique cache_read_input_tokens quando estiver validando o cache.
Ative streaming e inspecione eventos SSE para observar a diferença de latência entre low e xhigh.
Adicione uma asserção para garantir que stop_reason exista e não seja max_tokens.

A última verificação evita que uma resposta truncada pareça uma resposta curta válida.

Exemplo de condição que sua coleção deve verificar:

stop_reason existe AND stop_reason != "max_tokens"

Se a requisição terminar com stop_reason: "max_tokens", aumente max_tokens antes de concluir que aquele nível de effort teve desempenho ruim.

Você pode baixar o Apidog para montar essa coleção. Não é obrigatório: o mesmo processo pode ser automatizado com scripts, mas uma coleção facilita comparar as cinco variações.

O limite de capacidade do Opus 5

effort pode tornar o Opus 5 mais eficiente para rodar bem, mas não altera a posição do modelo na linha Claude.

Os números de lançamento divulgados pela Anthropic para o Opus 5 incluem:

mais que o dobro da pontuação do Opus 4.8 no Frontier-Bench v0.1;
aproximadamente 3x o próximo melhor modelo no ARC-AGI 3;
distância de 0,5% do Fable 5 no CursorBench 3.2 pela metade do preço.

Esses números foram publicados pela Anthropic e não haviam sido reproduzidos independentemente até 25 de julho de 2026. Trate-os como afirmações do fornecedor, não como medições neutras.

Consulte o detalhamento de benchmarks do Opus 5 para as ressalvas de cada benchmark.

Acima do Opus 5, o Fable 5 continua sendo o modelo mais capaz amplamente lançado da Anthropic, a US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída.

O Opus 5 também fica atrás do Mythos 5 em exploração de segurança cibernética e pesquisa biológica autônoma, conforme declarado pela Anthropic.

Usar effort: "max" não elimina essas diferenças de capacidade. O ganho prático está em encontrar o menor nível que atende às exigências da sua carga de trabalho.

Para comparar custo e capacidade entre os modelos, veja Opus 5 vs Fable 5.

FAQ

Qual é o nível de `effort` padrão no Claude Opus 5?

high.

Uma requisição sem output_config usa effort: "high" com pensamento adaptativo ativado.

Quais são os cinco níveis de `effort`?

low, medium, high, xhigh e max.

A Anthropic recomenda começar em xhigh para codificação e trabalho agêntico e, então, avaliar níveis menores com sua própria suíte de testes.

Por que minha requisição retorna erro 400 com `effort: "xhigh"`?

Provavelmente porque você também enviou:

{
  "thinking": {
    "type": "disabled"
  }
}

Com pensamento desativado, o effort fica limitado a high. Remova a desativação do pensamento ou reduza o nível para high, medium ou low.

Posso reutilizar minhas configurações de `effort` do Opus 4.8 no Opus 5?

Não.

Os níveis foram recalibrados, então o mesmo rótulo representa uma quantidade diferente de raciocínio. Execute uma nova varredura de avaliação antes de definir a configuração de produção.

Consulte o guia de migração para a lista completa de mudanças.

Diminuir o `effort` deixa as respostas mais curtas?

Não.

effort controla o raciocínio interno, não o tamanho visível da resposta. Se você precisa de uma resposta curta, solicite explicitamente concisão no prompt.

Qual valor de `max_tokens` devo usar com `xhigh` ou `max`?

Comece com 64000.

max_tokens limita o raciocínio e a resposta juntos. Um teto baixo pode truncar a saída. Você só paga pelos tokens realmente produzidos, então um teto alto não gera custo por si só.

Para especificações, disponibilidade e preços, comece por o que é o Claude Opus 5.

Claude Opus 5 vs Fable 5: Vale a Pena Metade do Preço?

Lucas — Sat, 25 Jul 2026 03:19:36 +0000

A Anthropic lançou o Claude Opus 5 em 24 de julho de 2026, e a pergunta que todas as equipes fizeram em uma hora foi a mesma: se o Opus 5 se aproxima do Fable 5 pela metade do preço, por que alguém continuaria pagando pelo Fable 5?

Experimente o Apidog hoje

Os números são simples. O Opus 5 custa US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída. O Fable 5 custa US$ 10 e US$ 50: uma diferença exata de 2x em ambos os lados, sem letras miúdas sobre níveis ou mínimos. As próprias declarações de lançamento da Anthropic afirmam que o Opus 5 atinge 0,5% do pico do Fable 5 no CursorBench 3.2 e supera o Fable 5 no OSWorld 2.0 com um terço do custo.

Se você quiser fazer a comparação por conta própria, pode enviar o mesmo prompt para ambos os IDs de modelo a partir do Apidog e comparar as respostas e as contagens de tokens lado a lado.

Os dois modelos em um relance

	Claude Opus 5	Claude Fable 5
ID do modelo de API	`claude-opus-5`	`claude-fable-5`
Preço de entrada	US$5 / MTok	US$10 / MTok
Preço de saída	US$25 / MTok	US$50 / MTok
Janela de contexto	1M tokens (padrão e máximo)	1M tokens
Saída máxima	128k (300k em Lote com um cabeçalho beta)	128k
Corte de conhecimento	Maio de 2026	Janeiro de 2026
Posicionamento	Padrão recomendado pela Anthropic	Modelo mais capaz amplamente lançado
Raciocínio	Adaptativo, ativado por padrão, controlável via esforço	Sempre ativo
Lançado	24 de julho de 2026	Início de junho de 2026

Duas linhas merecem uma segunda olhada antes de qualquer outra coisa.

A linha de corte contraria a história usual de “o nível mais novo é mais barato, o nível mais antigo é mais inteligente”. O Opus 5 tem conhecimento do mundo até maio de 2026. O Fable 5 para em janeiro de 2026, o mesmo corte que o Sonnet 5. Quatro meses de lançamentos de pacotes, versões de frameworks e alterações de API estão dentro dos dados de treinamento do Opus 5 e fora dos do Fable 5. Se o seu trabalho envolve bibliotecas de rápida evolução, o modelo mais barato é também o mais atualizado.

A linha de posicionamento aponta para a direção oposta. A Anthropic ainda descreve o Fable 5 como seu modelo mais capaz amplamente lançado, e não transferiu essa designação para o Opus 5. O Opus 5 é o padrão recomendado, o que é uma afirmação diferente: é o que você deve buscar quando estiver em dúvida, não o que você deve buscar quando a tarefa está no limite do que qualquer modelo pode fazer.

Para a ficha técnica completa do modelo mais recente, consulte nosso explicador do Claude Opus 5. Para os detalhes de lançamento do Fable 5, consulte o que é o Claude Fable 5.

O que a Anthropic realmente afirma

Aqui estão as afirmações de lançamento que se referem a esta comparação, declaradas como a Anthropic as declara.

Benchmark	Afirmação da Anthropic para o Opus 5
CursorBench 3.2	Dentro de 0,5% do pico do Fable 5, pela metade do preço
OSWorld 2.0 (uso de computador)	Supera o Fable 5 com um terço do custo
Frontier-Bench v0.1	Supera todos os outros modelos; mais que o dobro da pontuação do Opus 4.8
ARC-AGI 3	Aproximadamente 3x o próximo melhor modelo
Zapier AutomationBench	Taxa de aprovação aproximadamente 1,5x o próximo melhor modelo
Química orgânica	+10,2 pontos acima do Opus 4.8
Análise de proteínas	+7,7 pontos acima do Opus 4.8

Agora, a ressalva, porque é o ponto crucial. Cada um desses números é executado pelo fornecedor. A Anthropic projetou a configuração de avaliação, escolheu as configurações de esforço e publicou os resultados. Em 25 de julho de 2026, nenhum foi reproduzido independentemente. Isso não é uma acusação de má-fé; é o estado normal de um lançamento no segundo dia. Mas “dentro de 0,5% do Fable 5” descreve um conjunto de testes específico em uma configuração específica, e a diferença que você mede em suas próprias tarefas pode ser maior ou menor.

A afirmação sobre o OSWorld é a mais interessante dos dois números de comparação direta, porque é aquela em que o Opus 5 supera o Fable 5, em vez de apenas se aproximar. Tarefas de uso de computador recompensam persistência e recuperação em vez de profundidade de raciocínio bruta, o que se encaixa em um modelo ajustado para loops de agência. A afirmação sobre o CursorBench é mais suave: “dentro de 0,5% do pico do Fable 5” significa que o Fable 5 ainda detém o pico.

Nós detalhamos cada número, incluindo o que cada benchmark mede e não mede, na análise aprofundada dos benchmarks do Opus 5. Os próprios números de lançamento do Fable 5 estão na postagem sobre os benchmarks do Fable 5.

O argumento para o Opus 5

A diferença de preço é constante e se acumula. A US$5/US$25 contra US$10/US$50, uma carga de trabalho que custa US$3.000 por mês no Fable 5 custa US$1.500 no Opus 5 para um volume idêntico de tokens. Nenhum limite ou compromisso a reduz.

Os fatores de custo se somam à redução pela metade. A taxa da API em lote do Opus 5 é de US$2,50/US$12,50, um desconto adicional de 50%. Acertos e atualizações de cache custam US$0,50 por milhão, e o mínimo de cache de prompts caiu para 512 tokens (de 1.024 no Opus 4.8), então prompts de sistema curtos que antes eram muito pequenos para serem armazenados em cache agora são armazenados sem alteração de código.

A sobrecarga do prompt de sistema para uso de ferramentas também é menor: 286 tokens com tool_choice definido como auto ou none, contra 290 no Opus 4.8 e 675 no Opus 4.7. Juntos, estes fatores impactam significativamente a conta. Nosso detalhamento de preços do Opus 5 tem a tabela completa, e o guia sobre corte da sua conta da API do Claude aborda os fatores gerais.

Você pode gastar mais quando a tarefa merece. O parâmetro output_config.effort do Opus 5 assume high como padrão e os níveis foram recalibrados no lançamento, com low e medium significativamente mais fortes do que nos modelos Opus anteriores. Isso lhe dá um controle ajustável em vez de uma taxa fixa: classificação barata em low, codificação agêntica complexa em xhigh. O guia do parâmetro de esforço explica o ajuste a ser executado em vez de manter as configurações antigas.

É o modelo mais atualizado, por quatro meses.

É para onde os padrões estão indo. O Opus 5 é o novo padrão para assinantes Max e o modelo de maior desempenho disponível para usuários Pro, e ele está disponível na API do Claude, claude.ai, Claude Code, Claude Cowork, Amazon Bedrock, Claude Platform na AWS, Google Cloud, Microsoft Foundry e GitHub Copilot. A visão geral dos modelos da Anthropic afirma claramente que, se você não tiver certeza de qual modelo usar, comece com o Opus 5.

O argumento para o Fable 5

Defender o modelo mais caro é um trabalho mais difícil, então sejamos específicos em vez de polidos.

A designação de capacidade não mudou. A Anthropic poderia ter coroado o Opus 5 como seu modelo mais capaz amplamente lançado no dia do lançamento. Ela não o fez. Quando um fornecedor mantém um superlativo em um modelo mais antigo e mais caro enquanto lança um mais barato do qual se orgulha muito, isso é um sinal sobre o topo da curva de capacidade, não uma falha de marketing.

Nos problemas mais difíceis, aqueles em que uma única execução falha custa mais do que um mês de gastos com API, o Fable 5 ainda é o modelo que a Anthropic aponta. Seu anúncio de lançamento é a referência para esse posicionamento.

O raciocínio sempre ativo remove um modo de falha. O Fable 5 “pensa” em cada requisição: a comparação de modelos da Anthropic lista seu raciocínio adaptativo como “sempre ativo”, e é o único modelo atual descrito dessa forma.

O Opus 5 permite desabilitar o raciocínio, e a própria orientação de prompt da Anthropic documenta o que acontece quando você faz isso: chamadas de ferramentas ocasionalmente são escritas como texto simples em vez de serem executadas — e esse texto vazado então “envenena” as etapas posteriores em um loop de agência — e tags XML internas às vezes aparecem na saída visível. A mitigação recomendada pela Anthropic é manter o raciocínio ativado e controlar o custo com menos esforço. Um modelo que nunca lhe oferece essa “armadilha” não pode ser vítima dela.

A flexibilidade do Opus 5 tem arestas afiadas. Combinar thinking: {type: "disabled"} com esforço xhigh ou max retorna um erro 400, aplicado por requisição. O raciocínio agora é executado por padrão quando você omite o campo thinking, então orçamentos de max_tokens dimensionados para uma carga de trabalho sem raciocínio podem ser truncados.

O Opus 5 também delega mais prontamente a subagentes e produz respostas padrão mais longas, ambos os quais aumentam silenciosamente o custo se você não os restringir. O Fable 5 não apresenta nenhuma dessas superfícies de migração. Se você fizer a mudança, nosso guia de migração do Opus 4.8 para o Opus 5 contém todas as mudanças que podem quebrar a compatibilidade.

Os custos de troca não são zero. Suas avaliações, prompts, configurações de esforço e modelo de custo são calibrados em relação ao modelo que você usa hoje. “Metade do preço” é uma declaração por token, não uma declaração de custo de projeto. Se a migração levar duas semanas para dois engenheiros e a carga de trabalho for pequena, a aritmética não funciona.

A comparação Fable 5 vs Opus 4.8 aborda o que o nível Fable oferece em relação ao nível Opus em geral, e a precificação do Fable 5 cobre sua estrutura de custo.

Como a diferença de preço se parece em requisições reais

Multiplicadores são fáceis de aceitar, mas difíceis de sentir o impacto. Aqui está uma tarefa de codificação agêntica: 200.000 tokens de entrada — um grande contexto de repositório mais um longo histórico de chamadas de ferramentas — e 20.000 tokens de saída.

	Opus 5	Fable 5
Entrada (200k)	US$1.00	US$2.00
Saída (20k)	US$0.50	US$1.00
Por tarefa	US$1.50	US$3.00
500 tarefas/mês	US$750	US$1.500
5.000 tarefas/mês	US$7.500	US$15.000

Com 500 tarefas por mês, a diferença é de US$750. Isso está dentro do ruído da maioria dos orçamentos de engenharia, e se o Fable 5 economizar uma execução falha por mês para sua equipe, ele se paga. Com 5.000 tarefas por mês, a diferença é de US$90.000 por ano, o que é uma conversa sobre pessoal.

Portanto, a regra de decisão é sobre volume, não sobre qual modelo é mais inteligente. Abaixo de algumas centenas de tarefas difíceis por mês, escolha com base na capacidade e ignore o preço. Acima de alguns milhares, você precisa de evidências de que o Fable 5 é melhor em sua carga de trabalho, não no conjunto de testes da Anthropic.

Mais uma conta: o modo rápido do Opus 5 — velocidade de saída 2,5x, uma prévia de pesquisa apenas na API própria — tem o preço de US$10/US$50, exatamente a taxa base do Fable 5. Se a latência for a restrição em vez da capacidade, você pode gastar o dinheiro do Fable 5 em um Opus 5 mais rápido em vez de um Fable 5 mais lento.

Observe que inference_geo: "us" adiciona um multiplicador de 1,1x em todas as categorias de tokens no Opus 5, alterando esses números em 10%.

Um framework de decisão por carga de trabalho

Sua carga de trabalho	Escolha	Por quê
Codificação agêntica, alto volume	Opus 5	A Anthropic relata dentro de 0,5% no CursorBench pela metade do custo; o volume torna a diferença um dinheiro real
Uso de computador e automação de navegador	Opus 5	O único benchmark onde a Anthropic afirma que o Opus 5 supera o Fable 5 diretamente
Trabalho com bibliotecas pós-janeiro de 2026	Opus 5	Corte de maio de 2026 versus janeiro de 2026
Tráfego de produção sensível ao custo	Opus 5	Metade do preço, mais lote, mínimo de cache de 512 tokens e esforço `low`/`medium`
Execuções únicas de raciocínio de alto risco	Fable 5	Ainda o modelo mais capaz amplamente lançado da Anthropic; o custo por execução é irrelevante em baixo volume
Sessões autônomas de longo prazo onde uma falha no meio da execução é cara	Fable 5	Raciocínio sempre ativo, sem artefatos de raciocínio desativado, sem nova superfície de migração
Já estável no Fable 5, baixo volume	Fable 5	O custo de migração excede as economias
Exploração de segurança cibernética ou pesquisa de biologia autônoma	Nenhum dos dois, veja abaixo	Ambos ficam aquém do Mythos 5 nessas áreas

O padrão: Opus 5 ganha em economia de throughput, Fable 5 ganha em risco de cauda. Se você executa muitas tarefas e pode tolerar um resultado ocasionalmente mais fraco, reduzir sua conta pela metade é a jogada óbvia. Se você executa poucas tarefas e um único resultado ruim é caro, a diferença de preço não é o que você deveria estar otimizando.

Executando a comparação em sua própria carga de trabalho

Os benchmarks do fornecedor mostram o que aconteceu nas tarefas de outra pessoa. O número que decide isso para você vem do seu próprio conjunto de avaliação, e obtê-lo leva uma tarde. Ambos os modelos estão por trás do mesmo endpoint de Mensagens, então a comparação é uma mudança de uma única string:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 8192,
    "output_config": {"effort": "high"},
    "messages": [
      {"role": "user", "content": "Refactor this handler and explain the tradeoffs."}
    ]
  }'

Troque claude-opus-5 por claude-fable-5 e você terá o outro lado do teste. Uma configuração prática no Apidog se parece com isto:

Armazene a chave da API como uma variável de ambiente para que ela nunca esteja no corpo da requisição, e crie um ambiente por modelo com o ID do modelo como uma variável.
Salve a requisição em uma coleção e execute o mesmo cenário contra ambos os ambientes, de modo que a única coisa que mude seja a string do modelo.
Leia os campos usage em cada resposta. Compare os tokens de entrada, saída e leitura de cache; é aí que a verdadeira diferença de custo aparece, já que o Opus 5 tende a respostas padrão mais longas.
Inspecione o fluxo SSE e os payloads de chamadas de ferramentas ao comparar o comportamento agêntico. Se um modelo executou uma ferramenta ou escreveu a chamada como texto é visível no fluxo de eventos brutos.
Repita a execução do Opus 5 com esforço low, medium, high e xhigh. A verdadeira questão geralmente não é “Opus 5 ou Fable 5”, mas “qual nível de esforço no Opus 5 corresponde à saída do Fable 5 pela qual estou pagando”.

O quinto passo é o que a maioria das equipes pula e o que decide o dinheiro. Baixe o Apidog para configurar os ambientes, ou siga o passo a passo completo da requisição em nosso guia da API do Opus 5. A página de preços da Anthropic tem as taxas autoritativas para ambos os modelos.

O teto honesto

Nenhum dos modelos nesta comparação está no topo da pilha da Anthropic.

O Fable 5 continua sendo o modelo mais capaz amplamente lançado pela própria designação da Anthropic, e o Opus 5 não recebeu essa designação. E acima de ambos, em dois eixos específicos de capacidade, encontra-se o Mythos 5: a Anthropic afirma que o Opus 5 ainda fica atrás do Mythos 5 em exploração de segurança cibernética e pesquisa autônoma em biologia.

O Mythos 5 é o modelo irmão sem classificador, lançado para o Fable 5 junto com um programa limitado em vez de para o público em geral, então não é uma opção para a maioria das equipes; nossa comparação Fable 5 vs Mythos 5 aborda a elegibilidade.

O resumo preciso do Opus 5 é, portanto, mais restrito do que as manchetes: capacidade de classe de fronteira pela metade do preço de fronteira, com um teto nomeado acima dele. É um produto forte. Não é “o melhor modelo agora custa a metade”, e qualquer um que lhe vender essa versão está pulando a parte em que a própria Anthropic manteve a coroa de capacidade no modelo mais caro.

FAQ

O Claude Opus 5 é melhor que o Fable 5?

Nos próprios benchmarks da Anthropic, o Opus 5 supera o Fable 5 em tarefas de uso de computador no OSWorld 2.0 e atinge 0,5% do pico do Fable 5 no CursorBench 3.2, ambos por uma fração do custo. Esses números são executados pelo fornecedor e não foram reproduzidos de forma independente até 25 de julho de 2026. A Anthropic ainda designa o Fable 5 como seu modelo mais capaz amplamente lançado, então nas tarefas mais difíceis o Fable 5 mantém a vantagem.

Quanto mais barato é o Opus 5 que o Fable 5?

Exatamente a metade em ambos os lados: US$5/US$25 por milhão de tokens de entrada/saída versus US$10/US$50. A taxa da API em lote do Opus 5 de US$2,50/US$12,50 amplia ainda mais a diferença para trabalhos não urgentes.

Qual modelo tem o corte de conhecimento mais recente?

O Opus 5, por quatro meses. Seu corte confiável é maio de 2026; o do Fable 5 é janeiro de 2026.

Devo migrar minha carga de trabalho do Fable 5 para o Opus 5?

Primeiro, analise os números de volume. Abaixo de algumas centenas de tarefas difíceis por mês, a economia raramente justifica o trabalho de migração. Acima de alguns milhares, a migração é claramente vantajosa, desde que seu próprio conjunto de avaliação confirme que a qualidade é mantida.

Qual é o ID do modelo para cada um?

claude-opus-5 e claude-fable-5, ambos sem sufixo de data. No Amazon Bedrock, o Opus 5 é anthropic.claude-opus-5.

Há algo que o Opus 5 suporte e o Fable 5 não?

O Opus 5 expõe o parâmetro output_config.effort com níveis recalibrados, aceita mensagens de sistema no meio da conversa, suporta o modo rápido a US$10/US$50 e armazena prompts tão curtos quanto 512 tokens em cache. Uma lacuna na direção oposta: o Nível Prioritário não é suportado no Opus 5, embora o Opus 4.8 o mantenha.

A resposta curta

Metade do preço vale a pena para a maioria das equipes, e a razão é o volume, e não a capacidade. Os números da Anthropic colocam o Opus 5 perto o suficiente em codificação agêntica e à frente no uso de computador, de modo que a economia de 2x se transforma em orçamento real com milhares de tarefas por mês. Adicione o corte mais recente de maio de 2026 e o controle de esforço, e a resposta padrão é o Opus 5.

Mantenha o Fable 5 quando a tarefa estiver no limite do que qualquer modelo pode fazer, quando uma única execução falha custar mais do que a diferença de preço, ou quando seu volume for baixo o suficiente para que o trabalho de migração supere a economia. E trate cada benchmark aqui como o que ele é: uma medição própria do fornecedor, em um ambiente de teste próprio do fornecedor, esperando que alguém a reproduza. Seu conjunto de avaliação é o desempate.

Migrando do Claude Opus 4.8 para o Opus 5: Todas as Alterações Impactantes

Lucas — Sat, 25 Jul 2026 03:19:21 +0000

Trocar claude-opus-4-8 por claude-opus-5 parece uma alteração de uma linha — e, na maioria dos casos, é. Porém, alguns padrões mudaram, uma combinação antes válida agora retorna HTTP 400 e um recurso de capacidade empresarial não está disponível no novo modelo.

Experimente o Apidog hoje

A Anthropic lançou o Claude Opus 5 em 24 de julho de 2026 com o mesmo preço do Opus 4.8: US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída. Portanto, a migração tende a ser uma decisão de compatibilidade, não de orçamento.

Este guia mostra as mudanças que podem afetar integrações existentes, com requisições antes/depois para testar no cliente HTTP. A principal referência para a superfície da API é o guia de migração do Opus 4.8 para Opus 5 da Anthropic. Para validar cada variação contra o endpoint, salve e clone requisições no Apidog.

A versão curta

Mudança	Impacto	Ação
`thinking` ativado por padrão	Saída pode ser truncada silenciosamente	Aumente `max_tokens`
`thinking: disabled` com `effort` `xhigh`/`max`	HTTP 400	Escolha um ou outro
Níveis de `effort` recalibrados	Relação custo/qualidade muda	Reavalie os níveis
Contexto de 1M não exige beta	Cabeçalho antigo é redundante	Remova-o
Cache mínimo cai para 512 tokens	Mais prompts podem ser cacheados	Revise pontos de `cache_control`
Mensagens `system` no meio da conversa	Agora são aceitas	Simplificação opcional
Nível de Prioridade	Não suportado no Opus 5	Mantenha o 4.8 nesse tráfego
Modo Rápido	Funciona no Opus 5	Opcional: US$ 10/US$ 50
`fallbacks: "default"`	Fallback para recusas cibernéticas	Beta opcional
Amostragem e contagem de tokens	Sem alteração relevante	Nenhuma ação

1. `thinking` está ativado por padrão e `max_tokens` continua limitando tudo

Esta é a mudança com maior chance de quebrar código que parecia funcionar.

No Opus 4.8, uma requisição sem thinking era executada sem raciocínio adicional. No Opus 5, a mesma requisição usa pensamento adaptativo por padrão.

O limite de max_tokens cobre:

tokens de pensamento;
tokens da resposta visível.

Assim, um orçamento que era suficiente no 4.8 pode gerar uma resposta truncada no Opus 5.

Antes

{
  "model": "claude-opus-4-8",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Resuma este relatório de incidente em três pontos."
    }
  ]
}

Depois

Aumente o orçamento inicial e ajuste-o com base em métricas reais:

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "messages": [
    {
      "role": "user",
      "content": "Resuma este relatório de incidente em três pontos."
    }
  ]
}

Depois da migração, monitore:

stop_reason: "max_tokens": a resposta foi interrompida pelo limite;
stop_reason: "end_turn": o modelo terminou normalmente;
usage: mostra o consumo real de tokens no seu tráfego.

Se você precisa explicitamente do comportamento sem pensamento, envie:

{
  "thinking": {
    "type": "disabled"
  }
}

Mas leia a próxima seção: esse campo é incompatível com alguns níveis de effort.

2. HTTP 400: `thinking` desabilitado com `effort` `xhigh` ou `max`

No Opus 5, esta combinação retorna HTTP 400:

{
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "xhigh"
  }
}

Ela falha de forma imediata e consistente. Os níveis xhigh e max existem para permitir mais raciocínio; desativar o pensamento ao mesmo tempo é uma configuração contraditória.

Requisição que falha

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "xhigh"
  },
  "messages": [
    {
      "role": "user",
      "content": "Refatore este módulo e explique as compensações."
    }
  ]
}

Correção A: manter a capacidade

Remova thinking e preserve um nível alto de effort. Essa é a direção recomendada para tarefas de código e fluxos agênticos.

{
  "model": "claude-opus-5",
  "max_tokens": 32000,
  "output_config": {
    "effort": "xhigh"
  },
  "messages": [
    {
      "role": "user",
      "content": "Refatore este módulo e explique as compensações."
    }
  ]
}

Correção B: manter `thinking` desativado

Para caminhos muito sensíveis à latência, reduza o effort para high ou menos.

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "high"
  },
  "messages": [
    {
      "role": "user",
      "content": "Classifique este ticket em uma das cinco categorias."
    }
  ]
}

A Anthropic documenta possíveis efeitos colaterais com o pensamento desativado:

chamadas de ferramentas podem aparecer como texto em vez de serem executadas;
tags internas, como <thinking>, podem vazar para a saída;
em fluxos agênticos, texto vazado pode contaminar turnos seguintes.

Use thinking: disabled apenas quando houver uma necessidade explícita de latência.

3. Reavalie os níveis de `effort`

O Opus 5 usa high como padrão, e os níveis foram recalibrados.

Em particular, low e medium são mais fortes no Opus 5 do que nos modelos Opus anteriores. Não copie os valores usados no 4.8 sem medir novamente.

Na prática:

workloads que usavam high ou xhigh no Opus 4.8 podem entregar qualidade suficiente em medium;
workloads presos em low por custo podem melhorar com um nível acima;
para código e agentes de longa duração, xhigh continua sendo um ponto de partida recomendado.

Para níveis altos, comece com um orçamento de tokens generoso, por exemplo max_tokens: 64000, e ajuste com dados reais.

Teste no seu próprio conjunto de avaliação:

Mantenha prompt e dados de entrada fixos.
Varie apenas output_config.effort.
Registre qualidade, latência, stop_reason e usage.
Escolha o menor nível que atende ao requisito da carga.

Veja também:

4. Remova o cabeçalho beta de contexto longo

O Opus 5 oferece janela de contexto de 1M de tokens por padrão e como máximo. Não há mais necessidade de um cabeçalho beta para ativar contexto estendido.

Se seu cliente ainda envia um valor de contexto longo em anthropic-beta, remova-o. Cabeçalhos beta antigos em clientes HTTP compartilhados podem dificultar depuração futura.

A saída máxima na API Messages é de 128k tokens.

Para saídas maiores, a API Batch aceita até 300k tokens de saída com:

anthropic-beta: output-300k-2026-03-24

Esse opt-in é independente do contexto de 1M.

5. O mínimo de cache de prompt caiu para 512 tokens

No Opus 4.8, um segmento precisava de pelo menos 1.024 tokens para ser elegível ao cache. No Opus 5, o mínimo é 512 tokens.

Não é necessário mudar código existente, mas vale revisar:

prompts de sistema;
definições de ferramentas;
exemplos few-shot;
instruções reutilizadas entre requisições.

Segmentos entre 512 e 1.024 tokens agora podem justificar um ponto de interrupção cache_control.

Verifique o efeito no campo:

{
  "usage": {
    "cache_read_input_tokens": 0
  }
}

Na segunda requisição idêntica, cache_read_input_tokens deve ser maior que zero.

6. Mensagens de sistema no meio da conversa agora são aceitas

O Opus 4.8 retornava HTTP 400 ao receber {"role": "system"} dentro do array messages.

O Opus 5 aceita essa estrutura:

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "messages": [
    {
      "role": "user",
      "content": "Elabore a nota de lançamento."
    },
    {
      "role": "assistant",
      "content": "Aqui está um primeiro rascunho..."
    },
    {
      "role": "system",
      "content": "A partir de agora, mantenha as respostas abaixo de 150 palavras."
    },
    {
      "role": "user",
      "content": "Aperte o texto."
    }
  ]
}

Isso pode eliminar soluções alternativas que adicionavam instruções em turnos de usuário artificiais.

Atenção: se o mesmo histórico for enviado ao Opus 4.8 como fallback, ele ainda retornará 400 para mensagens system no meio da conversa.

7. Nível de Prioridade não é suportado no Opus 5

O Opus 4.8 suporta Nível de Prioridade. O Opus 5 não.

Se sua aplicação usa capacidade garantida para proteger latência em produção, migrar esse tráfego para o Opus 5 significa voltar à capacidade padrão.

A abordagem prática é dividir a migração por workload:

mantenha fluxos críticos de latência no claude-opus-4-8;
migre os demais fluxos para o Opus 5;
meça a latência de cauda antes de mover tráfego prioritário.

8. Modo Rápido e fallback para recusas cibernéticas

Modo Rápido

O Modo Rápido funciona no Opus 5 e oferece aproximadamente 2,5x a velocidade de saída.

Preço:

US$ 10 por milhão de tokens de entrada;
US$ 50 por milhão de tokens de saída.

Limitações:

prévia de pesquisa;
disponível apenas na API de primeira parte;
não disponível em Amazon Bedrock, Google Cloud ou Microsoft Foundry;
não pode ser combinado com a API Batch.

Use-o em fluxos interativos, não em jobs de segundo plano.

Fallback do lado do servidor

Para recusas relacionadas à categoria cibernética, envie:

{
  "fallbacks": "default"
}

Com o cabeçalho beta:

anthropic-beta: server-side-fallback-2026-07-01

Quando o Opus 5 recusar uma requisição por essa categoria, a API faz fallback automático para o Opus 4.8.

Há também este cabeçalho beta:

anthropic-beta: mid-conversation-tool-changes-2026-07-01

Ele permite adicionar ou remover definições de ferramentas entre turnos sem invalidar o cache de prompt, o que pode reduzir custo em sessões agênticas longas.

9. O que não mudou

Alguns comportamentos permanecem iguais:

Parâmetros de amostragem continuam retornando 400. Valores não padrão de temperature, top_p e top_k são rejeitados, como no Opus 4.8.
A contagem de tokens permanece aproximadamente igual. O Opus 5 usa a mesma família de tokenizadores do 4.8.
O preço base é o mesmo. US$ 5 de entrada e US$ 25 de saída por milhão de tokens.
Formato de requisição e resposta. Streaming, ferramentas, visão, saídas estruturadas e Batch continuam funcionando da mesma forma.

Consulte a página de preços do Opus 4.8.

Mesmo sem alteração de API, ajuste seus prompts:

remova instruções herdadas de “verifique sua resposta” quando não forem necessárias;
peça concisão explicitamente;
não dependa de reduzir effort para encurtar a resposta visível, pois isso reduz principalmente o pensamento.

Veja como criar prompts para Claude Opus 5.

Verifique a migração antes de implementar

Cada mudança acima pode ser testada fora da aplicação. Um fluxo prático no Apidog:

Salve uma requisição para a API Messages e armazene a chave como variável de ambiente.
Clone a requisição em variantes:
- linha de base com claude-opus-4-8;
- claude-opus-5 com valores padrão;
- um clone para cada nível de effort.
Envie intencionalmente thinking: disabled com effort: xhigh e registre o corpo do HTTP 400.
Faça o teste falhar quando stop_reason for max_tokens.
Envie duas requisições cacheadas idênticas e valide usage.cache_read_input_tokens na segunda.
Execute uma requisição com streaming e confirme que seu parser SSE processa os blocos de thinking.

Baixe o Apidog para manter essas requisições como uma coleção reutilizável para futuras trocas de modelo.

Uma ressalva antes de migrar tudo

O Opus 5 não é o topo da pilha Claude. O Fable 5 continua sendo o modelo mais capaz da Anthropic amplamente lançado, e o Opus 5 ainda fica atrás do Mythos 5 em exploração de segurança cibernética e pesquisa biológica autônoma.

A Anthropic declara isso na postagem de lançamento.

As alegações de benchmark de lançamento — Frontier-Bench, ARC-AGI 3, OSWorld 2.0 e CursorBench 3.2 — são resultados reportados pelo fornecedor e não reproduzidos independentemente em 25 de julho de 2026.

Execute avaliações próprias antes de comprometer uma carga de trabalho de produção.

Lista de verificação da migração

Siga esta ordem:

Altere o ID do modelo para claude-opus-5, sem sufixo de data.
Aumente max_tokens em requisições que antes omitiam thinking.
Procure por "disabled" no código e remova combinações com effort: "xhigh" ou effort: "max".
Remova o beta de contexto longo de anthropic-beta.
Reexecute sua varredura de effort usando suas próprias avaliações.
Adicione cache_control a segmentos reutilizáveis entre 512 e 1.024 tokens.
Identifique tráfego que depende do Nível de Prioridade e decida se ele permanece no claude-opus-4-8.
Remova instruções de verificação redundantes e adicione limites explícitos de concisão.
Habilite opcionalmente fallbacks: "default" se o workload encontrar recusas cibernéticas.
Faça seu conjunto de testes falhar quando stop_reason for max_tokens.

Para referências adicionais:

FAQ

A migração do Opus 4.8 para o Opus 5 é direta?

Quase. Alterar o ID do modelo funciona para a maioria das requisições, mas há três pontos principais:

thinking agora é executado por padrão e compartilha o orçamento de max_tokens;
thinking: {"type": "disabled"} com effort xhigh ou max retorna HTTP 400;
tráfego que usa Nível de Prioridade exige uma decisão, pois o Opus 5 não oferece esse recurso.

Por que recebo HTTP 400 após mudar para `claude-opus-5`?

A causa mais comum é combinar:

{
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "xhigh"
  }
}

Remova thinking e mantenha o effort alto, ou reduza o effort para high ou menos.

Valores não padrão para temperature, top_p e top_k também continuam retornando HTTP 400, como no Opus 4.8.

Preciso recontar meus tokens depois de migrar?

Não. O Opus 5 usa a mesma família de tokenizadores do Opus 4.8, então as contagens permanecem aproximadamente iguais.

Os orçamentos existentes continuam válidos, mas o custo total pode mudar porque o pensamento ativado por padrão pode consumir mais tokens.

Claude Opus 5 Preços: Detalhamento Completo de Custos (2026)

Lucas — Sat, 25 Jul 2026 03:17:48 +0000

Claude Opus 5 foi lançado em 24 de julho de 2026 por US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída. Essa é a mesma taxa do Opus 4.8 e exatamente metade do custo do Fable 5.

Experimente o Apidog hoje

O preço de entrada e saída é só parte da fatura. Escritas e leituras de cache, lotes, modo rápido, multiplicador regional e mudanças no comportamento do modelo podem alterar significativamente o custo final.

Antes de estimar um orçamento, envie solicitações reais pelo Apidog e analise o bloco usage de cada resposta.

A tabela de preços completa do Claude Opus 5

As taxas abaixo vêm da documentação de preços da Anthropic e se aplicam ao modelo claude-opus-5.

Categoria de token	Preço por milhão de tokens
Entrada padrão	US$ 5,00
Saída padrão	US$ 25,00
Escrita de cache de prompt, TTL de 5 minutos	US$ 6,25
Escrita de cache de prompt, TTL de 1 hora	US$ 10,00
Acertos e atualizações de cache	US$ 0,50
Entrada da API em lote	US$ 2,50
Saída da API em lote	US$ 12,50
Entrada em modo rápido	US$ 10,00
Saída em modo rápido	US$ 50,00

Pontos importantes:

Acertos de cache custam um décimo da entrada padrão. É a maior alavanca de economia disponível.
A escrita de cache de 5 minutos custa 1,25x a entrada padrão; a escrita de 1 hora custa 2x.
A API em lote reduz entrada e saída em 50%.
O modo rápido custa 2x o preço padrão para aproximadamente 2,5x a velocidade de saída. É uma prévia de pesquisa, disponível apenas na API de primeira parte, não funciona com Bedrock, Google Cloud ou Microsoft Foundry e não pode ser combinado com lote.
Não há sobretaxa para contexto longo. A janela de contexto de 1 milhão de tokens já é o padrão e o máximo.

Isso também define o teto de custo por solicitação. Uma chamada da API de Mensagens com 1 milhão de tokens de entrada e 128 mil de saída custa:

Entrada: 1.000.000 × US$ 5 / 1.000.000 = US$ 5,00
Saída:    128.000 × US$ 25 / 1.000.000 = US$ 3,20
Total: US$ 8,20

Na API em lote, a saída máxima pode chegar a 300 mil tokens com o cabeçalho beta output-300k-2026-03-24. Nesse cenário, o custo máximo de saída é US$ 3,75.

Referência: Opus 4.8, Fable 5 e Sonnet 5

Modelo	Entrada / MTok	Saída / MTok
Claude Opus 5	US$ 5,00	US$ 25,00
Claude Opus 4.8	US$ 5,00	US$ 25,00
Claude Fable 5	US$ 10,00	US$ 50,00
Claude Sonnet 5, até 31 de agosto de 2026	US$ 2,00	US$ 10,00
Claude Sonnet 5, a partir de 1º de setembro de 2026	US$ 3,00	US$ 15,00

A migração do Opus 4.8 para o Opus 5 não muda o preço por token. O custo unitário permanece igual para as versões 4.5, 4.6, 4.7, 4.8 e 5.

Porém, não assuma que sua fatura será idêntica: o Opus 5 pode mudar o volume de tokens consumidos, especialmente por causa do pensamento adaptativo ativado por padrão.

O detalhamento de preços do Opus 4.8 continua útil para workloads que ainda usam o ID do modelo anterior.

O Opus 5 custa metade do Fable 5. Segundo a Anthropic, ele fica dentro de 0,5% do pico do Fable 5 no CursorBench 3.2 e o supera no OSWorld 2.0 com aproximadamente um terço do custo por tarefa. Esses números são declarações do fornecedor presentes na publicação de lançamento do Opus 5 e não haviam sido reproduzidos independentemente até 25 de julho de 2026.

Para decidir entre os dois, consulte a comparação entre Opus 5 e Fable 5 e a página de preços do Fable 5.

Exemplo 1: custo de uma solicitação simples

Considere uma chamada de sumarização com:

8.000 tokens de entrada
1.200 tokens de saída

Entrada: 8.000 / 1.000.000 × US$ 5,00 = US$ 0,040
Saída:  1.200 / 1.000.000 × US$ 25,00 = US$ 0,030
Total: US$ 0,070 por chamada

Em 10.000 chamadas mensais:

10.000 × US$ 0,070 = US$ 700/mês

Comparação para o mesmo volume:

Modelo	Custo por chamada	Custo mensal em 10.000 chamadas
Opus 5	US$ 0,070	US$ 700
Fable 5	US$ 0,140	US$ 1.400
Sonnet 5, preço introdutório	US$ 0,028	US$ 280

Mesmo com quase sete vezes mais tokens de entrada do que de saída, a saída representa 43% da fatura. Isso ocorre porque tokens de saída custam cinco vezes mais.

No Opus 5, tokens de pensamento também são cobrados como saída. Portanto, monitore output_tokens ao ajustar prompts, limites de saída e níveis de esforço.

Exemplo 2: sessão agêntica longa com cache

Considere um agente de codificação com:

prompt de sistema e contexto de repositório: 120.000 tokens;
sessão de 40 turnos;
1.500 tokens de nova conversa por turno;
2.500 tokens de saída por turno.

Sem cache de prompt

Sem cache, o contexto inteiro é reenviado a cada turno.

Item	Tokens	Taxa	Custo
Entrada: `120.000 × 40 + 60.000`	4.860.000	US$ 5,00	US$ 24,30
Saída: `2.500 × 40`	100.000	US$ 25,00	US$ 2,50
Total			US$ 26,80

Com cache de prompt de 5 minutos

Agora, armazene em cache o prefixo estável de 120.000 tokens.

Item	Tokens	Taxa	Custo
Escrita de cache, uma vez	120.000	US$ 6,25	US$ 0,75
Leituras de cache, 39 turnos	4.680.000	US$ 0,50	US$ 2,34
Nova entrada: `1.500 × 40`	60.000	US$ 5,00	US$ 0,30
Saída: `2.500 × 40`	100.000	US$ 25,00	US$ 2,50
Total			US$ 5,89

O cache reduz o custo de US$ 26,80 para US$ 5,89: uma redução de 78%.

Depois de resolver a repetição de contexto com cache, a saída passa a ser a principal categoria para otimizar.

Leituras de cache atualizam o TTL. Se os turnos ocorrerem em intervalos menores que cinco minutos, uma única escrita mantém o cache ativo.

Se o agente pode ficar inativo por mais de cinco minutos, use TTL de uma hora:

Escrita de cache de 1 hora: 120.000 × US$ 10 / 1.000.000 = US$ 1,20
Custo total da sessão: US$ 6,34

Ainda é 76% mais barato que executar a sessão sem cache.

Exemplo 3: processamento em lote

Use a API em Lote para tarefas sem necessidade de resposta síncrona, como:

classificação;
enriquecimento de dados;
avaliações;
sumarizações noturnas;
backfills.

Considere 50.000 documentos, cada um com:

1.200 tokens de entrada;
150 tokens de saída.

Caminho	Custo de entrada	Custo de saída	Total
Padrão	60 MTok × US$ 5,00 = US$ 300,00	7,5 MTok × US$ 25,00 = US$ 187,50	US$ 487,50
Lote	60 MTok × US$ 2,50 = US$ 150,00	7,5 MTok × US$ 12,50 = US$ 93,75	US$ 243,75

Os tokens e o modelo são os mesmos. A diferença é de US$ 243,75, em troca de processamento assíncrono.

Antes de enviar uma carga ao endpoint padrão, pergunte: isso precisa mesmo de uma resposta imediata?

Exemplo 4: custo do modo rápido

O modo rápido dobra as taxas:

Entrada: US$ 10 / MTok
Saída:  US$ 50 / MTok

Para a solicitação do primeiro exemplo:

Entrada: 8.000 / 1.000.000 × US$ 10 = US$ 0,080
Saída:  1.200 / 1.000.000 × US$ 50 = US$ 0,060
Total: US$ 0,140 por chamada

É exatamente o dobro do caminho padrão.

Use modo rápido em experiências interativas nas quais a latência é visível ao usuário. Para jobs em segundo plano, o custo adicional costuma ser difícil de justificar.

O modo rápido e a API em lote são alavancas mutuamente exclusivas:

precisa de menor custo? Use lote;
precisa de menor latência? Avalie o modo rápido;
não é possível usar ambos na mesma solicitação.

As quatro alavancas que mais movem sua fatura

1. Cache de prompt a partir de 512 tokens

O Opus 5 aceita cache de prompt com um mínimo de 512 tokens. No Opus 4.8, o mínimo era 1.024.

Isso permite armazenar em cache prompts de sistema menores sem alterar a lógica do aplicativo, além de configurar o bloco de controle de cache.

O ponto de equilíbrio é baixo:

TTL de 5 minutos: o cache compensa a partir de 1,3 solicitações; você economiza a partir da segunda chamada.
TTL de 1 hora: o cache compensa a partir de 2,1 solicitações; você economiza a partir da terceira chamada.

Exemplo: um prompt de sistema de 700 tokens reutilizado em 1.000 chamadas.

Sem cache:
700.000 tokens × US$ 5 / 1.000.000 = US$ 3,50

Com cache de 5 minutos:
Escrita: 700 × US$ 6,25 / 1.000.000 = US$ 0,0044
999 leituras: 699.300 × US$ 0,50 / 1.000.000 = US$ 0,34965
Total: aproximadamente US$ 0,354

Esse prompt era curto demais para cache no Opus 4.8.

2. API em Lote com 50% de desconto

Audite seus workloads e separe caminhos síncronos de caminhos assíncronos.

Uma implementação prática:

Solicitações interativas → endpoint padrão
Avaliações e backfills → API em Lote
Processamento noturno → API em Lote
Classificação em massa → API em Lote

Não envie tarefas tolerantes a latência pelo endpoint padrão por conveniência. Isso dobra o custo de entrada e saída sem melhorar a qualidade do resultado.

3. Avalie `output_config.effort`

O parâmetro output_config.effort controla a quantidade de pensamento usada pelo modelo. Como tokens de pensamento são cobrados como saída, o impacto financeiro pode ser relevante.

O Opus 5 recalibrou os níveis de esforço:

low
medium
high — padrão
xhigh — recomendado como ponto de partida para codificação e trabalho agêntico

A Anthropic afirma que low e medium são mais fortes no Opus 5 do que em modelos Opus anteriores.

Não copie a configuração do Opus 4.8 sem medir. Execute uma varredura de esforço em suas próprias avaliações.

Exemplo ilustrativo:

Pensamento em xhigh: 8.000 tokens
Pensamento em low:   1.500 tokens
Economia:            6.500 tokens de saída por tarefa

6.500 / 1.000.000 × US$ 25 = US$ 0,1625 por tarefa
100.000 tarefas = US$ 16.250

Os valores reais dependem de prompts e tarefas. O guia de parâmetros de esforço mostra como estruturar essa avaliação.

Reduzir esforço diminui tokens de pensamento, não necessariamente o tamanho da resposta visível. Para respostas menores, instrua explicitamente o modelo a ser conciso e defina limites adequados de saída.

4. Menor sobrecarga de ferramentas

Ao enviar definições de ferramentas, a API injeta um prompt de sistema pelo qual você paga.

No Opus 5, essa sobrecarga é de 286 tokens para escolha de ferramenta auto ou none.

Modelo	Sobrecarga de ferramentas
Opus 5	286 tokens
Opus 4.8	290 tokens
Opus 4.7	675 tokens

Em relação ao Opus 4.8, a economia é de apenas quatro tokens por solicitação: cerca de US$ 20 por milhão de chamadas.

Em relação ao Opus 4.7, a diferença é de 389 tokens:

389 / 1.000.000 × US$ 5 = US$ 0,001945 por solicitação
1.000.000 solicitações = US$ 1.945

Para outras estratégias aplicáveis a toda a linha Claude, consulte o guia sobre como reduzir sua fatura da API Claude.

Dois custos frequentemente esquecidos

Multiplicador regional `inference_geo: "us"`

Fixar a inferência à infraestrutura dos Estados Unidos aplica um multiplicador de 1,1x a cada categoria de token.

Categoria	Preço padrão	Com `inference_geo: "us"`
Entrada	US$ 5,00	US$ 5,50
Saída	US$ 25,00	US$ 27,50
Acerto de cache	US$ 0,50	US$ 0,55
Entrada em lote	US$ 2,50	US$ 2,75
Saída em lote	US$ 12,50	US$ 13,75

No exemplo de US$ 700 mensais, o custo passa para US$ 770.

Em uma fatura de US$ 50.000, o impacto é de US$ 5.000. Configure fixação regional apenas quando houver uma necessidade real de conformidade ou residência de dados.

Priority Tier não é suportado no Opus 5

O Nível de Prioridade continua disponível no Opus 4.8, mas não é suportado no Opus 5.

Se seu planejamento de capacidade depende de compromissos do Priority Tier, trate isso como uma restrição de migração. O guia de migração do Opus 4.8 para o Opus 5 cobre essa diferença e outras mudanças incompatíveis na API.

Mudanças de comportamento que afetam a fatura

Preço por token é apenas metade do custo. O volume de tokens consumidos é a outra metade.

1. Pensamento adaptativo é ativado por padrão

No Opus 4.8, uma solicitação sem o campo thinking era executada sem pensamento.

No Opus 5, a mesma solicitação pode executar pensamento adaptativo. Esses tokens são cobrados como saída.

Além disso, max_tokens limita tanto o pensamento quanto a resposta visível. Workloads migrados podem passar a truncar respostas se esse limite não for revisado.

2. O modelo delega mais facilmente a subagentes

Cada subagente tem sua própria contagem de tokens faturáveis.

Para workloads sensíveis a custo:

limite a delegação;
defina escopo de tarefas;
restrinja ferramentas disponíveis;
monitore aumentos em output_tokens;
compare resultados com e sem delegação.

3. O modelo verifica o próprio trabalho

O Opus 5 pode verificar seu trabalho sem instruções explícitas.

Se seus prompts ainda incluem frases como “verifique seu trabalho” ou “revise várias vezes antes de responder”, avalie removê-las. O guia de prompting da Anthropic recomenda evitar instruções redundantes.

Mais verificação significa mais tokens.

Como confirmar seu gasto real com Apidog

Pare de estimar apenas com exemplos. Meça o tráfego da sua aplicação.

O objeto usage da resposta informa:

{
  "usage": {
    "input_tokens": 8000,
    "output_tokens": 1200,
    "cache_creation_input_tokens": 120000,
    "cache_read_input_tokens": 4680000
  }
}

Esses campos correspondem diretamente às categorias de cobrança:

input_tokens: entrada padrão;
output_tokens: saída e, quando aplicável, pensamento;
cache_creation_input_tokens: escrita de cache;
cache_read_input_tokens: leituras de cache.

O Apidog é uma plataforma de desenvolvimento e teste de APIs. Para validar seus custos:

Crie uma solicitação para o endpoint Messages com "model": "claude-opus-5".
Duplique a solicitação para cada nível de output_config.effort.
Execute os testes com prompts idênticos.
Compare output_tokens e a qualidade das respostas.
Verifique se usage.cache_read_input_tokens é maior que zero quando espera usar cache.
Armazene chaves de API em variáveis de ambiente, não no corpo da solicitação.
Acompanhe o fluxo SSE para visualizar o consumo de saída em gerações longas.

Você pode baixar o Apidog e usar este processo junto com o guia da API do Opus 5.

O que você compra por US$ 5 / US$ 25

O Opus 5 tem uma posição forte de preço por capacidade, mas não é o topo da linha Claude.

O Fable 5 continua sendo o modelo mais capaz da Anthropic amplamente lançado. Segundo a Anthropic, o Opus 5 também fica atrás do Mythos 5 em exploração de cibersegurança e pesquisa autônoma em biologia.

A decisão prática não é apenas “Opus 5 versus o modelo mais capaz”. Para a maioria das equipes, a pergunta é:

Esta carga precisa de Opus ou o Sonnet 5 resolve o problema por um custo menor?

O Sonnet 5 custa US$ 2 / US$ 10 durante o período introdutório e US$ 3 / US$ 15 a partir de 1º de setembro de 2026. Execute ambos nos seus próprios conjuntos de avaliação antes de comprometer o orçamento.

Consulte:

FAQ

Quanto custa o Claude Opus 5?

Na API padrão, custa US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída. Acertos de cache custam US$ 0,50 por milhão, lote custa US$ 2,50 / US$ 12,50 e o modo rápido custa US$ 10 / US$ 50.

O Claude Opus 5 é mais caro que o Opus 4.8?

Por token, não. As taxas são idênticas. Porém, sua fatura pode subir porque o pensamento é ativado por padrão e as respostas padrão podem ser mais longas. Meça os tokens reais antes e depois da migração.

Há sobretaxa para contexto longo na janela de 1 milhão de tokens?

Não. A janela de 1 milhão de tokens é o padrão e o máximo, sem nível premium para entradas longas.

Qual é a forma mais barata de usar o Claude Opus 5?

Combine três práticas:

Armazene prefixos reutilizados em cache.
Envie trabalhos não urgentes pela API em Lote.
Avalie níveis de esforço para encontrar o menor que mantém sua qualidade mínima.

O guia de caminho mais barato e gratuito tem mais detalhes.

A fixação regional custa mais?

Sim. Definir inference_geo: "us" aplica um multiplicador de 1,1x a todas as categorias, incluindo acertos de cache e processamento em lote.

Como Usar a API Claude Opus 5?

Lucas — Sat, 25 Jul 2026 03:16:21 +0000

Claude Opus 5 foi lançado em 24 de julho de 2026, e a Anthropic agora direciona os desenvolvedores a ele primeiro: a documentação recomenda começar com Claude Opus 5 quando você não tiver certeza de qual modelo usar. O ID exato do modelo na API é claude-opus-5, sem sufixo de data.

Experimente o Apidog hoje

Este guia mostra o fluxo completo: criar uma chave, enviar a primeira solicitação, usar streaming, integrar ferramentas, configurar pensamento adaptativo e effort, além de validar o objeto usage para confirmar o funcionamento do cache de prompt. Todas as chamadas usam HTTP e JSON, para que você possa construí-las e depurá-las no Apidog antes de levá-las ao código da aplicação.

Se você estiver migrando um serviço existente, leia também o guia completo de migração do Opus 4.8 para o Opus 5.

Antes da primeira chamada: duas mudanças impactantes

1. O pensamento é ativado por padrão

No Opus 4.8, uma requisição sem o campo thinking era executada sem pensamento. No Opus 5, a mesma requisição usa pensamento adaptativo.

O campo max_tokens continua sendo um limite rígido que cobre tokens de pensamento e tokens de resposta juntos. Portanto, um payload migrado do Opus 4.8 pode passar a truncar a resposta no meio.

Se seu max_tokens foi dimensionado apenas para a saída visível, aumente-o.

2. Desativar o pensamento limita o esforço

A combinação abaixo retorna 400:

{
  "thinking": {"type": "disabled"},
  "output_config": {"effort": "xhigh"}
}

Com thinking: {"type": "disabled"}, o maior nível permitido é high. Você tem duas opções:

Manter o pensamento ativado e reduzir effort para controlar custo.
Desativar o pensamento e limitar effort a high.

A recomendação da Anthropic é manter o pensamento ativado. Com ele desativado, o Opus 5 pode escrever chamadas de ferramenta como texto simples — elas não são executadas — e também pode expor tags <thinking> na resposta visível.

As duas mudanças estão documentadas no guia de migração de modelos da Anthropic.

Passo 1: obtenha uma chave de API

Faça login na Plataforma de Desenvolvedores Claude, abra as configurações da organização, acesse a seção de chaves de API e crie uma nova chave.

Copie a chave imediatamente: ela não poderá ser exibida novamente.

Armazene-a em uma variável de ambiente:

export ANTHROPIC_API_KEY="sk-ant-..."

Evite colar chaves no código ou em coleções compartilhadas. Em clientes GUI, use variáveis de ambiente. No Apidog, por exemplo, crie ambientes como Local, Staging e Production, defina a variável ANTHROPIC_API_KEY e use {{ANTHROPIC_API_KEY}} no cabeçalho.

Você também precisa adicionar créditos de cobrança antes que as solicitações sejam bem-sucedidas. As taxas do Opus 5 são de US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída, iguais às do Opus 4.8. Consulte o detalhamento completo de preços para taxas de cache, lote e modo rápido.

Passo 2: envie sua primeira solicitação

Use o endpoint:

POST https://api.anthropic.com/v1/messages

Inclua estes três cabeçalhos:

x-api-key
anthropic-version
content-type

Exemplo com curl:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "Explain the difference between a 429 and a 529 from an API perspective."
      }
    ]
  }'

O valor 4096 é intencionalmente maior que os 1024 comuns em exemplos básicos. Agora, os tokens de pensamento compartilham o mesmo orçamento da resposta.

Exemplo equivalente com o SDK oficial para Python:

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

message = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Explain the difference between a 429 and a 529 from an API perspective.",
        }
    ],
)

for block in message.content:
    if block.type == "text":
        print(block.text)

Não trate message.content como um único texto. A resposta contém um array de blocos tipados. Com pensamento ativado, normalmente haverá um bloco thinking antes do bloco text.

Evite isto:

print(message.content[0].text)

Esse padrão pode falhar silenciosamente após a migração: a chamada retorna 200, mas o primeiro bloco pode não ser texto visível.

O Opus 5 tem:

Janela de contexto padrão e máxima de 1M de tokens.
Saída máxima de 128k tokens na API de Mensagens.
Corte de conhecimento em maio de 2026.

Consulte a visão geral dos modelos e o explicador do Opus 5 para mais detalhes.

Passo 3: trabalhe com pensamento adaptativo

Pensamento adaptativo significa que o modelo decide quanto raciocínio interno uma solicitação exige. Você não configura um orçamento específico de pensamento; você direciona o comportamento com effort.

Ao implementar, siga estas regras:

Analise blocos por tipo. Use block.type == "text" para a resposta visível e block.type == "thinking" se precisar registrar raciocínio.
Reenvie blocos de pensamento sem alterações. Em conversas de múltiplas rodadas ou fluxos com ferramentas, anexe todo o array content do assistente ao histórico.
Orce max_tokens para pensamento e resposta. Verifique stop_reason nos testes para detectar truncamentos.

Exemplo para desativar o pensamento:

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "thinking": {"type": "disabled"},
  "output_config": {"effort": "high"},
  "messages": [
    {
      "role": "user",
      "content": "Return only the HTTP status code."
    }
  ]
}

O effort é limitado a high nesse exemplo. Se você alterar para xhigh ou max, a API retornará 400.

Passo 4: controle custo com `output_config.effort`

O campo effort fica dentro de output_config e aceita:

low
medium
high
xhigh
max

O padrão é high.

Exemplo usando xhigh:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 65536,
    "output_config": {"effort": "xhigh"},
    "messages": [
      {
        "role": "user",
        "content": "Refactor this handler to stream responses and keep backpressure."
      }
    ]
  }'

Antes de escolher um nível, considere estes pontos:

Os níveis foram recalibrados. Não reutilize diretamente as configurações do Opus 4.8. Segundo a Anthropic, low e medium são significativamente mais capazes no Opus 5.
xhigh é o ponto de partida recomendado para código e tarefas agênticas. Nesse nível, max_tokens se torna ainda mais importante. Para rodadas longas, 65536 é um limite inicial razoável.
Reduzir esforço não encurta necessariamente a resposta visível. Menos esforço reduz pensamento interno. Para respostas mais curtas, peça explicitamente isso no prompt.

Veja o guia detalhado do parâmetro effort para uma metodologia de avaliação.

Passo 5: transmita a resposta com streaming

Adicione "stream": true ao payload para receber eventos enviados pelo servidor (SSE) em vez de um único JSON.

with client.messages.stream(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Draft a retry policy for a flaky upstream.",
        }
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    final = stream.get_final_message()
    print("\n\nusage:", final.usage)

A sequência SSE é:

message_start
content_block_start
content_block_delta
content_block_stop
message_delta
message_stop

Com pensamento ativado, você recebe blocos diferentes:

Deltas thinking_delta para o bloco de pensamento.
Deltas text_delta para a resposta visível.

Não escreva todos os deltas no mesmo buffer da interface. Caso contrário, você pode exibir raciocínio interno para o usuário final.

Para inspecionar o SSE sem construir um cliente, use o Apidog. Ele renderiza os eventos à medida que chegam, o que ajuda a validar limites de blocos e sua estratégia de parsing antes da implementação.

Passo 6: adicione uso de ferramentas

Defina ferramentas no array tools. Quando o modelo quiser executar uma ferramenta, a resposta terá:

stop_reason: "tool_use"
Um bloco de conteúdo do tipo tool_use

Execute a ferramenta no seu backend e devolva o resultado como um bloco tool_result em uma nova mensagem do usuário.

tools = [
    {
        "name": "get_order_status",
        "description": "Look up the current status of a customer order by ID.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {
                    "type": "string",
                    "description": "The order ID, e.g. A-10293",
                }
            },
            "required": ["order_id"],
        },
    }
]

message = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    tools=tools,
    messages=[
        {
            "role": "user",
            "content": "What's the status of order A-10293?",
        }
    ],
)

if message.stop_reason == "tool_use":
    call = next(block for block in message.content if block.type == "tool_use")
    result = get_order_status(**call.input)

    follow_up = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=[
            {
                "role": "user",
                "content": "What's the status of order A-10293?",
            },
            {
                "role": "assistant",
                "content": message.content,
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "tool_result",
                        "tool_use_id": call.id,
                        "content": result,
                    }
                ],
            },
        ],
    )

O ponto crítico é este:

{"role": "assistant", "content": message.content}

Passe message.content diretamente. Não reconstrua manualmente a mensagem do assistente, pois isso pode remover blocos de pensamento e degradar o loop agêntico.

Detalhes do Opus 5 relevantes para agentes:

A sobrecarga do prompt de sistema para uso de ferramentas é menor que no Opus 4.8: 286 tokens com tool_choice igual a auto ou none, contra 290 no Opus 4.8 e 675 no Opus 4.7.
O cabeçalho beta mid-conversation-tool-changes-2026-07-01 permite adicionar ou remover ferramentas entre turnos sem invalidar o cache do prompt.
O Opus 5 delega a subagentes mais facilmente que o Opus 4.8. Em cargas de trabalho sensíveis a custo, explicite limites no prompt de sistema.

Passo 7: leia `usage` para validar acertos de cache

Cada resposta inclui um objeto usage:

{
  "input_tokens": 84,
  "cache_creation_input_tokens": 6421,
  "cache_read_input_tokens": 0,
  "output_tokens": 913
}

Use cache_control para marcar conteúdo cacheável:

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "system": [
    {
      "type": "text",
      "text": "<your long, stable instructions and reference material>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [
    {
      "role": "user",
      "content": "Question one."
    }
  ]
}

Valide o comportamento esperado:

Primeira chamada: cache_creation_input_tokens > 0 e cache_read_input_tokens = 0.
Chamadas seguintes com o mesmo prefixo: cache_read_input_tokens > 0.

Se isso não acontecer, o prefixo não é byte a byte idêntico ou está abaixo do tamanho mínimo.

No Opus 5, o cache de prompt começa a partir de 512 tokens, abaixo dos 1.024 tokens do Opus 4.8. Leituras de cache custam US$ 0,50 por milhão de tokens, contra US$ 5 por milhão de tokens de entrada na taxa base.

Inclua uma asserção em cache_read_input_tokens na sua suíte de testes. Assim, uma alteração de prompt que invalide o cache aparece como falha de teste, e não como surpresa na fatura.

Para outras estratégias, veja o guia sobre como reduzir sua fatura da API Claude.

Teste e depure todo o fluxo no Apidog

Cada etapa deste artigo é uma requisição HTTP com:

Cabeçalhos de autenticação.
Corpo JSON.
Fluxo SSE opcional.
Resposta que precisa ser validada.

O Apidog permite enviar, armazenar e testar essas requisições. A inferência continua acontecendo na Anthropic; o Apidog não executa nem roteia modelos.

Uma configuração prática para começar:

Crie a requisição. Use POST https://api.anthropic.com/v1/messages, os três cabeçalhos obrigatórios e uma variável de ambiente para a chave.
Salve-a em uma coleção. Isso cria uma referência reutilizável para toda a equipe.
Duplique por nível de esforço. Crie versões com output_config.effort em low, medium, high e xhigh. Envie o mesmo prompt em cada uma e compare qualidade, latência e uso de tokens.
Inspecione o streaming SSE. Ative "stream": true e confirme que sua implementação separa blocos de pensamento e texto.
Inspecione payloads de ferramentas. Quando stop_reason for tool_use, valide o objeto input retornado pelo modelo. Isso ajuda a identificar schemas muito permissivos.
Adicione asserções. Verifique se stop_reason não é max_tokens e se cache_read_input_tokens é maior que zero em chamadas repetidas.

Baixe o Apidog para acompanhar o fluxo. O mesmo padrão de coleção funciona com outros modelos Claude, incluindo Sonnet 5 e suas solicitações existentes do Opus 4.8.

Erros e pegadinhas que você realmente encontrará

400 com thinking: disabled e esforço xhigh ou max. Reduza o esforço para high ou reative o pensamento.
400 em parâmetros de amostragem. temperature, top_p e top_k com valores não padrão continuam retornando 400, como no Opus 4.8. Direcione o comportamento pelo prompt de sistema.
Respostas truncadas. stop_reason: "max_tokens" com pensamento ativado significa que o limite foi consumido por pensamento e saída. Aumente max_tokens.
Tier de Prioridade não é suportado no Opus 5. O Opus 4.8 continua suportando-o. Se sua estratégia de capacidade depende desse recurso, resolva isso antes de migrar tráfego.
Mensagens de sistema no meio da conversa funcionam. Uma entrada role: "system" dentro de messages é aceita no Opus 5, enquanto no Opus 4.8 retornava 400.
Superverificação. O Opus 5 já verifica o próprio trabalho sem ser solicitado. Remova instruções herdadas como “verifique novamente sua resposta antes de responder” se elas não agregarem valor à sua avaliação.

O limite honesto

O Opus 5 não é o topo da pilha Claude. O Fable 5 mantém a designação de “mais capaz amplamente lançado” da Anthropic, a US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída.

O Opus 5 também fica atrás do Mythos 5 em exploração de cibersegurança e pesquisa autônoma de biologia, segundo a própria Anthropic.

As alegações de benchmark de lançamento — aproximadamente o dobro do Opus 4.8 no Frontier-Bench v0.1, cerca de 3x o próximo melhor modelo no ARC-AGI 3 e dentro de 0,5% do Fable 5 no CursorBench 3.2 — são números da Anthropic e não haviam sido reproduzidos independentemente até 25 de julho de 2026.

Trate esses números como resultados fornecidos pelo fabricante e execute suas próprias avaliações. Veja a comparação entre Opus 5 e Fable 5 e o post de lançamento da Anthropic.

FAQ

Qual é o ID do modelo para Claude Opus 5?

claude-opus-5, exatamente, sem sufixo de data.

No Amazon Bedrock, é anthropic.claude-opus-5. O Google Cloud e a Plataforma Claude na AWS usam o ID proprietário.

Por que minha solicitação do Opus 4.8 começou a truncar no Opus 5?

Porque o pensamento agora é ativado por padrão. max_tokens limita conjuntamente os tokens de pensamento e de resposta.

Aumente max_tokens e verifique se stop_reason é "max_tokens".

Por que recebo `400` ao desativar o pensamento?

Provavelmente porque você combinou:

{"thinking": {"type": "disabled"}}

com:

{"output_config": {"effort": "xhigh"}}

Limite o esforço a high ou mantenha o pensamento ativado.

Preciso de um cabeçalho beta para usar a janela de contexto de 1M?

Não. No Opus 5, 1M de tokens é o padrão e o máximo, sem cabeçalho beta e sem preço adicional de contexto longo.

Para chegar a 300k de saída na API de Lote, use o cabeçalho beta output-300k-2026-03-24. A API de Mensagens limita a saída a 128k.

Posso reutilizar minhas configurações de esforço do Opus 4.8?

Não é recomendado. Os níveis foram recalibrados, e low e medium são significativamente mais fortes no Opus 5.

Execute uma nova varredura no seu próprio conjunto de avaliação.

O Apidog executa o modelo?

Não. O Apidog envia, inspeciona e testa a requisição HTTP. A inferência ocorre na Anthropic.

Ele ajuda a gerenciar chaves, streaming, payloads de chamadas de ferramenta e asserções de resposta ao redor da chamada.

O Que é Claude Opus 5? Especificações, Benchmarks e Preço

Lucas — Sat, 25 Jul 2026 03:12:55 +0000

Claude Opus 5 é o modelo mais recente da linha Opus da Anthropic, lançado em 24 de julho de 2026. A Anthropic o posiciona para codificação agentic complexa e trabalho empresarial, e sua documentação o apresenta como ponto de partida padrão quando você não sabe qual modelo escolher. O preço base é de US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída: a mesma taxa do Opus 4.8 e metade do preço do Fable 5.

Experimente o Apidog hoje

Este guia reúne especificações, preço, benchmarks de lançamento, compatibilidade com o Opus 4.8, níveis de esforço e opções de implantação. Se você chama o modelo por HTTP, use o Apidog para enviar, salvar e inspecionar requisições enquanto valida a migração.

Claude Opus 5 em resumo

Especificação	Valor
ID do modelo da API	`claude-opus-5` (sem sufixo de data)
Lançamento	24 de julho de 2026
Janela de contexto	1.000.000 tokens, padrão e máximo
Saída máxima	128.000 tokens na API de Mensagens; 300.000 na API de Lote com o cabeçalho beta `output-300k-2026-03-24`
Preço base	US$ 5 por milhão de tokens de entrada, US$ 25 por milhão de tokens de saída
Corte de conhecimento	Maio de 2026
Pensamento adaptativo	Ativado por padrão
Níveis de esforço	`low`, `medium`, `high`, `xhigh`, `max`; padrão `high`
Nível de Prioridade	Não suportado
Disponibilidade	API Claude, claude.ai, Claude Code, Claude Cowork, Amazon Bedrock, Claude Platform no AWS, Google Cloud, Microsoft Foundry, GitHub Copilot

Pontos práticos a considerar:

Contexto de 1M tokens: é o padrão e também o máximo. Você não precisa enviar um cabeçalho beta e não há tarifa adicional para contexto longo.
Conhecimento até maio de 2026: é mais recente que Fable 5 e Sonnet 5, ambos com corte em janeiro de 2026.
Nível de Prioridade: Opus 4.8 suporta esse recurso; Opus 5 não. Se sua capacidade de produção depende dele, trate isso como bloqueador e revise o guia de migração.

Para os campos completos e atualizados, consulte a visão geral dos modelos da Anthropic.

O que é Claude Opus 5

Opus 5 é o sucessor do Claude Opus 4.8. Na API Claude, use o ID exato:

claude-opus-5

No Amazon Bedrock, o ID é:

anthropic.claude-opus-5

No Google Cloud, use novamente:

claude-opus-5

A Claude Platform no AWS usa um ID próprio.

A linha Opus é a categoria de maior capacidade geral da Anthropic, acima do Sonnet e abaixo dos modelos de pesquisa Fable e Mythos. A mudança relevante nesta geração é de posicionamento: em vez de ser apenas a opção premium para escalar, a Anthropic recomenda começar pelo Opus 5 quando não houver um modelo pré-selecionado.

O modelo também passa a ser o padrão para assinantes Max e o modelo de maior desempenho no Pro. Veja os caminhos gratuitos e pagos mais baratos para entender o impacto nos planos de consumo.

Preço e custo por token

Taxa	Entrada por M tokens	Saída por M tokens
Padrão	US$ 5,00	US$ 25,00
API de Lote, 50% de desconto	US$ 2,50	US$ 12,50
Modo Rápido, prévia de pesquisa	US$ 10,00	US$ 50,00
Gravação em cache, TTL de 5 minutos	US$ 6,25	n/a
Gravação em cache, TTL de 1 hora	US$ 10,00	n/a
Acertos e atualizações de cache	US$ 0,50	n/a

O Claude Fable 5 custa US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída. A Anthropic afirma que o Opus 5 fica a 0,5% do Fable 5 em codificação agentic, por metade do preço.

Para reduzir custos na implementação:

Use cache de prompt quando houver contexto estável. O mínimo de cache caiu para 512 tokens, contra 1.024 no Opus 4.8.
Reutilize acertos de cache. Eles custam US$ 0,50 por milhão de tokens, ou um décimo da entrada padrão.
Envie trabalhos não urgentes para a API de Lote. A tarifa é reduzida pela metade.
Avalie o Modo Rápido apenas para latência crítica. Ele dobra o preço para US$ 10 e US$ 50, em troca de aproximadamente 2,5x a velocidade de saída.
Evite inference_geo: "us" sem necessidade. Essa configuração aplica multiplicador de 1,1x a entrada, saída, gravações e acertos de cache.

O Modo Rápido funciona somente na API própria da Anthropic. Ele não está disponível no Bedrock, Google Cloud, Microsoft Foundry ou API de Lote.

A análise completa de preços inclui exemplos por tarefa. As práticas para cortar sua conta da API Claude continuam aplicáveis. A referência oficial é a página de preços da Anthropic.

O que os benchmarks da Anthropic indicam

Os números abaixo foram publicados pela própria Anthropic no lançamento. Em 25 de julho de 2026, eles ainda não tinham reprodução independente. Use-os como alegações do fornecedor e valide seu próprio workload antes de migrar produção.

Benchmark	Afirmação da Anthropic
Frontier-Bench v0.1	Supera outros modelos e mais que dobra a pontuação do Opus 4.8, com menor custo por tarefa
ARC-AGI 3	Aproximadamente 3x a pontuação do segundo melhor modelo
OSWorld 2.0, uso de computador	Supera o Fable 5 a um terço do custo
CursorBench 3.2, codificação agentic	Fica a 0,5% do pico do Fable 5 pela metade do preço
Zapier AutomationBench	Taxa de aprovação de aproximadamente 1,5x a do segundo melhor modelo
Química orgânica	+10,2 pontos sobre o Opus 4.8
Análise de proteínas	+7,7 pontos sobre o Opus 4.8

Para tomar uma decisão de engenharia, priorize testes próprios em:

tarefas agentic com ferramentas;
edição e revisão de código no seu repositório;
fluxos com uso de navegador ou computador;
chamadas longas com contexto e cache;
custo total por tarefa concluída, não apenas custo por token.

CursorBench e OSWorld são os resultados mais importantes para uma possível migração de Fable 5 para Opus 5, mas uma diferença de 0,5% pode desaparecer ou se inverter dependendo do seu prompt, base de código, ferramentas e critérios de sucesso.

O mergulho profundo nos benchmarks explica o que cada avaliação mede e como criar testes internos.

O limite honesto do Opus 5

Opus 5 não é o modelo mais capaz de toda a linha Claude.

Fable 5 mantém a designação de “modelo amplamente lançado mais capaz”. Em duas áreas específicas de pesquisa — exploração de cibersegurança e pesquisa autônoma em biologia — o Opus 5 ainda fica atrás do Mythos 5.

Na prática:

para codificação agentic e automação empresarial, o Opus 5 é o principal candidato para avaliação;
para exploração de segurança e pesquisa científica autônoma, avalie Mythos 5;
para máxima capacidade geral, considere Fable 5.

Consulte o explicador do modelo de classe Mythos e Fable 5 vs Mythos 5.

Duas mudanças que quebram código do Opus 4.8

Trocar apenas o ID do modelo não é suficiente. Há duas mudanças que podem afetar a primeira requisição.

1. O pensamento é ativado por padrão

No Opus 4.8, omitir thinking executava a requisição sem pensamento. No Opus 5, a mesma requisição usa pensamento adaptativo.

Como max_tokens limita tanto tokens de pensamento quanto tokens visíveis de saída, uma configuração ajustada apenas para o tamanho esperado da resposta pode truncar silenciosamente.

Evite começar com valores muito baixos:

{
  "model": "claude-opus-5",
  "max_tokens": 8192,
  "messages": [
    {
      "role": "user",
      "content": "Refatore este handler e explique os trade-offs."
    }
  ]
}

Monitore respostas incompletas e aumente max_tokens antes de assumir que o problema é do modelo.

2. Desativar pensamento é incompatível com `xhigh` e `max`

Esta combinação retorna HTTP 400:

{
  "thinking": {
    "type": "disabled"
  },
  "output_config": {
    "effort": "xhigh"
  }
}

O mesmo vale para effort: "max".

Se você tem uma configuração global que desativa pensamento e aumenta esforço, altere-a antes de migrar.

Outras mudanças de migração:

os níveis de esforço foram recalibrados;
o cabeçalho beta da janela de contexto foi removido;
mensagens de sistema no meio da conversa agora são aceitas;
o Nível de Prioridade não está disponível.

Use o guia de migração do Opus 4.8 para o Opus 5 para exemplos antes e depois. A referência oficial é o guia de migração da Anthropic. Se você ainda usa a geração anterior, consulte também o passo a passo da API do Opus 4.8.

Como usar `output_config.effort`

O parâmetro relevante para controlar custo e capacidade é:

{
  "output_config": {
    "effort": "high"
  }
}

Os níveis disponíveis são:

low
medium
high
xhigh
max

O padrão é high.

O esforço controla quanto o modelo pensa antes de responder. Como os níveis foram recalibrados no Opus 5, não reutilize automaticamente as escolhas feitas para Opus 4.8.

Faça uma varredura simples:

Escolha um conjunto fixo de tarefas representativas.
Execute cada tarefa com low, medium, high e xhigh.
Registre sucesso, tokens, latência e custo.
Use o menor nível que atinge o critério de qualidade.
Reserve xhigh para codificação e loops agentic quando a qualidade adicional justificar o custo.

low e medium são descritos como significativamente mais fortes do que nos modelos Opus anteriores. Para workloads de codificação e agentes, xhigh continua sendo o ponto de partida recomendado pela Anthropic.

Veja o guia do parâmetro de esforço para uma metodologia de avaliação e a interação com max_tokens.

Mudanças de comportamento e prompting

O guia de prompting da Anthropic para o Opus 5 documenta diferenças que afetam resultados mesmo quando o código permanece igual.

Ele verifica o próprio trabalho sem ser solicitado. Remova instruções herdadas como “verifique sua resposta” se elas não forem necessárias.
As respostas podem ser mais longas. Reduzir esforço diminui pensamento, não necessariamente o texto visível. Peça concisão explicitamente.
Ele delega mais para subagentes. Delimite a delegação em workloads sensíveis a custo.
Ele pode expandir o escopo da tarefa. Declare entregáveis, limites e critérios de conclusão no prompt.

Exemplo de prompt com escopo controlado:

Refatore apenas o handler `createUser`.

Restrições:
- Não altere a interface pública.
- Não crie novos arquivos.
- Preserve os testes existentes.
- Retorne apenas o diff e uma lista de até três trade-offs.

Com pensamento desativado, podem ocorrer dois artefatos: chamadas de ferramenta emitidas como texto simples e tags XML internas aparecendo na saída. Em loops agentic, esse texto pode contaminar a próxima interação.

A mitigação recomendada é manter pensamento ativado e reduzir custo usando um nível de esforço menor. Consulte o mergulho profundo em prompting e o guia Claude Code.

Onde executar o Opus 5

Superfície	Status
API Claude	Disponível, ID `claude-opus-5`
claude.ai	Disponível; padrão para Max, modelo principal para Pro
Claude Code	Disponível
Claude Cowork	Disponível
Amazon Bedrock	Disponível como `anthropic.claude-opus-5`
Claude Platform no AWS	Disponível, ID próprio
Google Cloud	Disponível como `claude-opus-5`
Microsoft Foundry	Disponível
GitHub Copilot	Disponível

O Modo Rápido é a exceção: está disponível somente na API própria da Anthropic.

Testando requisições do Opus 5 no Apidog

Uma integração com Opus 5 envolve endpoint HTTP, autenticação, JSON, respostas em streaming e tratamento de erros. O Apidog ajuda a enviar a requisição, salvar exemplos em coleções, usar variáveis de ambiente e inspecionar a resposta campo a campo.

Configure seu ambiente desta forma:

Armazene ANTHROPIC_API_KEY como variável de ambiente.
Crie uma requisição base para a API de Mensagens.
Duplique a requisição para testar low, high e xhigh com o mesmo prompt.
Ative streaming para observar onde respostas truncadas terminam.
Inspecione o bloco usage para acompanhar tokens, cache e pensamento.

Requisição base:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 8192,
    "messages": [
      {
        "role": "user",
        "content": "Refactor this handler and explain the tradeoffs."
      }
    ]
  }'

Essa chamada usa pensamento adaptativo porque thinking não foi informado. Não reutilize valores baixos de max_tokens do Opus 4.8 sem testar: 1024 pode resultar em truncamento no Opus 5.

Para testar visualmente, baixe o Apidog e importe a requisição. O guia passo a passo da API cobre streaming, uso de ferramentas e leitura completa de usage.

Quem deve usar Claude Opus 5

Use Opus 5 quando:

Você constrói agentes ou fluxos com muitas ferramentas. É o principal foco das alegações de benchmark da Anthropic.
Você usa Fable 5 e precisa reduzir custos. A diferença alegada de 0,5% em codificação agentic merece uma avaliação no seu ambiente. Veja Opus 5 vs Fable 5.
Você usa Opus 4.8 hoje. O preço é o mesmo, o corte de conhecimento é mais recente e a Anthropic relata resultados melhores; o custo principal é a migração.
Você precisa de conhecimento recente. O corte em maio de 2026 está aproximadamente quatro meses à frente dos demais modelos Claude atuais.

Mantenha sua implementação atual quando:

O Nível de Prioridade é essencial. Opus 4.8 mantém o recurso; Opus 5 não. Revise preços e níveis do Opus 4.8.
Sua carga é simples, barata e de alto volume. Sonnet 5 pode ser suficiente. Veja Opus 5 vs Sonnet 5.
Você faz exploração de cibersegurança ou pesquisa autônoma em biologia. Mythos 5 ainda lidera nessas áreas.

FAQ

Qual é o ID do modelo para Claude Opus 5?

Use claude-opus-5, sem sufixo de data. No Amazon Bedrock, use anthropic.claude-opus-5. No Google Cloud, use claude-opus-5.

Quanto custa o Claude Opus 5?

US$ 5 por milhão de tokens de entrada e US$ 25 por milhão de tokens de saída. A API de Lote reduz para US$ 2,50 e US$ 12,50. O Modo Rápido aumenta para US$ 10 e US$ 50.

Claude Opus 5 é melhor que Fable 5?

Segundo os números da Anthropic, ele fica próximo, mas não à frente. A empresa relata diferença de 0,5% no CursorBench 3.2 e vantagem no OSWorld 2.0 a um terço do custo. Fable 5 mantém a designação de modelo amplamente lançado mais capaz. Esses resultados ainda não tinham reprodução independente em 25 de julho de 2026.

Qual é a janela de contexto do Claude Opus 5?

A janela é de 1.000.000 tokens como padrão e máximo, sem cabeçalho beta nem custo adicional para contexto longo. A saída máxima é de 128.000 tokens na API de Mensagens ou 300.000 na API de Lote com output-300k-2026-03-24.

Preciso alterar meu código ao migrar do Opus 4.8?

Sim. Além do ID do modelo, revise max_tokens porque o pensamento é ativado por padrão. Também não combine thinking: {type: "disabled"} com esforço xhigh ou max, pois a API retorna HTTP 400. Refaça sua varredura de esforço.

Qual é o corte de conhecimento do Claude Opus 5?

Maio de 2026 para conhecimento confiável e dados de treinamento, o corte mais recente entre os modelos Claude atuais.

Cliente API: Ainda é Necessário com Cursor ou Copilot?

Lucas — Thu, 23 Jul 2026 07:05:29 +0000

Você descreve o endpoint em português claro. O Cursor escreve a chamada fetch. O Copilot autocompleta os cabeçalhos. O código compila, então a pergunta surge por si só: se o agente no seu editor escreve a chamada da API, por que manter um cliente de API separado aberto ao lado dele?

Experimente o Apidog hoje

Geralmente, sim. Cursor e Copilot escrevem bons rascunhos de chamadas de API, mas duas tarefas permanecem fora da IDE: fornecer ao agente sua especificação real para que ele pare de adivinhar endpoints e executar a chamada gerada para confirmar que ela funciona contra o serviço em tempo real. Um cliente de API com um servidor MCP e um CLI cobre ambas.

A versão honesta não é “o agente da IDE é ruim”. Ele escreve código cliente sólido. O ponto é mais restrito: o agente adivinha sua API a partir de padrões vistos no treinamento e não pode garantir que a chamada escrita retorna 200 em vez de 404. Essas são as duas lacunas em que um cliente de API ainda tem espaço. Esta é a versão focada em IDE de uma questão maior: você ainda precisa de uma ferramenta de API na era dos agentes de IA?

O que Cursor e Copilot já fazem bem

Vale reconhecer onde essas ferramentas são eficazes.

Um agente de IDE é bom em estruturar uma requisição. Peça ao Cursor um GET paginado com retry, e ele pode gerar:

configuração do cliente;
loop de paginação;
tratamento de erros;
tipos;
lógica de retry.

O Copilot também é eficiente na próxima linha: depois que você escreve uma chamada, ele pode completar o restante do CRUD no estilo do projeto. Claude Code e Cline conseguem montar um módulo cliente inteiro a partir de uma descrição curta e mantê-lo consistente com os arquivos existentes.

Isso remove trabalho real. O boilerplate que antes exigia busca na documentação e vários minutos de digitação agora chega como um rascunho. As lacunas abaixo não são motivo para deixar de usar o agente — são motivo para adicionar uma ferramenta complementar.

As duas tarefas que seu agente de IDE deixa em aberto

A divisão é simples: o agente cobre a escrita, mas não cobre a fundamentação nem a execução.

Tarefa	O agente da IDE cobre isso?	O que preenche a lacuna
Escrever uma chamada de API de rascunho	Sim, bem	Continue usando Cursor ou Copilot
Autocompletar o restante do cliente	Sim	Continue usando o agente
Conhecer seus endpoints, campos e autenticação reais	Não, ele adivinha a partir de padrões	Sua especificação, fornecida ao agente via MCP
Confirmar que a chamada retorna o que você espera	Não	Um cliente ou CLI que a execute
Reexecutar a verificação em cada commit na CI	Não	Um executor de testes determinístico
Mostrar a requisição exata que o agente enviou	Não	Um histórico de requisições inspecionável

As duas linhas mais importantes são as que o agente não alcança sozinho: conhecer sua API real e executar a chamada contra ela.

Lacuna 1: o agente precisa da sua especificação real, não de uma suposição

O erro mais comum de um agente de IDE é a invenção confiante.

Ele pode escrever:

POST /v1/users

Com este corpo:

{
  "name": "Ana Silva"
}

Esse formato parece plausível porque é comum em APIs públicas. Mas sua API pode expor:

POST /v1/accounts

Com este corpo:

{
  "full_name": "Ana Silva"
}

E exigir um cabeçalho de tenant:

X-Tenant-ID: tenant_123

O código pode parecer correto e compilar sem erros, mas falhar na primeira chamada real.

Um prompt melhor não resolve completamente esse problema. O agente não está sendo preguiçoso; ele não conhece seu esquema. A solução é disponibilizar o esquema para consulta.

É para isso que serve o Model Context Protocol. MCP é um padrão aberto que permite a um agente consultar contexto externo — como uma definição de API — enquanto escreve código.

Com a especificação conectada via MCP, o agente pode consultar:

caminhos reais;
parâmetros obrigatórios;
campos de request e response;
métodos HTTP;
esquemas de autenticação;
códigos de resposta esperados.

Em vez de adivinhar, ele usa a definição que você mantém.

O Apidog MCP Server oferece essa integração. Execute:

npx apidog-mcp-server

Depois, aponte o servidor para seu projeto de API ou arquivo OpenAPI. Sua especificação fica disponível no Cursor, GitHub Copilot, Claude Code ou Cline.

O fluxo é:

Mantenha sua definição OpenAPI como fonte de verdade.
Execute o servidor MCP.
Conecte o MCP ao agente da sua IDE.
Peça ao agente para consultar a especificação antes de implementar a chamada.
Revise o código gerado e execute a requisição.

Por exemplo, em vez de pedir apenas:

Crie uma função para cadastrar uma conta.

Prefira:

Consulte a especificação MCP e implemente a função de criação de conta.
Use o endpoint, os campos obrigatórios, a autenticação e os códigos de resposta definidos na API.

O agente passa a escrever chamadas para os seus endpoints, não para endpoints que ele lembra vagamente.

O comando não exige conta para testes iniciais. Você pode validar a fundamentação antes de fazer login. Consulte o guia de programação divertida com o Apidog MCP Server e, se MCP ainda for novo para você, veja o que é um cliente MCP.

A especificação fornecida é a definição OpenAPI que você já mantém. Não há um novo formato nem uma segunda fonte de verdade.

Lacuna 2: algo precisa executar o que o agente escreveu

Fundamentar o agente melhora o que ele escreve. Isso não garante que a chamada funcione no serviço real.

Um agente de IDE pode gerar um teste, mas você ainda precisa executar a requisição e verificar o resultado:

o endpoint retorna 200?
o corpo tem o formato definido pelo esquema?
a autenticação passa?
os cabeçalhos obrigatórios foram enviados?
uma mudança no contrato quebrou um fluxo existente?

Um cliente de API responde a essas perguntas executando a requisição, não apenas raciocinando sobre ela.

Quando essa verificação precisa se manter ao longo do tempo, ela deve ir para a CI. Nesse contexto, o executor precisa produzir o mesmo resultado — passou ou falhou — para o mesmo commit.

Um agente pode variar entre execuções. Por isso, ele não deve ser o mecanismo que bloqueia um merge.

É nesse ponto que o Apidog CLI se encaixa em um fluxo de trabalho de agente. Ele executa casos de teste salvos sem interface, retorna um código de saída e falha a build quando um contrato é quebrado.

O fluxo prático é:

Use o agente para gerar ou atualizar o código e os testes.
Salve os casos de teste da API.
Execute os testes com o CLI na CI.
Faça o pipeline falhar quando o código de saída indicar erro.

Em outras palavras:

Agente: elabora a verificação
CLI: executa a verificação de forma repetível
CI: bloqueia ou libera o merge

O CLI funciona sem login, então você pode integrá-lo ao pipeline ao lado do agente que escreveu os testes.

Vendo o que o agente enviou

Há uma terceira lacuna menor, mas importante para depuração.

Quando uma chamada gerada falha, o resumo do agente não é a verdade da comunicação HTTP. Ele pode afirmar que enviou um token válido enquanto a requisição real usou um token expirado.

Para investigar, você precisa inspecionar:

URL final;
método HTTP;
cabeçalhos enviados;
corpo da requisição;
código de status;
corpo da resposta.

Esse é o papel de um histórico de requisições inspecionável.

O Apidog também possui um Cliente MCP e um Depurador de Agente de IA para percorrer chamadas de agentes. O lado visual está explicado em depuração visual com o Cliente MCP Apidog.

É importante ser preciso: essas são superfícies de inspeção. O Apidog lê e verifica o que seu agente fez na camada da API. Ele não escreve nem executa o agente.

Quando um agente de IDE sozinho é suficiente

Há casos em que você pode dispensar um cliente de API completo:

Você está escrevendo um script descartável e uma chamada basta. O agente mais uma linha curl resolve.
Você está prototipando sozinho contra dois ou três endpoints que já conhece bem.
Ninguém mais depende do resultado.
O código não se integra a serviços de outras equipes ou empresas.

Nesses cenários, abrir uma plataforma de API completa pode exigir mais configuração do que a tarefa justifica.

O cliente ganha espaço quando a chamada precisa estar correta para outra pessoa:

você atende usuários reais;
outras equipes dependem do contrato;
a CI precisa permanecer verde;
um erro de resposta pode gerar custo ou incidente;
você precisa reproduzir e depurar requisições.

Isso cobre grande parte do trabalho em produção.

Onde o Apidog se encaixa

Em termos práticos, o Apidog é a camada de fundamentação e verificação em torno de qualquer agente que escreva seu código.

Ele é uma plataforma de API tudo em um, não uma estrutura de agentes e não é de código aberto. Não substitui Cursor ou Copilot. Em vez disso:

fornece a especificação real ao agente para reduzir suposições;
executa as chamadas e os testes gerados;
ajuda a inspecionar o tráfego HTTP real;
permite levar verificações para a CI.

Para começar em um fluxo de trabalho com IDE, use estas duas superfícies:

npx apidog-mcp-server

Use o MCP Server para disponibilizar sua especificação dentro do editor.

Depois, use o CLI para executar testes salvos no pipeline.

Design, mock inteligente e testes automatizados com asserções visuais estão na mesma plataforma quando o projeto cresce além de alguns endpoints. Baixe o Apidog se quiser acompanhar; o plano gratuito cobre a fundamentação e a execução.

Perguntas frequentes

O Copilot precisa do Postman ou de outro cliente de API?

Para um script rápido, não. Para algo que você entrega, geralmente sim.

O Copilot escreve a chamada, mas não conhece seus endpoints reais sem acesso à especificação e não confirma sozinho que a chamada funciona. Um cliente com servidor MCP e executor de testes cobre essas duas partes.

A resposta é a mesma para Copilot, Cursor, Claude Code ou Cline.

Como o agente conhece meus endpoints?

Somente se você fornecer essa informação.

Sem uma especificação, um agente de IDE adivinha a API a partir de padrões de treinamento. Por isso, ele pode inventar caminhos plausíveis, mas errados.

Forneça sua especificação via MCP com:

npx apidog-mcp-server

Assim, ele pode consultar rotas, campos e autenticação reais antes de escrever código.

O Cursor pode testar a API que ele escreveu?

Ele pode escrever um teste e executá-lo uma vez no chat, o que é útil para exploração.

Mas ele não é um mecanismo determinístico de aprovação ou reprovação para cada commit. Para isso, execute os testes com uma ferramenta como o CLI Apidog e condicione a CI ao código de saída.

Preciso de uma conta para experimentar?

Não.

O npx apidog-mcp-server e o CLI funcionam sem login, então você pode integrar a especificação à IDE e executar testes em um pipeline antes mesmo de fazer login.

O cliente de API autônomo está morto agora que os agentes escrevem chamadas?

Não, mas a função mudou.

Digitar requisições manualmente diminuiu. Fundamentar o agente na especificação real e verificar o que ele gerou se tornou mais importante.

Um cliente que apenas oferece uma superfície de digitação tem menos a fazer. Um cliente que fundamenta e verifica tem mais.

A verdadeira questão

Nunca foi Cursor versus um cliente, ou Copilot versus Apidog.

A questão é quem faz cada trabalho:

o agente de IDE rascunha a chamada e o código do cliente;
o MCP fornece a especificação real para que o rascunho use o contrato correto;
o cliente e o CLI executam a chamada e os testes;
a CI garante que o resultado permaneça verificável a cada commit.

Mantenha ambos. Comece com:

npx apidog-mcp-server

Depois, adicione o CLI Apidog para executar o que o agente escreve, ou experimente o Apidog gratuitamente.

A IA Substitui Testes de API? O Que Agentes de IA Podem e Não Podem Fazer

Lucas — Thu, 23 Jul 2026 06:45:02 +0000

Seu agente escreveu o teste. O Cursor sugeriu três casos extremos que você não havia pensado. O Copilot preencheu o corpo da requisição, e o Claude executou tudo uma vez e reportou “verde”. A pergunta é justa: se o agente faz tudo isso, a IA pode substituir completamente o teste de API?

Experimente o Apidog hoje

Não. A IA não substitui o teste de API, mas já substitui boa parte da autoria dos testes. Agentes elaboram casos, sugerem cenários extremos e geram payloads com eficiência. Porém, eles não garantem execução idêntica em cada commit, não bloqueiam merges com um resultado confiável e não decidem se um contrato está correto. Para isso, você precisa de uma ferramenta determinística e de revisão humana.

Essa separação responde a uma dúvida maior: você ainda precisa de uma ferramenta de API na era dos agentes de IA? Sim — mas o papel da ferramenta mudou. Use agentes para acelerar a autoria e ferramentas determinísticas para validar, executar e bloquear regressões.

Onde este artigo difere do guia prático

Se você procura instruções para gerar testes com agentes, consulte o guia sobre como usar agentes de IA para teste de API.

Este artigo trata de outra pergunta: quais partes do fluxo você pode delegar a um agente e quais precisam continuar em uma suíte determinística?

Uma implementação prática separa o trabalho assim:

O agente lê a especificação e cria um rascunho de testes.
Um desenvolvedor revisa cenários, asserções e regras de negócio.
Um runner headless executa a suíte no CI.
O pipeline bloqueia o merge usando o código de saída do runner.
Quando algo falha, você inspeciona a requisição e a resposta reais.

O que a IA faz bem em testes de API hoje

Agentes removem trabalho repetitivo de autoria. Use-os principalmente para criar e expandir artefatos de teste.

Elaborar uma primeira suíte a partir de uma especificação

Entregue ao agente um endpoint, uma definição OpenAPI ou uma resposta de exemplo. Ele pode gerar rapidamente:

verificações de status HTTP;
asserções de campos obrigatórios;
payloads de caminho feliz;
testes básicos de autenticação;
cenários de entrada inválida.

Por exemplo, para um endpoint POST /users, um agente pode começar com algo como:

pm.test("retorna 201", () => {
  pm.response.to.have.status(201);
});

pm.test("retorna um usuário com ID", () => {
  const body = pm.response.json();

  pm.expect(body).to.have.property("id");
  pm.expect(body.email).to.eql("dev@example.com");
});

Isso não elimina a revisão, mas elimina a página em branco.

Sugerir casos extremos

Peça explicitamente ao agente para listar condições de falha e limites. Ele costuma ser útil para ampliar a cobertura inicial com cenários como:

array vazio;
valor null em campo obrigatório;
token expirado;
payload com campos desconhecidos;
paginação no limite;
datas em fusos horários diferentes;
concorrência ou repetição de requisições;
respostas 429, 500 e timeout.

Um prompt prático:

Com base neste endpoint e nesta especificação OpenAPI, liste:
1. casos de validação;
2. limites de tamanho e paginação;
3. falhas de autenticação e autorização;
4. erros de rede e do servidor;
5. cenários que podem quebrar consumidores downstream.

O agente não encontrará tudo, mas ajuda a evitar que a cobertura fique limitada aos três cenários óbvios.

Gerar payloads e fixtures

Payloads grandes são uma boa tarefa para IA. Se uma requisição exige vinte campos ou se você precisa de dezenas de registros de teste, o agente pode gerar uma base rapidamente.

Para reduzir suposições, conecte a especificação real ao agente por um protocolo como o Model Context Protocol. Assim, o agente usa os campos e tipos definidos no seu contrato em vez de inventar um schema.

Por exemplo:

{
  "name": "Ana Silva",
  "email": "ana.silva@example.com",
  "role": "admin",
  "preferences": {
    "locale": "pt-BR",
    "timezone": "America/Sao_Paulo"
  }
}

Ainda valide se os dados são adequados para o domínio. Um payload sintaticamente válido pode continuar sendo inválido para sua regra de negócio.

Escrever asserções de primeiro rascunho

Agentes conseguem converter requisitos genéricos em asserções iniciais. Por exemplo, “verifique se a resposta contém um usuário válido” pode se tornar:

pm.test("schema mínimo do usuário", () => {
  const user = pm.response.json();

  pm.expect(user).to.have.property("id").that.is.a("string");
  pm.expect(user).to.have.property("name").that.is.a("string");
  pm.expect(user).to.have.property("email").that.is.a("string");
});

Revise essas asserções antes de aceitá-las. O agente vê o contrato disponível; ele não entende automaticamente quais campos são críticos para o produto, quais são compatíveis com versões anteriores ou quais regras têm impacto financeiro.

O que ainda exige uma ferramenta determinística

A diferença é simples: algumas tarefas exigem que a mesma entrada produza o mesmo resultado em todas as execuções.

Executar a suíte de forma idêntica em cada commit

Um merge gate precisa ser repetível. O mesmo commit deve aprovar ou falhar pelo mesmo motivo, independentemente de quem iniciou a execução.

Um agente pode executar testes e resumir o resultado, mas o seu texto, avaliação e até o veredito podem variar entre execuções. Isso é aceitável durante exploração e depuração. Não é aceitável para aprovar código automaticamente.

Bloquear o CI com uma aprovação ou falha real

O CI precisa de um processo que retorne um código de saída.

npm run test:api

if [ $? -ne 0 ]; then
  exit 1
fi

Uma mensagem como “parece bom” em uma janela de chat não é um sinal confiável para o pipeline. Um runner headless é: ele executa a suíte e retorna sucesso ou falha para a regra de merge.

Validar contrato e schema

A validação de contrato compara uma resposta contra uma definição fixa. Por exemplo:

um campo obrigatório desapareceu;
o tipo de id mudou;
um endpoint passou a retornar um status inesperado;
uma enumeração recebeu um valor incompatível.

Isso deve falhar sempre da mesma forma. A Especificação OpenAPI é onde esse contrato pode ser definido e compartilhado entre produtores e consumidores.

Reproduzir uma chamada com falha

Quando um teste falha, o resumo do agente não substitui os dados reais da execução. Você precisa inspecionar:

URL e método HTTP;
cabeçalhos enviados;
corpo da requisição;
status retornado;
corpo da resposta;
sequência e ordem das chamadas.

A diferença entre “o agente acredita que enviou um token válido” e “o cliente enviou um token expirado” só aparece ao inspecionar o tráfego real.

A divisão de 2026: IA vs. execução determinística

Tarefa de teste	Agente de IA hoje	Por quê
Elaborar uma primeira suíte de teste	Faz bem	Autoria a partir de uma especificação é um trabalho de padrões
Sugerir casos extremos	Faz bem	Amplia a cobertura além dos casos mais óbvios
Gerar payloads e fixtures	Faz bem	É rápido e mais preciso quando a especificação está conectada
Escrever asserções de primeiro rascunho	Faz, mas exige revisão	É um ponto de partida, não a decisão final
Executar a suíte da mesma forma em cada commit	Precisa de runner determinístico	A saída do modelo pode variar
Bloquear o CI com aprovação ou falha	Precisa de runner determinístico	Regras de merge precisam de código de saída real
Validar contrato e schema	Precisa de ferramenta determinística	É uma verificação fixa contra uma especificação fixa
Reproduzir uma chamada com falha	Precisa de cliente inspecionável	Um resumo não é a verdade do tráfego HTTP
Decidir se o contrato está correto	Precisa de humano	É uma decisão de produto, não apenas um teste

As primeiras quatro linhas são boas candidatas para agentes. As demais explicam por que “a IA substitui o teste de API” é uma manchete, não uma estratégia de engenharia.

Por que o modelo não pode ser o merge gate

O problema não é que LLMs sejam ruins. É que foram projetados para gerar saídas, não para servir como mecanismo determinístico de aprovação.

Um modelo pode variar sua resposta devido a fatores como:

amostragem;
temperatura;
contexto disponível;
variações no caminho de inferência;
mudanças no próprio modelo.

Essa variabilidade é útil para gerar ideias, testes e alternativas. Em um gate, ela é um risco.

Um gate confiável precisa ter esta propriedade:

mesmo commit + mesmo ambiente + mesma suíte = mesmo resultado

Portanto, use o modelo para criar ou melhorar o teste. Use um runner determinístico para executá-lo e impor o resultado. São responsabilidades diferentes.

Para entender os riscos de ignorar essa divisão, veja por que os agentes de IA quebram em produção.

Onde o Apidog se encaixa: inspecionar e verificar

O Apidog se encaixa na camada determinística. O objetivo não é substituir o agente, mas validar o trabalho que ele produziu.

O Apidog não escreve, executa ou toma decisões pelo seu agente, e não é de código aberto. Ele atende duas necessidades práticas: inspecionar o tráfego do agente e executar testes de API de forma repetível.

Inspecione o que o agente enviou

O Apidog AI Agent Debugger, lançado em maio de 2026, é uma interface de inspeção para execuções de agentes.

Use-o para visualizar:

chamadas ao LLM;
chamadas de ferramentas MCP;
interações multi-turno;
tráfego na camada de API.

Ele é um depurador, não um runtime. Seu papel é mostrar o que aconteceu no “wire” quando uma chamada falhar.

Execute testes no CI com um runner headless

O Apidog CLI executa casos de teste salvos de forma headless, retorna um código de saída real e falha a compilação quando encontra um contrato quebrado.

O fluxo de CI fica assim:

steps:
  - name: Executar testes de API
    run: apidog-cli run ./api-tests

A ideia é simples:

O agente cria ou atualiza a suíte.
Você revisa e salva os testes.
O CLI executa a suíte no pipeline.
O código de saída aprova ou bloqueia o merge.

O CLI pode ser executado sem login, permitindo conectá-lo ao pipeline antes de alguém fazer login.

Conecte o agente à sua especificação real

Execute:

npx apidog-mcp-server

Com isso, sua definição OpenAPI pode ficar disponível para ferramentas como Cursor, Copilot e Claude Code. O agente passa a elaborar testes contra endpoints e schemas reais, em vez de trabalhar com suposições.

O Apidog MCP Server pode ser experimentado sem conta.

Além disso, o mock inteligente do Apidog pode retornar respostas como 429, 500 ou timeout sob demanda. Isso permite testar os caminhos de recuperação que o código do agente precisa suportar.

Você pode baixar o Apidog para acompanhar; o plano gratuito cobre esses recursos.

Quando IA mais um script é suficiente

Nem todo teste exige uma plataforma completa. Um agente e uma chamada curl podem ser suficientes quando:

você está validando um script descartável;
uma única requisição responde à sua dúvida;
você está prototipando sozinho;
a superfície tem apenas dois ou três endpoints;
nenhuma outra equipe depende do contrato;
o código não segue para produção nem cruza o código de outra pessoa.

Por exemplo:

curl --fail \
  --request GET \
  --header "Authorization: Bearer $TOKEN" \
  https://api.example.com/health

Nesse contexto, um teste sugerido pelo agente e uma revisão manual podem bastar.

A camada determinística passa a ser necessária quando o risco aumenta:

o código entra no CI;
outras pessoas dependem da API;
consumidores downstream usam o contrato;
uma resposta incorreta causa custo, indisponibilidade ou perda de dados;
você precisa investigar falhas de forma reproduzível.

Perguntas frequentes

A IA pode substituir completamente o teste de API?

Não. Agentes podem elaborar testes, sugerir casos extremos e gerar payloads com eficiência. Porém, executar a suíte de forma idêntica em cada commit, bloquear um merge e decidir se o contrato está correto continua exigindo uma ferramenta determinística e revisão humana.

O que agentes de IA fazem bem no teste de API?

Eles são úteis para:

criar uma primeira suíte a partir de uma especificação;
sugerir casos extremos;
gerar payloads e fixtures;
escrever asserções iniciais para revisão.

Essas são tarefas de autoria, onde modelos são mais fortes.

Por que um agente não pode ser o CI gate?

Porque um gate precisa retornar o mesmo resultado para a mesma entrada. LLMs podem variar sua saída entre execuções. O CI deve usar o código de saída de um runner determinístico, não um resumo de chat.

Este artigo é igual ao guia prático sobre agentes de IA para teste de API?

Não. O guia prático mostra como obter testes com um agente. Este artigo define onde usar IA e onde manter execução determinística.

O Apidog AI Agent Debugger executa meu agente?

Não. Ele inspeciona a execução do agente, incluindo chamadas LLM, ferramentas MCP e interações multi-turno, para ajudar a depurar o que aconteceu na camada de API. É uma interface de inspeção, não um runtime de agente.

Preciso fazer login para executar testes no CI?

Não. O Apidog CLI executa casos de teste salvos de forma headless sem conta, retorna um código de saída real e falha a compilação em caso de contrato quebrado.

A linha real

“A IA pode substituir o teste de API?” mistura duas perguntas diferentes.

A IA pode escrever testes? Cada vez mais, sim. Ignorar essa capacidade desperdiça tempo de engenharia.

A IA pode executar esses testes de forma idêntica em cada commit, bloquear merges e preservar contratos? Não. Por design, um modelo é útil para elaborar alternativas, enquanto um gate precisa ser previsível.

Use os dois no fluxo certo:

Deixe o agente elaborar a suíte.
Peça ao agente casos extremos e payloads.
Revise as asserções e regras de negócio.
Execute a suíte com uma ferramenta determinística.
Valide o contrato no CI.
Inspecione o tráfego real quando algo quebrar.

Comece com:

npx apidog-mcp-server

Depois conecte a suíte ao Apidog CLI, ou experimente o Apidog gratuitamente.

DEV Community: Lucas

Claude Opus 5 x Sonnet 5: Qual te atende melhor?

Preços e a mudança de setembro

Especificações: quase o mesmo invólucro

Por que custo por token não é custo por tarefa

Exemplo de custo diário

Quando o Opus 5 justifica o preço

Quando o Sonnet 5 é suficiente

Tabela de decisão por carga de trabalho

O que nenhum dos modelos é

Como testar Opus 5 e Sonnet 5 no Apidog

Perguntas frequentes

Otimize seus Prompts para Claude Opus 5: Pare de Pedir a Dupla Verificação

Resumo

1. Remova instruções globais de verificação

Como manter verificações realmente necessárias

2. Defina limites de saída explicitamente

Limite respostas de chat

Limite documentos e entregáveis

Limite explicações em mudanças de código

3. Limite a delegação para subagentes

Para impedir delegação

Para permitir delegação controlada

4. Restrinja o escopo de tarefas cirúrgicas

5. Desative a narração de correções quando a saída for consumida por máquinas

Modos de falha com pensamento desabilitado

Chamadas de ferramenta retornadas como texto

Tags XML internas na resposta

Mitigação recomendada

Teste os prompts em vez de adivinhar

O limite honesto

Prompt de sistema base para tarefas sensíveis a custo

FAQ

Como Usar Claude Opus 5 de Graça

Caminho gratuito 1: assinatura Claude Pro ou Max

Caminho gratuito 2: créditos de teste e promoções de nuvem

Cuidado: thinking é ativado por padrão

Não existe API gratuita e ilimitada

O caminho pago mais barato

1. Use a Batch API para tarefas assíncronas

2. Ajuste output_config.effort

3. Ative cache de prompts para contexto repetido

4. Evite o modo rápido quando custo for prioridade

5. Não defina inference_geo sem necessidade

Comparação de custos em um relance

Testando os caminhos baratos no Apidog

O Opus 5 é mesmo o modelo que você deve otimizar?

Qual caminho escolher

FAQ

Claude Opus 5 Benchmarks: O Que os Números Realmente Dizem

Todas as alegações publicadas em uma tabela

Como interpretar alegações em proporção

1. Uma proporção esconde o denominador

2. Dobrar uma pontuação é mais fácil em escalas baixas

3. “Próximo melhor modelo” não identifica o baseline

4. Lacunas precisam de unidade e configuração

Alegações de custo por tarefa dependem da configuração

O teto que a Anthropic declara

O que benchmarks não medem

Variação de comportamento na migração

Comprimento da saída

Falhas quando o pensamento está desabilitado

Recalibração de esforço

Erro 400 em combinações inválidas

O que testar no seu ambiente

1. Monte um conjunto de tarefas reais

2. Fixe a configuração

3. Meça custo por tarefa resolvida

4. Execute uma varredura de esforço

5. Teste loops agênticos, não só prompts únicos

6. Compare com seu modelo atual

7. Registre recusas separadamente

Executando a avaliação no Apidog

Resumo honesto

FAQ

Os benchmarks do Claude Opus 5 são verificados independentemente?

Qual é a maior alegação de benchmark do Opus 5?

O Claude Opus 5 é o modelo Claude mais capaz?

Quanto melhor é o Opus 5 em tarefas científicas?

O Opus 5 vence o Fable 5?

Cuidado: `thinking` é ativado por padrão

2. Ajuste `output_config.effort`

5. Não defina `inference_geo` sem necessidade

O que o parâmetro `effort` realmente faz

`effort` não controla verbosidade

Os cinco níveis de `effort`

Como `xhigh` e `max` interagem com `max_tokens`

O erro 400 ao combinar `thinking` desativado com `xhigh` ou `max`

Como executar uma varredura de `effort` nas suas avaliações

Qual é o nível de `effort` padrão no Claude Opus 5?

Quais são os cinco níveis de `effort`?

Por que minha requisição retorna erro 400 com `effort: "xhigh"`?

Posso reutilizar minhas configurações de `effort` do Opus 4.8 no Opus 5?

Diminuir o `effort` deixa as respostas mais curtas?

Qual valor de `max_tokens` devo usar com `xhigh` ou `max`?

1. `thinking` está ativado por padrão e `max_tokens` continua limitando tudo

2. HTTP 400: `thinking` desabilitado com `effort` `xhigh` ou `max`

Correção B: manter `thinking` desativado

3. Reavalie os níveis de `effort`

Por que recebo HTTP 400 após mudar para `claude-opus-5`?