DEV Community

Cover image for Como usar a API Claude Fable 5
Lucas
Lucas

Posted on • Originally published at apidog.com

Como usar a API Claude Fable 5

A Anthropic lançou o Claude Fable 5 em 9 de junho de 2026. Para quem desenvolve integrações, a parte prática é simples: ele usa a mesma API de Mensagens do Claude, e a principal mudança é a string do modelo: claude-fable-5. Neste guia, você vai montar chamadas reais com curl, Python e TypeScript, ativar streaming, usar ferramentas, tratar erros e calcular custo por requisição.

Experimente o Apidog hoje

TL;DR

  1. Crie uma chave no Anthropic Console.
  2. Exporte a chave como variável de ambiente: 
export ANTHROPIC_API_KEY="sk-ant-..."
Enter fullscreen mode Exit fullscreen mode
  1. Envie um POST para a API de Mensagens usando: 
{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Explique o que faz uma boa API REST."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode
  1. Use streaming para respostas longas.
  2. Leia usage.input_tokens e usage.output_tokens para calcular custo.
  3. O preço é de US$10 por milhão de tokens de entrada e US$50 por milhão de tokens de saída.

Se você já integrou outro modelo Claude, a migração é parecida com a troca usada na API do Claude Opus 4.8: altere o model e valide a resposta.

Claude Fable 5 API

Pré-requisitos

Antes da primeira chamada, confirme estes itens:

  1. Conta Anthropic

    Crie ou acesse sua conta em console.anthropic.com.

  2. Chave de API

    Gere uma chave em API Keys no Console. Copie e armazene com segurança. Você não deve versioná-la no Git.

  3. Faturamento ativo ou plano Enterprise

    O Fable 5 está disponível na API padrão do Claude e em planos Enterprise baseados em consumo. Confirme seu método de pagamento ou cobertura do plano antes de enviar tráfego. Se ainda estiver avaliando o modelo, veja também o que é o Claude Fable 5.

  4. SDK ou cliente HTTP

    Você pode usar HTTP puro, curl, Python ou TypeScript/Node.

Anthropic Console

Defina a chave no ambiente:

export ANTHROPIC_API_KEY="sk-ant-..."
Enter fullscreen mode Exit fullscreen mode

Os SDKs oficiais leem ANTHROPIC_API_KEY automaticamente. Evite passar a chave diretamente no código. Se uma chave vazar, revogue-a e gere outra no Console.

Um detalhe operacional: o Fable 5 possui salvaguardas que podem redirecionar uma pequena parcela de consultas sensíveis, como cibersegurança, biologia, química e tentativas de destilação de modelos, para o Claude Opus 4.8. Isso ocorre em menos de 5% das sessões. A requisição continua válida, mas response.model pode indicar outro modelo.

Primeira chamada com curl

O endpoint é:

POST https://api.anthropic.com/v1/messages
Enter fullscreen mode Exit fullscreen mode

Exemplo mínimo:

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."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Cabeçalhos usados:

Cabeçalho Função
x-api-key Envia sua chave de API
anthropic-version Define a versão da API
content-type Indica que o corpo está em JSON

Campos principais do corpo:

Campo Obrigatório Descrição
model Sim Use claude-fable-5
max_tokens Sim Limite máximo de tokens de saída
messages Sim Histórico da conversa

Resposta simplificada:

{
  "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
  }
}
Enter fullscreen mode Exit fullscreen mode

Pontos importantes:

  • content é uma lista de blocos, não uma string.
  • Sempre verifique type antes de ler text.
  • stop_reason indica por que a resposta terminou.
  • usage contém os tokens usados e deve ser salvo para custo, métricas e auditoria.

Usando Claude Fable 5 com Python

Instale o SDK oficial:

pip install anthropic
Enter fullscreen mode Exit fullscreen mode

Chamada básica:

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)
Enter fullscreen mode Exit fullscreen mode

Esse padrão deve ser a base da sua integração:

  1. Instancie o cliente.
  2. Envie model, max_tokens e messages.
  3. Itere por response.content.
  4. Extraia apenas blocos com type == "text".

Adicionando prompt de sistema

Use system para definir papel, restrições e formato da resposta:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    system=(
        "Você é um engenheiro de backend sênior. "
        "Responda de forma concisa e use exemplos de código quando necessário."
    ),
    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)
Enter fullscreen mode Exit fullscreen mode

Use system para regras estáveis, como:

  • tom da resposta;
  • formato de saída;
  • limites técnicos;
  • idioma;
  • persona do assistente;
  • restrições de segurança.

