Preço de lançamento (até 25 de dez.), garantido enquanto você continuar assinando: Go por $10/mês (de $20), Plus com Opus 5.5 por apenas $30/mês (de $50)Assinar agora →
Chat de textocontexto de 1M

Claude Sonnet 5.5

API do Claude Sonnet 5.5 pela metade da tabela da Anthropic: $1 de entrada, $5 de saída por 1M de tokens. O que mudou em relação ao Sonnet 5, benchmarks, breaking changes e código funcional.

Preço / 1M tokensPoupe 50%
OficialAIReiter
Entrada$2.00$1.00
Saída$10.00$5.00
Leitura de cache$0.20$0.10
Criação de cache$2.50$1.25
Leia-me
Entrada
Limita o comprimento da resposta. Os modelos de raciocínio também contam o seu pensamento.
claude-sonnet-5-5
Saída

A codebase you don't know is a risk, not a hurdle. The plan should burn down that risk in order: understand, run, trace, spike, then make the change small enough that "production-ready" is a property you can demonstrate, not a hope.

Here are the first five steps, with the evidence you collect at each.

Step 1 — Get it building and the baseline green (half day)
Read the README, the manifest(s), the CI config, and any architecture docs. Boot the app locally, run the full test suite, run the linter/typechecker.
Evidence: The exact commands that reproduce a clean build and a passing test suite from a fresh checkout (recorded output, not memory of it). A one-page map you wrote yourself: where the entry points are, the layers, the build/test toolchain, and the main risks to your feature (e.g. "this touches cron jobs and payments").

Step 2 — Trace the smallest end-to-end slice that resembles your feature (half day)
Don't start with your feature. Pick a neighboring one that already works and follow it from entry to persistence. Note the conventions along the way: how errors surface, how config is injected, how logging is done, how tests are written.
Evidence: An annotated trace — file → function → what it does — for that slice. A written list of "conventions I must follow" (not intuitions; things you observed in real code). A named shortlist of the 3–5 files you will actually touch. If you can't produce this trace, you're not ready to write code.

Step 3 — Spike the core path (day 2)
Build the ugly version: hardcoded values, no error handling, no tests. The purpose is to confirm the path you traced in step 2 is real and to surface what you didn't know you didn't know.
Evidence: A working spike demonstrating the feature's central data path, alongside a list of every assumption the spike broke and what you corrected. That correction list is the most valuable document in this whole plan.

Step 4 — Write the contract before the code (half of day 2 / day 3)
Once the spike proves the path, pin down what production needs: the inputs/outputs, the error cases, where it sits in the conventions from step 2. Then write the tests — they'll be red, but they're the specification.
Evidence: A one-to-two-page design doc, an agreed interface/API shape (with the team if there is one), and a red test suite that encodes intended behavior. If you can't write the contract without consulting the code, you haven't finished step 2.

