TL;DR
A Claude Fable 5.2 API permite adicionar raciocínio avançado a assistentes de codificação, fluxos de trabalho de pesquisa e aplicações que exigem trabalho sustentado em múltiplas etapas. Você pode se conectar diretamente à Anthropic ou usar a CometAPI, dependendo de como deseja gerenciar o acesso ao modelo e a integração.
Para custos de tokens mais baixos e integração multi-modelo mais simples, a Claude Fable 5.2 API via CometAPI é um ponto de partida prático: suas tarifas publicadas de entrada e saída são 20% abaixo das tarifas padrão da API da Anthropic, e você pode manter o formato de solicitações Anthropic Messages dentro de um fluxo de trabalho compartilhado de acesso a modelos e faturamento. Escolha acesso direto à Anthropic quando controles de conta específicos do provedor ou um recurso nativo forem seu principal requisito.
Este guia cobre ambas as rotas, depois aborda requests em Python, streaming, histórico de conversas, entrada de imagem e verificações de produção. Você precisa de Python 3.10 ou posterior, uma chave de API para a rota escolhida e acesso a claude-fable-5-2.
Principais pontos
- A Claude Fable 5.2 API usa o ID de modelo claude-fable-5-2 em ambas as rotas mostradas aqui.
- Acesso direto à Anthropic e CometAPI usam chaves e faturamento separados; escolha uma rota antes de enviar uma solicitação.
- A CometAPI se adapta a aplicações multi-provedor por meio de credenciais compartilhadas, faturamento e interfaces de API compatíveis.
- Comece com uma única solicitação de texto, depois adicione configurações de raciocínio, streaming, histórico de conversas e imagens conforme necessário.
- A CometAPI reduz as cobranças de tokens do Claude Fable 5.2 em 20% em relação às tarifas oficiais padrão listadas abaixo, incluindo as operações de cache listadas.
O que é a Claude Fable 5.2 API?
Claude Fable 5.2 é o modelo de raciocínio da Anthropic para trabalho técnico exigente. Foi lançado em 9 de novembro de 2026. A API oferece à sua aplicação acesso ao modelo sem operar a infraestrutura do modelo você mesmo.
Projetos iniciais típicos incluem revisar uma mudança em repositório, analisar uma coleção de documentos e explicar um design de sistema complexo. Cada um começa com uma solicitação e uma resposta; ferramentas e laços de conversação mais longos podem vir depois que esse caminho estiver funcionando.
Especificações da Claude Fable 5.2 API
Os limites de contexto e de saída descrevem capacidade, não tamanhos sugeridos de solicitação. Use um prompt curto e um orçamento de saída modesto enquanto verifica credenciais e o tratamento da resposta.
O que há de novo na Claude Fable 5.2 API em comparação com a Fable 5.1?
Se você já usa a Fable 5.1, a atualização trata principalmente de melhor desempenho em tarefas, preços padrão de tokens mais baixos e mudanças na compatibilidade de conversas e ferramentas. A comparação abaixo usa a Fable 5.1 como geração anterior.
Resultados mais fortes em tarefas técnicas exigentes
Nas avaliações de lançamento da Anthropic, a Fable 5.2 obteve 49,1% no FrontierCode 2.0 versus 32,4% para a Fable 5.1, ambas com esforço xhigh. As pontuações em Chartography subiram de 44,8% para 73,4%. A Anthropic também relata geração de saída até 30% mais rápida do que a 5.1 e um modo rápido opcional. Estes são resultados reportados pelo fornecedor; geração mais rápida não garante uma solicitação ponta a ponta mais curta para sua carga de trabalho.
Para uma revisão de repositório ou uma tarefa difícil de análise de documentos, teste se o novo modelo captura erros que seu modelo atual não detecta. Mantenha seus prompts, entradas e critérios de pontuação consistentes para que a comparação responda a uma pergunta prática: ele conclui mais do seu trabalho real com sucesso?
Preços padrão mais baixos do que a Fable 5.1
As tarifas padrão publicadas da Anthropic caem de US$ 10 para US$ 8 por milhão de tokens de entrada e de US$ 50 para US$ 40 por milhão de tokens de saída. Leituras de cache caem de US$ 0,25 para US$ 0,20. Cada uma é uma redução de 20%. Estes são preços oficiais de geração para geração; a comparação posterior com a CometAPI mede uma diferença separada entre provedores de acesso.
Com uso inalterado de 100.000 tokens de entrada e 10.000 tokens de saída, uma solicitação padrão sem cache cai de US$ 1,50 na Fable 5.1 para US$ 1,20 na Fable 5.2. As economias reais dependem de tokens gerados, novas tentativas, cache e modos opcionais.
Quatro mudanças de compatibilidade para verificar
O log de alterações oficial identifica quatro mudanças que podem afetar uma integração existente:
- As verificações da conversa agora cobrem todas as contas. Reproduzir o raciocínio após editar mensagens anteriores, instruções de sistema ou ferramentas pode falhar, incluindo em contas antigas que antes passavam.
- O rollback não preserva todo o raciocínio. Apenas Fable 5.2 e Mythos 5.2 podem ler blocos de raciocínio da Fable 5.2. Alternar para 5.1 ou outro modelo pode descartar esse raciocínio.
- O uso de computador requer o conjunto de ferramentas mais recente. A antiga ferramenta computer_20251124 falha fora do Amazon Bedrock; use computer_toolset_20260801 e adapte o loop de ferramentas.
- Alterações de compatibilidade do advisor. Um executor Fable 5.2 requer um advisor Fable 5.2 ou Mythos 5.2.
O que permanece igual
As especificações da Fable 5.1 já incluem janela de contexto de 1M tokens, saída máxima de 128K, entrada de texto e imagem, raciocínio adaptativo sempre ativo e esforço padrão alto na API. Essas continuam sendo capacidades úteis na 5.2, mas não são motivos novos para migrar.
Como migrar para a Claude Fable 5.2 API — e vale a pena?
Comece com uma migração pequena que você possa medir e reverter. Uma primeira solicitação bem-sucedida é apenas o começo: sua aplicação também precisa preservar o estado da conversa, concluir fluxos de ferramentas e lidar corretamente com fallback.
Migrar uma integração existente para a Fable 5.2
Use o guia de migração da Anthropic junto com estas etapas:
- Altere o modelo em uma configuração de teste. Defina MODEL como claude-fable-5-2 no client_config.py usado abaixo. Mantenha juntas a chave e a base URL da rota escolhida. Execute primeiro uma conversa nova e curta.
- Revise as opções de solicitação. Para integrações antigas, remova raciocínio desativado ou orçamentos de raciocínio definidos manualmente, pré-preenchimentos do assistente e seleção forçada de ferramenta. Omita temperature, top_p e top_k. Use output_config.effort para ajustar o raciocínio.
- Verifique o tratamento do histórico. Reproduza respostas completas do assistente na ordem original. Mantenha mensagens anteriores, instruções de sistema e definições de ferramentas inalteradas; anexe novos turnos. Exercite qualquer código que reduza o histórico ou atualize ferramentas.
- Atualize ferramentas opcionais em conjunto. Aplique as mudanças de uso de computador e advisor acima quando relevante. Inicie uma nova conversa após alterar as definições de ferramentas.
- Teste o caminho de retorno. Execute uma tarefa de múltiplos turnos, uma ida e volta de ferramenta e um fallback para seu modelo anterior. Uma resposta de fallback bem-sucedida não significa que o raciocínio anterior sobreviveu.
Ao usar a CometAPI, confirme disponibilidade do modelo e recursos opcionais exigidos nessa rota antes de habilitá-los em produção. Uma interface Messages compatível por si só não estabelece suporte a todos os recursos do provedor.
Vale a pena migrar?
De Fable 5.1: priorize um piloto se trabalho técnico complexo já for valioso para sua aplicação. As tarifas padrão mais baixas tornam o experimento atraente, mas compare o custo das tarefas concluídas em vez de assumir que cada solicitação usará os mesmos tokens.
De Opus, Sonnet ou Haiku: comece pelas tarefas que seu modelo atual tem dificuldade em concluir. Migrar todas as solicitações para a Fable pode aumentar os gastos sem melhorar trabalhos diretos. Você pode manter solicitações rotineiras no modelo existente e avaliar a Fable para casos mais difíceis.
Mantenha sua configuração atual por enquanto se ela atende às suas metas de qualidade e tempo de resposta, ou se as mudanças exigidas no histórico e ferramentas superam o benefício medido. Uma atualização deve resolver um problema que você consegue identificar.
API oficial da Anthropic vs CometAPI: por que escolhi esta última
A Anthropic fornece acesso direto à API Messages. A CometAPI fornece um endpoint Messages compatível com a Anthropic, ao lado de interfaces para outras famílias de modelos. A decisão importante é qual conta e camada de integração deve atender sua aplicação.
Onde a CometAPI simplifica uma aplicação multi-modelo
A CometAPI documenta uma chave e camada de faturamento compartilhadas entre múltiplos formatos de API. Para uma equipe que mantém várias integrações de modelos, isso pode reduzir o número de credenciais e fluxos de conta separados que precisa operar. O benefício cresce quando Claude é uma parte de um produto mais amplo.
Você também pode manter uma integração existente com o SDK da Anthropic: a configuração do cliente abaixo altera a chave e a base URL enquanto o corpo da solicitação Messages permanece o mesmo. Para aplicações que já usam uma interface de chat compatível, a CometAPI oferece outro ponto de entrada; escolha o formato que preserve os recursos de que sua aplicação precisa.
Seus relatórios de uso por conta e por chave fornecem um lugar comum para conciliar consumo. Isso é útil quando recursos separados do produto usam modelos diferentes e você precisa entender seus gastos combinados.
Escolhendo a rota para o seu projeto
Comece com a CometAPI quando reduzir o gasto com tokens for prioridade, quer você use Claude sozinho ou junto com outros provedores. Teste solicitações representativas com seu código de cliente existente para confirmar os recursos necessários. Escolha acesso direto à Anthropic quando seus requisitos se concentrarem em controles de conta específicos do provedor. Em qualquer rota, verifique conclusão bem-sucedida da tarefa, uso e latência antes de mover tráfego de produção.
Como usar a Claude Fable 5.2 API passo a passo?
Escolha um caminho de acesso para sua primeira solicitação. Os exemplos em Python compartilham um pequeno arquivo de configuração, para que você possa testar a outra rota mais tarde sem reescrever o corpo da solicitação.
Etapa 1: Criar uma chave de API
Para acesso oficial, siga a configuração da chave de API no Console do Claude. Use uma chave com escopo para o workspace deste tutorial e confirme que a conta tem acesso e faturamento configurados. Armazene-a como ANTHROPIC_API_KEY. Chaves que não têm escopo de workspace também precisam do cabeçalho de workspace descrito na documentação de autenticação da Anthropic.
Para a CometAPI, crie uma chave no painel da API e confirme acesso ao modelo e saldo. Armazene-a como COMETAPI_KEY. Uma chave de um provedor não pode autenticar no endpoint do outro provedor.
Armazene a chave com segurança. Evite colocar credenciais diretamente no código-fonte da aplicação ou em JavaScript no frontend.
No macOS ou Linux, execute a atribuição apropriada no shell que iniciará o Python:
# Set the variable for the route you chose.
export ANTHROPIC_API_KEY="your_anthropic_api_key"
# Or, for CometAPI:
export COMETAPI_KEY="your_cometapi_api_key"
No Windows PowerShell, use a variável de ambiente correspondente:
# Set the variable for the route you chose.
$env:ANTHROPIC_API_KEY = "your_anthropic_api_key"
# Or, for CometAPI:
$env:COMETAPI_KEY = "your_cometapi_api_key"
Etapa 2: Fazer a primeira solicitação com cURL
Estes são comandos Bash alternativos. Execute o da sua conta selecionada para inspecionar a resposta HTTP antes de introduzir Python.
Envie uma solicitação de texto diretamente para a Anthropic com uma chave de API com escopo de workspace:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-2",
"max_tokens": 4096,
"messages": [{
"role": "user",
"content": "Explain API rate limiting in three sentences."
}]
}'
Envie a solicitação equivalente pela CometAPI:
curl https://api.cometapi.com/v1/messages \
-H "x-api-key: $COMETAPI_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-2",
"max_tokens": 4096,
"messages": [{
"role": "user",
"content": "Explain API rate limiting in three sentences."
}]
}'
Os exemplos HTTP usam os cabeçalhos de versão documentados para cada rota: versões da API da Anthropic e formato Messages da CometAPI. Um SDK gerencia esses cabeçalhos para você; capacidades beta opcionais ainda precisam de verificação específica da rota.
O endpoint retorna uma resposta no estilo Anthropic contendo content, usage e stop_reason.
Etapa 3: Configurar o cliente Python
Instale o SDK Python da Anthropic no seu ambiente Python ativo.
Instale ou atualize o pacote:
python -m pip install --upgrade anthropic
Crie client_config.py na pasta do seu projeto. Escolha exatamente uma das configurações a seguir; todos os scripts posteriores importam client e MODEL deste arquivo.
Configuração CometAPI: salve isto como client_config.py ao usar sua conta CometAPI:
import os
from anthropic import Anthropic
MODEL = "claude-fable-5-2"
client = Anthropic(
api_key=os.environ["COMETAPI_KEY"],
auth_token=None,
base_url="https://api.cometapi.com",
)
Configuração oficial: use esta versão de client_config.py para acesso direto à Anthropic:
import os
from anthropic import Anthropic
MODEL = "claude-fable-5-2"
client = Anthropic(
api_key=os.environ["ANTHROPIC_API_KEY"],
auth_token=None,
base_url="https://api.anthropic.com",
)
Para o SDK de Messages, essas bases URL não têm o sufixo /v1. Ao comparar rotas, execute sessões separadas com a chave e configuração de cliente correspondentes, em vez de trocar credenciais dentro de uma conversa ativa.
Etapa 4: Enviar uma solicitação com Python
Salve isto como fable52.py ao lado de client_config.py. A solicitação funciona com qualquer configuração que você selecionou:
from client_config import client, MODEL
response = client.messages.create(
model=MODEL,
max_tokens=4096,
messages=[{
"role": "user",
"content": "Explain synchronous and asynchronous Python.",
}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print("Stop reason:", response.stop_reason)
print("Input tokens:", response.usage.input_tokens)
print("Output tokens:", response.usage.output_tokens)
Execute o exemplo no terminal onde você definiu a chave:
python fable52.py
Uma solicitação somente texto bem-sucedida imprime a resposta e o uso. Verifique se há end_turn antes de tratar a resposta como completa. Se o motivo de parada for max_tokens, revise a saída parcial e o orçamento; um sucesso HTTP não significa por si só que o trabalho solicitado foi concluído.
Como adicionar raciocínio, streaming e imagens à Claude Fable 5.2?
Mantenha client_config.py da seção de configuração. Cada script abaixo usa a rota selecionada, para que você possa testar novos recursos sem alterar o código básico de conexão.
Controlando o esforço de raciocínio
A Fable 5.2 usa raciocínio adaptativo sempre ativo. Você pode omitir thinking ou definir seu tipo como adaptive; raciocínio desativado e orçamentos manuais de tokens de raciocínio não são suportados.
O parâmetro effort aceita low, medium, high, xhigh e max. Comece com o padrão da API, high, e só mude depois de ter uma linha de base útil para sua tarefa.
Salve isto como fable52_effort.py e execute python fable52_effort.py para definir effort explicitamente:
from client_config import client, MODEL
response = client.messages.create(
model=MODEL,
max_tokens=8192,
thinking={"type": "adaptive"},
output_config={"effort": "high"},
messages=[{
"role": "user",
"content": "Identify failure modes in a queue-based worker system.",
}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print("Stop reason:", response.stop_reason)
Deixe temperature, top_p e top_k fora da solicitação inicial. A Fable 5.2 também rejeita a escolha de ferramenta forçada; não carregue tipos tool_choice any ou tool de outra integração.
Streaming para aplicações interativas
Em vez de esperar pela resposta completa, sua aplicação pode exibir o texto gerado conforme ele chega.
Use o auxiliar de streaming de Messages para ler incrementos de texto e coletar a mensagem final.
Salve isto como fable52_stream.py e execute python fable52_stream.py:
from client_config import client, MODEL
with client.messages.stream(
model=MODEL,
max_tokens=8192,
messages=[{
"role": "user",
"content": "Design a fault-tolerant microservice architecture.",
}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final_message = stream.get_final_message()
print("\nStop reason:", final_message.stop_reason)
print("Usage:", final_message.usage)
Pode haver uma pausa antes de o primeiro texto aparecer enquanto o modelo raciocina. Considere o stream completo somente após o auxiliar terminar com sucesso; texto parcial sozinho não confirma uma resposta concluída.
Preservando o histórico de conversas de múltiplos turnos
Diferentemente de uma interface de chat com estado, a API padrão Messages depende da sua aplicação para fornecer o histórico da conversa.
Salve isto como fable52_history.py e execute python fable52_history.py para fazer duas solicitações relacionadas:
from client_config import client, MODEL
history = [{
"role": "user",
"content": "Design a scalable event-processing architecture.",
}]
first = client.messages.create(
model=MODEL,
max_tokens=8192,
output_config={"effort": "high"},
messages=history,
)
if first.stop_reason != "end_turn":
raise RuntimeError(f"First turn is incomplete: {first.stop_reason}")
history.append({
"role": "assistant",
"content": [block.model_dump() for block in first.content],
})
history.append({
"role": "user",
"content": "Now identify its three highest-risk failure scenarios.",
})
second = client.messages.create(
model=MODEL,
max_tokens=8192,
output_config={"effort": "high"},
messages=history,
)
for block in second.content:
if block.type == "text":
print(block.text)
print("Stop reason:", second.stop_reason)
Observe que o exemplo preserva o conteúdo completo do assistente da primeira resposta, em vez de extrair apenas seu texto visível.
A Fable 5.2 valida o raciocínio em relação à conversa precedente. Mantenha mensagens anteriores, instruções de sistema e definições de ferramentas inalteradas ao reproduzir esses blocos. Anexe o próximo turno em vez de reconstruir o prefixo.
A ilustração de contexto e compactação da Anthropic mostra por que uma sessão longa eventualmente precisa de um histórico de trabalho menor. O diagrama vem do Claude Code; uma aplicação de API personalizada deve implementar sua própria gestão de contexto.
Para este tutorial, mantenha o histórico curto intacto. Antes de adicionar compactação a uma aplicação mais longa, confirme que seu gateway suporta a opção documentada no lado do servidor. Se você iniciar uma nova conversa a partir de um resumo, não anexe blocos de raciocínio assinados do prefixo antigo.
Enviando uma imagem para análise
O formato nativo de entrada de imagem coloca um bloco de imagem ao lado de uma instrução de texto. Este exemplo lê um PNG local; verifique suporte a imagem e limites de tamanho na rota do gateway escolhida antes de usar entradas maiores.
Coloque dashboard.png ao lado dos scripts, salve isto como fable52_vision.py e execute python fable52_vision.py:
import base64
from pathlib import Path
from client_config import client, MODEL
image_data = base64.b64encode(
Path("dashboard.png").read_bytes()
).decode("ascii")
response = client.messages.create(
model=MODEL,
max_tokens=4096,
messages=[{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": image_data,
},
},
{
"type": "text",
"text": "Identify three usability issues in this dashboard.",
},
],
}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print("Stop reason:", response.stop_reason)
Adicionando ferramentas controladas pela aplicação
Em um loop de ferramentas no lado do cliente, defina ferramentas com esquemas de entrada, leia os blocos tool_use retornados, execute a operação permitida na sua aplicação e envie blocos tool_result correspondentes na próxima mensagem do usuário. Preserve a resposta completa do assistente antes de retornar esses resultados.
Comece com uma ferramenta somente leitura, como consultar um registro. Valide seus argumentos e trate tool_use como uma continuação da tarefa. Um modelo que gera uma chamada de ferramenta não executa seu código de aplicação por si só.
Quanto custa a Claude Fable 5.2 API?
As tarifas publicadas da CometAPI são 20% mais baixas do que as tarifas padrão da Anthropic em todas as cinco categorias de tokens abaixo. Os preços estão em USD por um milhão de tokens; compare a mesma categoria em cada rota ao estimar sua carga de trabalho.
As tarifas foram verificadas em 10 de novembro de 2026. Esta comparação usa as tarifas padrão publicadas da API, antes de quaisquer acordos específicos de conta ou cobranças adicionais de ferramentas.
Estimativa de uma solicitação sem cache
Para 100.000 tokens de entrada e 10.000 tokens de saída sem cache, a CometAPI custa estimados (0,1 x US$ 6,40) + (0,01 x US$ 32) = US$ 0,96. O mesmo uso de tokens nas tarifas padrão da Anthropic custa (0,1 x US$ 8) + (0,01 x US$ 40) = US$ 1,20. Você economiza US$ 0,24 por solicitação, ou 20%, antes de quaisquer cobranças adicionais de ferramentas.
Em 1.000 solicitações com esse uso de tokens, o gasto estimado com tokens cai de US$ 1.200 para US$ 960, deixando US$ 240 para execuções adicionais ou outras cargas de trabalho de modelos. Para um orçamento de produção, use contagens reais de tokens faturados e inclua novas tentativas, operações de cache e ferramentas cobradas separadamente.
O guia de fallback de modelo e provedor da CometAPI fornece um próximo passo útil: um modelo secundário compatível pode usar a mesma chave e base URL da CometAPI, com uma rota oficial separada configurada se você precisar. Sua aplicação deve implementar a política; IDs de modelo por si só não normalizam formatos de conteúdo nem garantem recuperação bem-sucedida.
Limitações da Claude Fable 5.2
Apesar de suas capacidades avançadas, a Fable 5.2 tem várias restrições práticas:
- Custos de tokens mais altos: A US$ 8 por milhão de tokens de entrada e US$ 40 por milhão de tokens de saída, é consideravelmente mais cara do que a Opus 5.5.
- Latência moderada: Seu raciocínio avançado e capacidades de longo horizonte não a tornam a melhor escolha para aplicações sensíveis à latência.
- Raciocínio adaptativo não pode ser desativado: Desenvolvedores devem gerenciar a profundidade do raciocínio por meio das configurações de effort.
- Tarefas de cibersegurança e biologia restritas: A Fable inclui classificadores de segurança que bloqueiam certas solicitações de pesquisa em cibersegurança e biologia de alto risco.
- Restrições de parâmetros da API: Seleção forçada de ferramenta usando tipos e retorna erro 400. Parâmetros de amostragem como , e devem ser omitidos.
Verificações comuns de configuração
| Sintoma | Primeira ação |
|---|---|
| 401 ou 403 | Verifique se a chave pertence ao endpoint selecionado e tem acesso ao modelo. |
Para uma falha inesperada, registre o horário, ID do modelo, status e ID da solicitação quando presente. Mantenha chaves de API e texto sensível do prompt fora de logs rotineiros.
FAQ
Como obter acesso à Claude Fable 5.2 API?
Escolha acesso direto à Anthropic ou CometAPI, crie uma chave de API para esse provedor e configure faturamento ou saldo. Envie sua primeira solicitação Messages com o modelo claude-fable-5-2. Os endpoints usados neste guia são https://api.anthropic.com/v1/messages e https://api.cometapi.com/v1/messages. Use a chave emitida pelo provedor que você chama; as chaves não são intercambiáveis. Siga a seção de configuração acima e a documentação Messages da CometAPI para a rota do gateway.
Quanto custa a Claude Fable 5.2 API?
A precificação padrão da Anthropic é de US$ 8 por milhão de tokens de entrada e US$ 40 por milhão de tokens de saída. A CometAPI lista US$ 6,40 e US$ 32, respectivamente, conforme verificado em 11 de novembro de 2026. Nessas tarifas, 100.000 tokens de entrada mais 10.000 tokens de saída custam US$ 1,20 diretamente ou US$ 0,96 pela CometAPI, sem cache ou cobranças adicionais. Operações de cache e modos opcionais têm tarifas separadas.
Posso usar o SDK Python da Anthropic com a CometAPI?
Sim. A CometAPI documenta um endpoint Messages compatível com a Anthropic. Configure o cliente da Anthropic com sua chave da CometAPI e base_url="https://api.cometapi.com", depois use client.messages.create. A base URL do SDK neste guia não tem o sufixo /v1. Mantenha o ID do modelo como claude-fable-5-2 e verifique qualquer recurso opcional na rota selecionada antes de depender dele.
Posso desativar o thinking na Claude Fable 5.2 API?
Não. A Fable 5.2 usa raciocínio adaptativo sempre ativo. Controle a profundidade do raciocínio com output_config.effort; o padrão da API é high. Não envie thinking desativado nem uma configuração manual de budget_tokens. O guia de migração explica as configurações suportadas. Teste esforço mais baixo em tarefas representativas se quiser reduzir custo de raciocínio ou latência.
A Claude Fable 5.2 suporta entrada de imagem e janela de contexto de 1M de tokens?
Sim. As especificações do modelo listam entrada de texto e imagem, saída de texto, janela de contexto de 1M de tokens e até 128K tokens de saída. Entrada de imagem permite analisar uma imagem existente; isso não torna o modelo um gerador de imagens. Confirme limites de tamanho de solicitação na rota escolhida antes de enviar payloads grandes.
Posso migrar da Fable 5.1 apenas mudando o ID do modelo?
Uma simples solicitação de texto nova pode precisar apenas da mudança de modelo, mas uma integração de produção requer mais verificações. O guia de migração oficial identifica mudanças na validação do prefixo da conversa, compatibilidade de blocos de raciocínio, uso de computador e seleção de advisor. Siga a seção de migração acima, especialmente se sua aplicação edita histórico, alterna modelos no meio da conversa ou usa essas ferramentas.
Por que minha solicitação à Claude Fable 5.2 API retorna erro 400?
Leia primeiro a mensagem de erro da resposta. Causas comuns incluem configurações de raciocínio não suportadas, pré-preenchimentos do assistente, seleção forçada de ferramenta ou reprodução de blocos de raciocínio após alterar a conversa precedente. O guia de migração da Anthropic descreve essas restrições. Reproduza o problema com uma solicitação mínima nova, depois adicione suas opções e o histórico de volta gradualmente. Repetir a mesma solicitação inválida não irá corrigi-la.
Como devo lidar com limites de taxa (rate limits) da Claude Fable 5.2 API?
Reduza solicitações simultâneas e siga Retry-After quando o gateway o retornar. A configuração de retries do SDK Python permite limitar novas tentativas automáticas; ele já tenta novamente certas falhas transitórias, incluindo respostas 429. Evite empilhar um loop de retries ilimitado da aplicação por cima. Se as falhas persistirem, verifique a cota e o saldo da conta selecionada em vez de aumentar a contagem de retries.
Conclusão
Escolha uma rota, salve sua configuração de cliente e execute o exemplo de texto até conseguir explicar o motivo de parada e o uso retornados. Em seguida, valide uma capacidade adicional por vez com entradas que seu produto realmente receberá.
Execute um pequeno piloto semelhante à produção pela CometAPI e compare as cobranças de tokens registradas com a estimativa acima. Se seu roadmap incluir outros provedores, adicione um segundo modelo para testar o fluxo de acesso e faturamento compartilhado. Mantenha acesso direto à Anthropic disponível quando um requisito nativo o exigir, e expanda a configuração que atenda às suas metas de qualidade e orçamento.