Evite alterar o prompt de sistema sem necessidade, especialmente se depois você usar cache de prompt.

Streaming para respostas longas

Use streaming quando a resposta puder ser grande. Isso melhora a UX e reduz o risco de timeout.

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 de saída: {final.usage.output_tokens}")
Enter fullscreen mode Exit fullscreen mode

Boas práticas:

  • use flush=True para imprimir os chunks imediatamente;
  • use get_final_message() para obter a resposta completa;
  • leia final.usage para registrar custo;
  • prefira streaming em chats, geração de documentos e respostas técnicas longas.

Usando Claude Fable 5 com TypeScript / Node

Instale o SDK:

npm install @anthropic-ai/sdk
Enter fullscreen mode Exit fullscreen mode

Chamada básica:

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);
Enter fullscreen mode Exit fullscreen mode

Para extrair apenas texto:

const text = msg.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);
Enter fullscreen mode Exit fullscreen mode

Em uma aplicação real, encapsule essa lógica em uma função:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

export async function askFable(prompt: string): Promise<string> {
  const msg = await client.messages.create({
    model: "claude-fable-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
  });

  return msg.content
    .filter((block) => block.type === "text")
    .map((block) => block.text)
    .join("");
}
Enter fullscreen mode Exit fullscreen mode

Para frontends de chat, faça o streaming no backend e encaminhe os chunks para o navegador. Antes de implementar o cliente final, você pode validar o contrato manualmente com uma ferramenta como Apidog, no mesmo fluxo mostrado em testando a API ChatGPT com Apidog.

Uso de ferramentas com Fable 5

O uso de ferramentas permite que o modelo solicite a execução de funções definidas por você. O fluxo é:

  1. Você descreve a ferramenta com JSON Schema.
  2. O modelo decide quando usá-la.
  3. Sua aplicação executa a função real.
  4. Você envia o resultado de volta.
  5. O modelo responde usando esse resultado.

Exemplo de definição de ferramenta:

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"],
        },
    }
]
Enter fullscreen mode Exit fullscreen mode

Envie a ferramenta junto da mensagem:

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,
)
Enter fullscreen mode Exit fullscreen mode

Quando o modelo quiser chamar a ferramenta, a resposta terá:

response.stop_reason == "tool_use"
Enter fullscreen mode Exit fullscreen mode

E um bloco do tipo tool_use.

Exemplo de loop manual:

if response.stop_reason == "tool_use":
    tool_use = next(
        block for block in response.content
        if block.type == "tool_use"
    )

    # Execute sua função real
    result = lookup_order(tool_use.input["order_id"])

    # Preserve a resposta do assistente no histórico
    messages.append({
        "role": "assistant",
        "content": response.content
    })

    # Envie o resultado da ferramenta
    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result,
            }
        ],
    })

    followup = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
Enter fullscreen mode Exit fullscreen mode

O detalhe mais importante é tool_use_id. O bloco tool_result precisa apontar para o id exato do bloco tool_use.

Para agentes multi-etapas, envolva isso em um loop:

while True:
    response = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )

    messages.append({
        "role": "assistant",
        "content": response.content
    })

    if response.stop_reason != "tool_use":
        break

    tool_use = next(
        block for block in response.content
        if block.type == "tool_use"
    )

    result = lookup_order(tool_use.input["order_id"])

    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result,
            }
        ],
    })
Enter fullscreen mode Exit fullscreen mode

Esse formato também é útil para adicionar:

  • logs de auditoria;
  • aprovação humana antes da execução;
  • limites de chamadas;
  • validação de input;
  • fallback quando uma ferramenta falha.

Pensamento adaptativo e esforço

O Fable 5 suporta pensamento adaptativo. Com ele, o modelo decide quando raciocinar mais profundamente antes de responder.

Exemplo:

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."
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Use thinking e effort quando a tarefa envolver:

  • planejamento multi-etapas;
  • arquitetura;
  • análise de trade-offs;
  • depuração complexa;
  • raciocínio de produto ou sistema.

Evite em tarefas simples, como:

  • reformular uma frase;
  • classificar texto curto;
  • gerar uma resposta pequena;
  • extrair campos simples.

effort maior tende a consumir mais tokens. Comece sem thinking, meça a qualidade e ative apenas nas rotas que realmente precisam.

Tratamento de erros

Integrações de produção devem capturar exceções tipadas em vez de comparar strings.

Exemplo em Python:

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:
    # HTTP 401
    print("Chave de API inválida ou ausente. Verifique ANTHROPIC_API_KEY.")

except anthropic.RateLimitError as e:
    # HTTP 429
    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:
    # HTTP 400
    print(f"Requisição inválida: {e.message}")
