Claude Fable 5.1 foi lançado em 1º de setembro de 2026, e o ID do modelo da API é a string exata claude-fable-5-1, sem sufixo de data. Ele custa os mesmos $10 por milhão de tokens de entrada e $50 por milhão de tokens de saída que o Fable 5, com leituras de cache reduzidas para $0,25 por milhão, e apresenta três mudanças que quebram a compatibilidade e que o Fable 5 não tinha.
Este guia percorre todo o caminho: obtendo uma chave, enviando uma primeira solicitação, controlando o esforço, streaming, uso de ferramentas sem tool_choice forçado, fallbacks de recusa, atualizações de progresso e lendo o objeto usage para confirmar que seu cache está funcionando com a nova taxa. Cada solicitação é HTTP puro com JSON, então você pode construí-la e depurá-la no Apidog antes de ser incorporada ao código da aplicação.
Se você está migrando um serviço Fable 5 ou Opus 5 existente em vez de começar do zero, leia o guia completo de migração junto com este. Para uma visão geral do modelo, comece com o que é o Claude Fable 5.1.
Antes da sua primeira chamada: três coisas que retornam 400
1. O pensamento não pode ser configurado, apenas direcionado. O Fable 5.1 executa pensamento adaptativo em cada solicitação. Omita o campo thinking ou envie {"type": "adaptive"}. Ambos {"type": "disabled"} e {"type": "enabled", "budget_tokens": N} retornam um 400. Se você está vindo do Opus 5, onde disabled era aceito em esforço high ou inferior, remova-o e controle os gastos com output_config.effort.
2. O uso forçado de ferramentas foi removido. tool_choice: {"type": "any"} e {"type": "tool", "name": "..."} retornam tool_choice: type "tool" and "any" are not supported for this model. A solução está na etapa de uso de ferramentas abaixo.
3. Sua organização precisa de retenção de dados de 30 dias. O Fable 5.1 é um Modelo Abrangente (Covered Model). Uma solicitação de uma organização ou workspace com retenção de dados zero retorna 400 invalid_request_error sem outra pista. Se sua primeira chamada falhar e o corpo parecer correto, verifique a retenção antes de qualquer outra coisa.
Os três estão documentados no Novidades no Claude Fable 5.1 da Anthropic.
Passo 1: Obtenha uma chave de API
Faça login no Claude Console, abra a seção de chaves de API das configurações da sua organização e crie uma chave. Copie-a uma vez; você não poderá lê-la novamente mais tarde. Exporte-a em vez de colá-la no código:
export ANTHROPIC_API_KEY="sk-ant-..."
No Apidog, armazene-a como uma variável de ambiente chamada ANTHROPIC_API_KEY e referencie-a como {{ANTHROPIC_API_KEY}} no cabeçalho, para que a chave nunca seja salva no corpo de uma solicitação.
Passo 2: Envie sua primeira solicitação
Crie um POST para https://api.anthropic.com/v1/messages com três cabeçalhos: x-api-key, anthropic-version: 2023-06-01 e content-type: application/json.
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-1",
"max_tokens": 16000,
"messages": [
{"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}
]
}'
A mesma chamada em Python com o SDK oficial:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
messages=[{"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}],
)
if response.stop_reason == "refusal":
print("declined:", response.stop_details.category if response.stop_details else None)
else:
for block in response.content:
if block.type == "text":
print(block.text)
Dois hábitos a serem desenvolvidos desde a primeira chamada. Verifique stop_reason antes de ler content, porque uma recusa do classificador é um HTTP 200 com um array de conteúdo vazio. E dê espaço real a max_tokens. Ele limita os tokens de pensamento mais os tokens de resposta juntos, e o pensamento está sempre ativo, então um valor apertado ajustado para um modelo sem pensamento será truncado aqui.
A resposta contém um bloco thinking cujo texto está vazio sob o display padrão de "omitted". Isso é esperado. Passe-o de volta inalterado na próxima vez.
Passo 3: Controle o custo e a profundidade com o esforço
O parâmetro effort é a principal alavanca no Fable 5.1. Ele vai dentro de output_config, não no nível superior, e aceita low, medium, high, xhigh e max. O padrão é high.
{
"model": "claude-fable-5-1",
"max_tokens": 16000,
"output_config": {"effort": "medium"},
"messages": [{"role": "user", "content": "Summarize this changelog in five bullets."}]
}
Orientação da Anthropic: comece com high, depois teste os outros com suas próprias avaliações, e refaça o teste mesmo se você já o fez no Fable 5, porque os nomes dos níveis não correspondem à mesma quantidade de pensamento entre os modelos. A afirmação deles é que medium se aproxima do Fable 5 com custo menor e que low é frequentemente competitivo com Opus e Sonnet em custo por tarefa. Dois comportamentos específicos do esforço a serem observados: em low, o Fable 5.1 chama ferramentas de busca e recuperação com menos frequência e responde mais da memória, e em xhigh e max ele pode rascunhar um entregável longo em seu pensamento e depois escrevê-lo novamente, então defina max_tokens para ambos.
Mudando o esforço no meio da conversa (beta). No Fable 5, mudar o esforço de nível superior entre as solicitações descartava o prefixo em cache. No Fable 5.1, uma mensagem role: "system" com conteúdo vazio e um output_config muda o esforço a partir da próxima vez do usuário sem invalidar o cache. Isso requer o cabeçalho beta mid-conversation-output-config-2026-07-01 e o namespace client.beta.messages.
response = client.beta.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
output_config={"effort": "high"},
betas=["mid-conversation-output-config-2026-07-01"],
messages=[
{"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
{"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
{"role": "system", "content": [], "output_config": {"effort": "low"}},
{"role": "user", "content": "Summarize the plan in one sentence."},
],
)
Diminuir o esforço dessa forma é confiável. Aumentá-lo funciona melhor para grandes saltos, como de low para xhigh. O guia de parâmetros de esforço para Opus 5 cobre os cinco níveis em profundidade, e a mesma semântica se aplica aqui.
Passo 4: Faça o streaming da resposta
O Fable 5.1, em tarefas difíceis, pode levar minutos com esforço maior, então faça streaming de qualquer coisa que possa ser longa. O SDK exige streaming para valores de max_tokens próximos ao limite de 128.000 para evitar timeouts HTTP.
with client.messages.stream(
model="claude-fable-5-1",
max_tokens=64000,
messages=[{"role": "user", "content": "Write a test plan for a rate-limited public API."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final = stream.get_final_message()
print(final.stop_reason, final.usage.output_tokens)
No Apidog, as respostas de streaming são renderizadas à medida que chegam, o que é a maneira mais rápida de ver quanto tempo uma rodada de esforço high gasta pensando antes do primeiro token de texto.
Passo 5: Adicione o uso de ferramentas sem forçá-lo
Defina ferramentas da mesma forma que no Fable 5. O que muda é como você garante uma chamada. No Fable 5, você poderia forçá-la com tool_choice: {"type": "tool", ...}. No Fable 5.1, isso retorna um 400, porque uma chamada forçada pularia o pensamento e o modelo escreveria seu raciocínio nos argumentos.
A substituição tem três partes: mantenha tool_choice em auto, nomeie a ferramenta na instrução e defina strict: true (uso estrito de ferramentas) na ferramenta com additionalProperties: false no schema para que os argumentos sempre sejam validados.
record_summary_tool = {
"name": "record_summary",
"description": "Record the structured summary of the document.",
"strict": True,
"input_schema": {
"type": "object",
"properties": {"summary": {"type": "string"}},
"required": ["summary"],
"additionalProperties": False,
},
}
response = client.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
tools=[record_summary_tool],
tool_choice={"type": "auto"},
messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."}],
)
Se a chamada forçada existia apenas para obter JSON de volta, use saídas estruturadas (output_config.format) em vez de uma ferramenta. Se sua aplicação, e não o usuário, exigir uma chamada específica na vez atual de uma conversa com várias rodadas, anexe uma mensagem role: "system" após a última vez do usuário que nomeia a ferramenta e diz que a chamada é necessária, e mantenha essa mensagem no histórico depois. tool_choice: {"type": "none"} ainda funciona para uma rodada que não deve chamar ferramentas.
O loop de agente em si permanece inalterado: quando stop_reason é tool_use, execute cada bloco tool_use, retorne todos os blocos tool_result em uma mensagem do usuário, e anexe a resposta do assistente exatamente como foi retornada, incluindo os blocos de pensamento. Essa última cláusula é mais importante no Fable 5.1 do que em qualquer modelo anterior, pelas razões que o guia de pensamento preservado explica.
Um comportamento a observar: em loops longos onde as próximas leituras independentes são apenas implicadas pela tarefa, o Fable 5.1 pode emitir uma chamada de ferramenta por turno onde o Fable 5 agrupava várias. A correção da Anthropic é um lembrete de uma frase anexado após cada mensagem de resultado da ferramenta: “Primeiro liste privadamente o que você precisa em seguida; depois solicite cada item que não dependa do resultado de outro nesta única resposta.” Envie-o como uma mensagem de sistema com escopo de turno (clear_at: "next_user_message", cabeçalho beta mid-conversation-system-clear-at-2026-08-21) e deixe cada cópia anterior no lugar.
Passo 6: Lide com recusas usando fallbacks
O Fable 5.1 executa classificadores de segurança. Uma solicitação recusada retorna como HTTP 200 com stop_reason: "refusal" e um objeto stop_details nomeando a categoria: cyber, bio, frontier_llm, reasoning_extraction ou general_harms. Uma recusa antes de qualquer saída não é faturada.
Opte por fallbacks por padrão. A forma mais simples é fallbacks: "default" com o cabeçalho beta server-side-fallback-2026-07-01, que tenta novamente uma solicitação recusada no modelo que a Anthropic recomenda para essa categoria. Para o Fable 5.1, os alvos permitidos são claude-opus-4-8 e claude-opus-5.
response = client.beta.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
fallbacks="default",
betas=["server-side-fallback-2026-07-01"],
messages=[{"role": "user", "content": "Audit this authentication middleware for logic bugs."}],
)
fallback_ran = any(
entry.type == "fallback_message" for entry in (response.usage.iterations or [])
)
if fallback_ran and response.stop_reason != "refusal":
print("served by", response.model)
A resposta nomeia o modelo de serviço em seu campo model de nível superior, e um bloco de conteúdo fallback marca a transição. Mantenha esse bloco onde ele apareceu ao ecoar a rodada de volta. Duas limitações: fallbacks é rejeitado na API de Lotes, e não está disponível no Bedrock, Google Cloud ou Foundry, onde você registra o BetaRefusalFallbackMiddleware do SDK no cliente. O guia de tratamento de recusas cobre faturamento, roteamento persistente e a tentativa manual com crédito de fallback.
Passo 7: Obtenha atualizações de progresso durante turnos longos
Entre as chamadas de ferramenta, o Fable 5.1 escreve notas curtas sobre o que encontrou e o que fará em seguida. Cada uma chega como seu próprio bloco thinking imediatamente antes da chamada da ferramenta, e sob o display padrão esses blocos estão vazios. Defina display: "updates" com o cabeçalho beta thinking-display-updates-2026-08-18 para recebê-los como texto enquanto o raciocínio em si permanece oculto.
{
"model": "claude-fable-5-1",
"max_tokens": 16000,
"thinking": {"type": "adaptive", "display": "updates"},
"tools": [...],
"messages": [{"role": "user", "content": "Review the PRs open against our billing service."}]
}
Qualquer bloco thinking com texto não vazio é então uma linha de status que você pode renderizar. O Fable 5.1 escreve menos deles do que o Fable 5, então, se sua UI depender de narração, remova também qualquer linha de prompt que diga ao modelo para reter as descobertas para a resposta final.
Passo 8: Leia o objeto usage para a taxa de cache de $0.25
Cache de prompt é onde a mudança de preço do Fable 5.1 se manifesta. Coloque cache_control no prefixo estável e confirme os acertos em usage:
response = client.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
system=[{"type": "text", "text": LONG_STABLE_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}],
messages=[{"role": "user", "content": "Which endpoints in the spec lack an error schema?"}],
)
u = response.usage
print(u.input_tokens, u.cache_creation_input_tokens, u.cache_read_input_tokens)
No primeiro envio, cache_creation_input_tokens é diferente de zero (faturado a $12,50 por milhão para o TTL de 5 minutos). No segundo envio, dentro de cinco minutos, cache_read_input_tokens deve ser diferente de zero, faturado a $0,25 por milhão. Se permanecer zero em solicitações idênticas, algo no prefixo muda a cada vez: um timestamp no prompt do sistema, JSON não ordenado, um array de ferramentas variável. O prompt mínimo armazenável em cache é de 512 tokens.
Duas informações sobre cache específicas para este modelo. Como uma falha custa 40x um acerto, manter o cache aquecido importa mais do que no Fable 5, e tanto o esforço por mensagem quanto as mensagens de sistema com escopo de turno existem em parte para que você possa mudar as coisas no meio da sessão sem um reset. E as mesmas edições que resetam o cache (reconstruir system, editar turnos anteriores) agora também invalidam os blocos de pensamento, então a disciplina de 'apenas adicionar' compensa duas vezes.
Teste e depure todo o fluxo no Apidog
Salve cada etapa acima como uma solicitação em uma coleção do Apidog: primeira chamada, variantes de esforço, streaming, loop de ferramentas, fallback, verificação de cache. Use variáveis de ambiente para a chave e para model, de modo que alternar uma coleção inteira entre claude-fable-5 e claude-fable-5-1 seja uma única edição. Em seguida, adicione asserções: stop_reason não é refusal em seus prompts de teste benignos, usage.cache_read_input_tokens é maior que zero na segunda solicitação de cache, e nenhuma entrada de input_transformations tem reason: "prefix_binding_mismatch" ao executar com o cabeçalho de ligação de pensamento. Execute a coleção antes e depois de qualquer alteração no arnês. Baixe o Apidog para configurá-lo; a mesma coleção funciona como uma verificação de CI através do Apidog CLI.
Erros e armadilhas que você encontrará
- 400
tool_choice: type "tool" and "any" are not supported for this model.Mude paraautomais uma instrução estrict: true. - 400 em
thinking: {"type": "disabled"}. Remova o campo. Diminua o esforço em vez disso. - 400
invalid_request_errorcom um corpo válido. Verifique se a organização ou workspace tem retenção de 30 dias. - 400
Invalid signature in thinking block. The block is bound to a different conversation.Seu código editou um turno anterior, o prompt do sistema ou o array de ferramentas. Consulte o guia de pensamento preservado. - Texto de pensamento vazio e silencioso. Esperado sob
display: "omitted". Use"summarized"ou"updates"se você for renderizá-lo. - Leituras de cache em zero. Um prefixo volátil. Audite por timestamps e objetos não ordenados.
- A solicitação da Camada de Prioridade falha na validação. O Fable 5.1 não suporta a Camada de Prioridade. O Fable 5 suporta.
FAQ
Qual é o ID do modelo para a API Claude Fable 5.1? claude-fable-5-1. No Amazon Bedrock, é anthropic.claude-fable-5-1; Google Cloud, Microsoft Foundry e Claude Platform na AWS usam claude-fable-5-1.
Preciso de um cabeçalho beta para usar o Claude Fable 5.1? Não. O modelo base, pensamento adaptativo, esforço, ferramentas e caching funcionam todos com o cabeçalho padrão anthropic-version: 2023-06-01. Cabeçalhos beta são necessários apenas para esforço por mensagem, mensagens de sistema com escopo de turno, atualizações de progresso, fallbacks do lado do servidor e os controles de ligação de pensamento.
Posso forçar uma chamada de ferramenta no Claude Fable 5.1? Não. tool_choice any e tool retornam um 400. Use auto, nomeie a ferramenta no prompt e defina strict: true para argumentos válidos de esquema, ou use saídas estruturadas para extração de JSON.
Qual é a saída máxima na API Claude Fable 5.1? 128.000 tokens na Messages API. Faça streaming para qualquer coisa grande. A API de Lotes beta de 300.000 tokens não está listada para o Fable 5.1.
Como vejo as leituras de cache mais baratas? Observe usage.cache_read_input_tokens em uma solicitação repetida. Esses tokens são faturados a $0,25 por milhão no Fable 5.1, versus $1 no Fable 5 e $0,50 no Opus 5. O detalhamento de preços explica os números.
O guia da API Fable 5 ainda se aplica? Em grande parte. O guia da API Fable 5 cobre o mesmo endpoint, mas seus exemplos de uso forçado de ferramentas agora retornam um 400 e ele é anterior ao esforço por mensagem e às atualizações de progresso.