Step 5 — Implement in small, verified increments (days 3–4)
Replace the spike with the real thing in small commits, each one keeping the suite green, leaning on the existing patterns. Run lint/tests/typecheck per commit — CI, not just locally — and exercise the actual path against a real instance (staging or a local environment that isn't stubbed).
Evidence: A branch with progressive commits, each green in CI; coverage on the new code; something that proves it works against reality (a test result, a log trace, a screenshot); and a review by at least one person who knows the codebase. The review counts as evidence — an unfamiliar codebase has tribal knowledge you cannot extract from the files alone.

Steps 6+ would be the things that actually make it "shipped": a migration plan and its rollback, feature flagging, observability, the release and post-release verification. But the first five get you to a reviewed, green, working slice in staging — which is the point at which you can say "this will work in production" with evidence behind it, instead of a guess.

Gerado em42.7s
Token de entrada134
Token de saída2,354
Tokens / s55.13
TTFT-

Executar abre o AI Chat com este prompt. São necessários início de sessão e créditos.

Detalhes do modelo

Use a mesma chave de modelo no Playground, nas solicitações da API e nos fluxos de trabalho internos.

ID do modelo
claude-sonnet-5-5
Provedor
Anthropic
Protocolo
Anthropic Messages
Janela de contexto
1,000,000 tokens
Saída máxima
128,000 tokens
Token de entrada
100 créditos / 1 mi de tokens
Token de saída
500 créditos / 1 mi de tokens
Leitura de cache
10 créditos / 1 mi de tokens
Gravação de cache
125 créditos / 1 mi de tokens

O que há de novo no Claude Sonnet 5.5

A Anthropic lançou o Claude Sonnet 5.5 em 28 de setembro de 2026 como uma atualização direta do Sonnet 5. O preço de tabela não mudou; o trabalho que ele pode realizar e a quantidade de tokens que consome para isso, sim.

Próximo do Opus 5.5 em trabalho intelectual

A Anthropic relata uma pontuação GDPval-AA de 1844 para o Sonnet 5.5, dois pontos atrás do Opus 5.5 (1846) e cerca de 400 pontos à frente do Sonnet 5 (1449). A Anthropic também afirma que o Opus 5.5 ainda é claramente superior em tarefas abertas que exigem julgamento contínuo.

Um grande avanço em programação

No CursorBench 4.0, a Anthropic relata 55,5% para o Sonnet 5.5, contra 34,1% para o Sonnet 5 e 57,8% para o Opus 5.5. A Anthropic o posiciona para o trabalho diário bem delimitado: criação de recursos, correção de bugs e produção de documentos, slides e planilhas.

Menos tokens para a mesma tarefa

Os primeiros clientes relataram economia em suas próprias cargas de trabalho: o Slack observou cerca de 14% menos tokens de saída sem alterações nos prompts, e a Balyasny Asset Management mediu aproximadamente 121 mil tokens por resposta contra 497 mil no Sonnet 5 em 2.441 tarefas financeiras.

Saída mais rápida, mesmo tokenizer

A Anthropic afirma que a saída é mais de 30% mais rápida que a do Sonnet 5; a Artificial Analysis mediu cerca de 139 tokens de saída por segundo. O tokenizer não mudou, portanto o mesmo texto conta como o mesmo número de tokens em ambos os modelos.

Claude Sonnet 5.5 vs Sonnet 5 vs Opus 5.5

Todos os três funcionam com a mesma chave do AIReiter. Em resumo: saia do Sonnet 5 assim que suas solicitações passarem pelas verificações de migração abaixo e mantenha o Opus 5.5 para os trabalhos abertos mais difíceis.

Sonnet 5.5 vs Sonnet 5: mesmo preço, mais resultados

Ambos custam oficialmente $2 de entrada e $10 de saída por milhão de tokens. O Sonnet 5.5 obtém pontuações mais altas nos benchmarks de programação e trabalho intelectual acima e geralmente conclui tarefas com menos tokens, portanto a mesma tarefa tende a custar menos.

Sonnet 5.5 vs Opus 5.5: metade do preço

Aqui, o Sonnet 5.5 custa $1,00 de entrada e $5,00 de saída por milhão de tokens; o Opus 5.5 custa $2,00 e $10,00. Ambos possuem uma janela de contexto de 1M de tokens e saída máxima de 128K, portanto migrar exige apenas alterar o campo do modelo e nada mais.

Quando o Opus 5.5 ainda vale a pena

Tarefas longas e ambíguas em que o modelo precisa planejar, notar seus próprios erros e continuar em frente. A Base44 relatou 3,6 iterações por criação de aplicativo no Sonnet 5.5 contra 7,7 no Opus 5, portanto tente o Sonnet 5.5 primeiro e escale apenas as tarefas que falharem.

Quando permanecer no Sonnet 5 por enquanto

Se o seu código desativa o thinking, força uma ferramenta específica ou define temperature, essas solicitações falharão no Sonnet 5.5 até que você as altere. Ferramentas de segurança também podem apresentar mais recusas. Corrija isso primeiro e depois faça a migração.

Migrando do Sonnet 5: o que agora retorna erro

Mudar a string do modelo para claude-sonnet-5-5 nem sempre é suficiente. Estes formatos de requisição funcionavam no Sonnet 5 e são rejeitados pelo Sonnet 5.5.

thinking: disabled retorna 400

O adaptive thinking está sempre ativado. Substitua {"type": "disabled"} por {"type": "between_tools"}, a configuração mais baixa, que ignora o thinking antes da primeira resposta. between_tools funciona apenas com effort em low, medium ou high; para xhigh ou max, omita thinking ou envie {"type": "adaptive"}.

Budgets manuais de thinking retornam 400

thinking: {"type": "enabled", "budget_tokens": N} é rejeitado. Em vez disso, controle a profundidade com o nível de effort. Os tokens de thinking continuam sendo descontados de max_tokens e cobrados como saída, portanto aumente max_tokens se as respostas começarem a ser cortadas.

Escolha forçada de ferramenta é rejeitada

Um tool_choice que força uma ferramenta específica agora gera erro. Use a escolha automática de ferramentas com definições estritas e deixe o modelo decidir quando chamar.

temperature, top_p e top_k personalizados retornam 400

Apenas a amostragem padrão é aceita. Remova esses campos da solicitação em vez de defini-los com valores fixos. Uma mudança joga a seu favor: o prompt mínimo armazenável em cache cai de 1.024 para 512 tokens.

Escolha o nível de esforço antes de colocar em produção

O esforço (effort) agora é o principal controle de custo e latência. Existem cinco níveis: low, medium, high, xhigh e max.

O padrão da API é high

Se você não enviar o nível de esforço, a API roda em high. O Claude Code e os aplicativos Claude usam medium por padrão. Defina output_config.effort explicitamente para que sua fatura não dependa de um valor padrão.

max é caro

No esforço max, a Artificial Analysis mediu $7.60 por tarefa ao preço de tabela e 410M de tokens de saída em seu índice, contra uma mediana de 88M. As alegações de eficiência da Anthropic são sobre os níveis mais baixos, não sobre max.

Comece em medium, meça e depois avance

Execute suas tarefas reais em medium, avalie a qualidade e aumente o nível apenas quando necessário. Para loops de ferramentas sensíveis à latência, low ou medium com thinking between_tools mantém as primeiras respostas rápidas.

Preços da API do Claude Sonnet 5.5 no AIReiter

Gerir chaves API →

Cada item é cobrado com 50% de desconto sobre a tabela da Anthropic. Mesmo modelo, mesmo protocolo Messages.

01Metade do preço de tabela em cada item

Entrada: $1.00 (tabela: $2.00). Saída: $5.00 (tabela: $10.00). Leituras de cache: $0.10 (tabela: $0.20). Gravações de cache: $1.25 (tabela: $2.50). Todos por milhão de tokens.

02Uma chamada real: $1.50 em vez de $3.00

Um milhão de tokens de entrada mais cem mil tokens de saída custam $1.50 aqui e $3.00 na tabela da Anthropic. A mesma chamada no Opus 5.5 aqui custa $3.00.

03Faturado com base nos tokens realmente usados

Uma estimativa é retida quando a chamada começa e, em seguida, ajustada com a contagem real de tokens quando a resposta é concluída, estornando a diferença. A taxa é a mesma do primeiro ao milionésimo token; não há faixa de preço diferenciada para contexto longo.

Experimente Claude Sonnet 5.5 em 3 passos

  1. 01

    Obtenha uma chave e aponte o cliente para o AIReiter

    Crie uma chave de API no seu painel do AIReiter. Nos SDKs oficiais da Anthropic, defina a URL base como https://aireiter.com/api — o SDK adiciona /v1/messages automaticamente.

  2. 02

    Envie uma requisição com curl

    curl https://aireiter.com/api/v1/messages \ -H "x-api-key: $AIREITER_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-sonnet-5-5", "max_tokens": 4096, "output_config": {"effort": "medium"}, "messages": [{"role": "user", "content": "Hello"}] }'

  3. 03

    Ou use o SDK em Python

    from anthropic import Anthropic client = Anthropic(api_key="YOUR_AIREITER_KEY", base_url="https://aireiter.com/api") msg = client.messages.create( model="claude-sonnet-5-5", max_tokens=4096, messages=[{"role": "user", "content": "Hello"}], ) print(msg.content[0].text)

FAQ

01Quando o Claude Sonnet 5.5 foi lançado e qual é o ID do modelo?

A Anthropic o lançou em 28 de setembro de 2026. O ID do modelo na API é claude-sonnet-5-5, e a data de corte do seu conhecimento é junho de 2026.

02Qual é a janela de contexto e o limite máximo de saída?

Uma janela de contexto de 1M de tokens e até 128K tokens de saída por requisição. Aceita entrada de texto e imagem e retorna texto.

03Quanto custa a API do Claude Sonnet 5.5?

A Anthropic lista US$ 2 para entrada e US$ 10 para saída por milhão de tokens, o mesmo que o Sonnet 5. O AIReiter cobra a metade: US$ 1 para entrada, US$ 5 para saída, US$ 0,10 para leituras de cache e US$ 1,25 para gravações de cache.

04Posso desativar o raciocínio?

Não totalmente. thinking disabled retorna um erro 400. A configuração mais baixa é between_tools, que funciona com esforço baixo, médio e alto.

05O Sonnet 5.5 é melhor que o Sonnet 5?

Nos benchmarks de programação e tarefas de conhecimento divulgados pela Anthropic, sim, por uma ampla margem, pelo mesmo preço de tabela. Verifique as alterações de migração acima antes de mudar, pois alguns formatos de requisição do Sonnet 5 agora falham.

06Por que minha pergunta sobre segurança foi recusada ou respondida pelo Sonnet 5?

O Sonnet 5.5 é o primeiro Sonnet a vir com as proteções de cibersegurança usadas nos modelos mais avançados da Anthropic. Algumas requisições de maior risco recorrem ao Sonnet 5 como fallback, e tarefas de segurança benignas podem sofrer mais recusas. Este é um comportamento upstream.

07Preciso de uma conta da Anthropic?

Não. Uma chave do AIReiter funciona no endpoint do AIReiter, e você pode testar o modelo no playground nesta página antes de escrever qualquer código.

08Quais APIs são suportadas?

Anthropic Messages em /api/v1/messages é o contrato principal, com suporte a streaming. Chat Completions no estilo OpenAI e a Responses API também são atendidas, e /api/v1/models lista os modelos disponíveis para a sua chave.