A Anthropic lançou o Claude Fable 5 em 9 de junho de 2026, e se você desenvolve código para viver, a API do Claude Fable 5 é a parte que te interessa. Ela roda na mesma API de Mensagens que você já conhece, então a string do modelo é a única coisa que realmente muda: claude-fable-5. Este guia percorre todas as chamadas que você precisa para obter um código funcional em frente a uma resposta real, desde uma solicitação curl de uma linha até streaming, uso de ferramentas, tratamento de erros e cálculo de custos. Se você já integrou com Claude antes, a estrutura parecerá familiar. Se você migrou de um modelo mais antigo, a mudança é principalmente uma troca de string, da mesma forma que foi para a API do Claude Opus 4.8.
TL;DR
Obtenha uma chave de API no Anthropic Console, defina-a como ANTHROPIC_API_KEY, depois faça um POST para a API de Mensagens com model: "claude-fable-5", um valor de max_tokens e um array messages. Use o SDK oficial da Anthropic para Python ou TypeScript, ou HTTP puro. Faça stream de saídas longas para não atingir o tempo limite da solicitação. O preço é de US$10 por milhão de tokens de entrada e US$50 por milhão de tokens de saída.
Antes de começar
Você precisa de quatro coisas prontas antes de sua primeira solicitação:
- Uma conta Anthropic. Cadastre-se em console.anthropic.com. O Console é onde você gerencia chaves, uso e faturamento.
- Uma chave de API. Crie uma no Console em API Keys. Copie-a uma vez; você não a verá novamente. Trate-a como uma senha.
- Faturamento ou um plano Enterprise. Fable 5 está disponível na API padrão do Claude e está totalmente disponível em planos Enterprise baseados em consumo. Adicione um método de pagamento ou confirme se seu plano cobre antes de enviar tráfego. Se você ainda está decidindo se o Fable 5 se encaixa no seu caso de uso, a visão geral sobre o que é o Claude Fable 5 aborda os pontos fortes do modelo em termos simples.
- Um SDK (opcional, mas recomendado). Instale o SDK oficial da Anthropic para sua linguagem. Você também pode chamar o endpoint HTTP bruto com curl ou qualquer cliente HTTP, se preferir.
Defina a chave como uma variável de ambiente para que ela nunca vá parar no seu código-fonte:
export ANTHROPIC_API_KEY="sk-ant-..."
Ambos os SDKs leem ANTHROPIC_API_KEY do ambiente automaticamente, então você raramente a passa no código. Mantenha as chaves fora do git. Se uma chave vazar, gire-a no Console imediatamente.
Um comportamento a saber de antemão: o Fable 5 vem com salvaguardas que redirecionam uma pequena parcela de consultas sensíveis (cibersegurança, biologia e química, e tentativas de destilação de modelos) para o Claude Opus 4.8 em vez disso. Isso ocorre em menos de 5% das sessões. Você não configura nada para isso, mas explica a resposta ocasional que volta rotulada como um modelo diferente. Mais sobre isso na seção de tratamento de erros.
Sua primeira chamada à API do Claude Fable 5
Comece com curl para que você possa ver a solicitação e a resposta brutas sem nada no caminho. O endpoint é POST https://api.anthropic.com/v1/messages, documentado na referência da API de Mensagens da Anthropic, e precisa de três cabeçalhos mais um corpo 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","max_tokens":1024,"messages":[{"role":"user","content":"Summarize what makes a good REST API in 3 bullet points."}]}'
Três cabeçalhos importam aqui. x-api-key carrega sua chave. anthropic-version fixa a versão da API (2023-06-01 é o valor estável atual). content-type informa ao servidor que você está enviando JSON. O corpo tem três campos obrigatórios: model, max_tokens e messages. Esse é todo o contrato.
A resposta retorna como um objeto JSON. A parte que te interessa é content, que é uma lista de blocos:
{
"id": "msg_01ABC...",
"type": "message",
"role": "assistant",
"model": "claude-fable-5",
"content": [
{ "type": "text", "text": "- URLs previsíveis e orientadas a recursos..." }
],
"stop_reason": "end_turn",
"usage": { "input_tokens": 18, "output_tokens": 96 }
}
content é uma lista, não uma string, porque uma única resposta pode misturar texto, blocos de uso de ferramentas e blocos de pensamento. Sempre percorra a lista e verifique o type de cada bloco antes de ler text. O stop_reason informa por que o modelo parou (end_turn é um término limpo), e usage fornece as contagens de tokens que você usará para calcular o custo mais tarde.
Chamando Fable 5 do Python
O SDK oficial da Anthropic para Python remove o boilerplate de cabeçalhos e JSON. Instale-o primeiro:
pip install anthropic
Aqui está a chamada básica. O cliente lê sua chave do ambiente, então você não a passa:
import anthropic
client = anthropic.Anthropic() # lê ANTHROPIC_API_KEY do ambiente
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Resuma o que faz uma boa API REST."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
O padrão espelha a chamada curl. Você passa model, max_tokens e messages, e recebe uma resposta cujo content é uma lista de blocos. O loop protege em block.type == "text" para que você nunca se depare com um bloco que não seja de texto.
Adicionando um prompt de sistema
Um prompt de sistema define o papel do modelo e as regras básicas para toda a conversa. Passe-o como o campo system, separado de messages:
response = client.messages.create(
model="claude-fable-5",
max_tokens=2048,
system="Você é um engenheiro de backend sênior. Seja conciso e use exemplos de código.",
messages=[{"role": "user", "content": "Escreva uma rota Flask que valida um corpo JSON."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
O prompt do sistema é o lugar certo para a persona, regras de formato de saída e restrições que você deseja manter em cada turno. Mantenha-o estável, porque alterá-lo a cada solicitação anula o cache de prompt se você o adicionar mais tarde.
Streaming de saídas longas
Para qualquer coisa que produza uma resposta longa, faça streaming. O streaming envia tokens à medida que são gerados, para que você mostre o progresso imediatamente e evite os timeouts de solicitação que atingem grandes respostas sem streaming. O trabalho de longo prazo do Fable 5 torna esta a escolha padrão para cargas de trabalho reais:
with client.messages.stream(
model="claude-fable-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Explique as chaves de idempotência para APIs de pagamento."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final = stream.get_final_message()
print(f"\n\nTokens: {final.usage.output_tokens}")
stream.text_stream gera pedaços de texto conforme chegam. O flush=True é importante para que cada pedaço seja impresso imediatamente em vez de ser armazenado em buffer. Quando o stream termina, stream.get_final_message() entrega a mensagem completa montada, incluindo os números finais de usage, para que você obtenha a UX de streaming e o objeto completo sem uma segunda solicitação.
Chamando Fable 5 do TypeScript / Node
O SDK do Node segue a mesma estrutura. Instale-o:
npm install @anthropic-ai/sdk
Então faça a chamada. O cliente lê ANTHROPIC_API_KEY do ambiente, o mesmo que Python:
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic(); // lê ANTHROPIC_API_KEY
const msg = await client.messages.create({
model: "claude-fable-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Liste 3 erros comuns de segurança de API." }],
});
console.log(msg.content);
msg.content é a mesma lista de blocos que você viu em Python e curl. Para extrair apenas o texto, filtre pelo tipo de bloco:
const text = msg.content
.filter((block) => block.type === "text")
.map((block) => block.text)
.join("");
console.log(text);
O streaming funciona da mesma forma que no Python. Use client.messages.stream({...}) e itere os eventos, ou aguarde finalMessage() para o resultado montado. Se você estiver conectando isso a um frontend de chat, faça o stream de uma rota do servidor e encaminhe os chunks para o navegador. Os mesmos hábitos de teste se aplicam, seja você construindo em Node ou Python, e uma ferramenta como Apidog torna o contrato fácil de verificar antes de escrever qualquer código cliente, que é o mesmo fluxo de trabalho abordado em testando a API ChatGPT com Apidog.
Uso de ferramentas (chamada de função) com Fable 5
O uso de ferramentas permite que o Fable 5 chame funções que você define. Você descreve uma ferramenta com um esquema JSON, o modelo decide quando chamá-la, e você executa a função real e alimenta o resultado de volta. O Fable 5 é forte no uso de ferramentas, por isso se encaixa bem em loops de agentes.
Defina uma ferramenta com um nome, uma descrição e um input_schema:
tools = [
{
"name": "get_order_status",
"description": "Consulta o status de um pedido do cliente por ID.",
"input_schema": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
}
]
Passe tools para a solicitação da mesma forma que você passa messages:
messages = [{"role": "user", "content": "Qual o status do pedido A1855?"}]
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
Quando o modelo quer usar uma ferramenta, a resposta retorna com stop_reason == "tool_use" e um bloco tool_use carregando o nome da ferramenta e a entrada que ele escolheu. O loop é direto: adicione a resposta do assistente, execute a ferramenta, e então envie o resultado de volta como um bloco tool_result em um novo turno de usuário:
if response.stop_reason == "tool_use":
tool_use = next(b for b in response.content if b.type == "tool_use")
# Execute sua função real com a entrada escolhida pelo modelo
result = lookup_order(tool_use.input["order_id"]) # seu código
messages.append({"role": "assistant", "content": response.content})
messages.append({
"role": "user",
"content": [{
"type": "tool_result",
"tool_use_id": tool_use.id,
"content": result,
}],
})
# Envie o resultado de volta; o modelo agora responde usando-o
followup = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
O detalhe chave é tool_use_id: o bloco tool_result deve referenciar o id exato do bloco tool_use para que o modelo saiba qual chamada sua resposta atende. Para agentes multi-etapas, você envolve isso em um loop que continua até que stop_reason seja end_turn. O SDK Python também fornece um executor de ferramentas que lida com o loop para você, mas a versão manual acima mostra o que está acontecendo por baixo dos panos e oferece um local para adicionar gates de aprovação ou log.
Pensamento adaptativo e esforço
O Fable 5 suporta pensamento adaptativo, onde o modelo decide por si mesmo quando e quão profundamente raciocinar antes de responder. É opcional. Ative-o passando thinking e ajuste a profundidade geral e o gasto de tokens com output_config:
response = client.messages.create(
model="claude-fable-5",
max_tokens=4096,
thinking={"type": "adaptive"},
output_config={"effort": "high"}, # low | medium | high
messages=[{"role": "user", "content": "Projete uma estratégia de repetição para um receptor de webhook instável."}],
)
effort controla o quanto o modelo pensa e trabalha: menor esforço significa respostas mais curtas e rápidas, maior esforço significa raciocínio mais completo com custo maior de tokens. Deixe ambos desligados para pesquisas simples e respostas curtas, onde o raciocínio extra não vale os tokens. Utilize-os para problemas difíceis e multifásicos, o tipo de planejamento de longo prazo para o qual o Fable 5 foi construído. Comece de forma simples; você pode adicionar thinking mais tarde, quando souber que uma rota precisa disso.
Tratamento de erros e o fallback de salvaguarda
Integrações reais precisam lidar com falhas de forma limpa. O SDK levanta exceções tipadas, então capture a classe específica em vez de corresponder strings de erro. As três que você verá com mais frequência mapeiam para HTTP 401, 429 e 400:
import anthropic
client = anthropic.Anthropic()
try:
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Explique as requisições de preflight do CORS."}],
)
except anthropic.AuthenticationError:
# 401: chave de API inválida ou ausente. Verifique ANTHROPIC_API_KEY.
print("Chave de API inválida. Gire-a no Console e re-exporte.")
except anthropic.RateLimitError as e:
# 429: muitas requisições. Espere e tente novamente.
retry_after = e.response.headers.get("retry-after", "60")
print(f"Limite de taxa atingido. Tente novamente após {retry_after}s.")
except anthropic.BadRequestError as e:
# 400: requisição malformada (parâmetros ruins, mensagens vazias, formato incorreto).
print(f"Requisição inválida: {e.message}")
Aqui está o que cada um significa e como corrigi-los:
- 401 (
AuthenticationError): a chave está ausente, malformada ou revogada. Confirme seANTHROPIC_API_KEYestá definida no ambiente em que seu código realmente executa e se a chave ainda está ativa no Console. - 429 (
RateLimitError): você excedeu seu limite de requisições por minuto ou tokens por minuto. O SDK já tenta novamente os erros 429 e 5xx com backoff exponencial (duas tentativas por padrão). Leia o cabeçalhoretry-afterse você adicionar um backoff personalizado. - 400 (
BadRequestError): a requisição está malformada. As causas comuns são um arraymessagesvazio, ummax_tokensausente ou mensagens que não alternam as funções corretamente. A mensagem de erro geralmente nomeia o campo.
Agora, o fallback de salvaguarda. O Fable 5 roteia um pequeno conjunto de consultas sensíveis (cibersegurança, biologia e química, e tentativas de destilação) para o Claude Opus 4.8 em vez de responder diretamente. Isso ocorre em menos de 5% das sessões. Não é um erro, e sua solicitação ainda é bem-sucedida, mas a resposta pode vir marcada com um modelo diferente. Se você registrar ou afirmar em response.model, não falhe gravemente quando não for claude-fable-5; a solicitação foi tratada, apenas por um modelo diferente nos bastidores. Se sua aplicação precisa estritamente saber qual modelo respondeu, leia response.model do objeto retornado em vez de assumir que ele corresponde ao que você enviou.
Estimando o custo por solicitação
O preço é de US$10 por milhão de tokens de entrada e US$50 por milhão de tokens de saída. Cada resposta contém as contagens exatas em usage, para que você possa calcular o custo por solicitação com precisão, em vez de adivinhar:
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Escreva uma consulta SQL para encontrar e-mails duplicados."}],
)
input_tokens = response.usage.input_tokens
output_tokens = response.usage.output_tokens
input_cost = input_tokens / 1_000_000 * 10
output_cost = output_tokens / 1_000_000 * 50
total = input_cost + output_cost
print(f"Entrada: {input_tokens} tokens = ${input_cost:.6f}")
print(f"Saída: {output_tokens} tokens = ${output_cost:.6f}")
print(f"Total: ${total:.6f}")
Tokens de saída custam cinco vezes mais que tokens de entrada, então a alavanca mais barata que você tem é manter as respostas concisas. Uma solicitação com 2.000 tokens de entrada e 500 tokens de saída custa 2000 / 1M * US$10 + 500 / 1M * US$50, o que equivale a US$0.02 + US$0.025 = US$0.045. Multiplique pelo seu volume de solicitações para dimensionar um orçamento. Se o custo de saída dominar sua conta, limite max_tokens e peça respostas concisas no prompt do sistema. O preço de saída é o mesmo cálculo que você faria para o modelo de preços do Claude Opus 4.8, apenas com os números do Fable 5.
Teste e depure a API do Claude Fable 5 com Apidog
Antes de escrever o código do cliente, vale a pena enviar algumas requisições manualmente e observar exatamente o que retorna. Apidog é um cliente de API construído para isso: você envia requisições reais para https://api.anthropic.com/v1/messages, inspeciona a resposta em stream e salva a requisição para que toda a sua equipe trabalhe com a mesma definição. Aqui está um caminho limpo do zero a uma requisição funcionando e salva.
- Crie a requisição. No Apidog, crie uma nova requisição HTTP, defina o método como
POSTe cole a URLhttps://api.anthropic.com/v1/messages. Este é o mesmo endpoint que todos os exemplos neste guia utilizam. - Armazene sua chave como uma variável de ambiente. Crie uma variável de ambiente no Apidog, nomeie-a como
anthropic_api_keye cole sua chave como um valor secreto. Manter a chave no ambiente significa que ela permanece fora da requisição salva e de qualquer exportação que você compartilhar. - Defina os cabeçalhos. Adicione
x-api-keycom o valor{{anthropic_api_key}}, depoisanthropic-version: 2023-06-01econtent-type: application/json. Se preferir uma variável secreta estilo Bearer, armazene o token da mesma forma e referencie-o com a sintaxe{{...}}para que o valor bruto nunca apareça na requisição. - Adicione o corpo JSON. Insira o payload mínimo:
{"model": "claude-fable-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explique as chaves de idempotência para APIs de pagamento."}]}. Envie e leia a resposta. Você deverá ver os blocoscontent,stop_reasoneusagediretamente no painel de resposta. - Visualize respostas transmitidas. Defina
"stream": trueno corpo e envie novamente. O Apidog renderiza os eventos enviados pelo servidor à medida que chegam, para que você possa observar os tokens serem transmitidos e confirmar se sua lógica de streaming corresponde ao que a API realmente envia antes de implementá-la em um aplicativo. - Salve e gere código. Salve a requisição em uma coleção para que os colegas de equipe possam reutilizá-la e, em seguida, use a geração de código do Apidog para exportar um trecho de código funcional em Python, JavaScript, curl ou outra linguagem. Isso oferece um ponto de partida testado em vez de um arquivo em branco.
Este fluxo é a maneira mais rápida de aprender a forma exata da resposta da API e de depurar uma solicitação que se comporta mal em seu aplicativo, já que você pode comparar a solicitação do seu código com uma que já funciona lado a lado. Quando estiver pronto para configurá-lo, baixe o Apidog e comece com o corpo mínimo acima.