Enter fullscreen mode Exit fullscreen mode

Resumo dos erros comuns:

Erro HTTP Causa comum Como corrigir
AuthenticationError 401 Chave ausente, inválida ou revogada Verifique ANTHROPIC_API_KEY e gere outra chave se necessário
RateLimitError 429 Limite de requisições ou tokens excedido Use backoff e respeite retry-after
BadRequestError 400 Corpo inválido Verifique model, max_tokens, messages e formato dos papéis

O SDK já tenta novamente erros 429 e 5xx com backoff exponencial, com duas tentativas por padrão. Se você implementar retry próprio, evite duplicar tentativas sem controle.

Lidando com fallback de salvaguarda

O fallback de salvaguarda não é erro. A requisição pode ser bem-sucedida, mas response.model pode vir como outro modelo, como Claude Opus 4.8.

Não faça isto:

assert response.model == "claude-fable-5"
Enter fullscreen mode Exit fullscreen mode

Prefira registrar o modelo retornado:

print(f"Modelo usado: {response.model}")
Enter fullscreen mode Exit fullscreen mode

Se sua aplicação depende do modelo exato usado, leia response.model da resposta em vez de assumir que será sempre igual ao model enviado.

Calculando custo por requisição

O preço informado é:

  • Entrada: US$10 por milhão de tokens
  • Saída: US$50 por milhão de tokens

Cada resposta inclui usage, então calcule o custo real por chamada:

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}")
Enter fullscreen mode Exit fullscreen mode

Exemplo de cálculo:

Entrada: 2.000 tokens
Saída:     500 tokens

Entrada: 2000 / 1.000.000 * US$10 = US$0,020
Saída:    500 / 1.000.000 * US$50 = US$0,025

Total: US$0,045
Enter fullscreen mode Exit fullscreen mode

Como tokens de saída custam mais, as principais alavancas de custo são:

  • limitar max_tokens;
  • pedir respostas concisas no prompt de sistema;
  • usar streaming sem aumentar o tamanho da saída;
  • evitar raciocínio adaptativo em tarefas simples;
  • registrar usage por rota, usuário ou tenant.

O cálculo segue a mesma lógica usada em preços do Claude Opus 4.8, mas com os valores do Fable 5.

Testando e depurando a API do Claude Fable 5 com Apidog

Antes de codar o cliente final, envie algumas requisições manualmente para validar headers, corpo, streaming e formato de resposta. Apidog permite criar uma requisição real para https://api.anthropic.com/v1/messages, inspecionar a resposta e salvar o contrato para a equipe.

Testando Claude Fable 5 no Apidog

Fluxo recomendado:

  1. Crie uma requisição HTTP

Método:

   POST
Enter fullscreen mode Exit fullscreen mode

URL:

   https://api.anthropic.com/v1/messages
Enter fullscreen mode Exit fullscreen mode
  1. Armazene a chave como variável de ambiente

Crie uma variável chamada:

   anthropic_api_key
Enter fullscreen mode Exit fullscreen mode

Salve o valor como secreto. Assim a chave não fica exposta na requisição salva.

  1. Configure os headers

Use:

   x-api-key: {{anthropic_api_key}}
   anthropic-version: 2023-06-01
   content-type: application/json
Enter fullscreen mode Exit fullscreen mode
  1. Adicione o corpo mínimo 
   {
     "model": "claude-fable-5",
     "max_tokens": 1024,
     "messages": [
       {
         "role": "user",
         "content": "Explique as chaves de idempotência para APIs de pagamento."
       }
     ]
   }
Enter fullscreen mode Exit fullscreen mode
  1. Envie e valide a resposta

Verifique se a resposta contém:

  • content;
  • stop_reason;
  • usage;
  • model.
  1. Teste streaming

Adicione stream: true:

   {
     "model": "claude-fable-5",
     "max_tokens": 1024,
     "stream": true,
     "messages": [
       {
         "role": "user",
         "content": "Explique as chaves de idempotência para APIs de pagamento."
       }
     ]
   }
Enter fullscreen mode Exit fullscreen mode

Observe os eventos chegando em tempo real. Isso ajuda a implementar corretamente o streaming no backend.

  1. Salve a requisição e gere código

Salve a chamada em uma coleção e use a geração de código do Apidog para exportar exemplos em Python, JavaScript, curl ou outra linguagem.

Esse processo reduz tentativa e erro: primeiro você valida a requisição funcionando, depois replica o mesmo contrato no código. Quando estiver pronto, baixe o Apidog e comece com o payload mínimo acima.

Top comments (0)