Principais conclusões
- ID do modelo:
claude-fable-5-2. Lançado a 9 de novembro de 2026, com uma janela de contexto de 1M tokens e até 128K tokens de saída por pedido. - Preço: $8 / $40 por milhão de tokens de entrada/saída na API da Anthropic, 20% abaixo do Fable 5.1. Na PoYo custa $6.40 / $32.
- Duas formas de o chamar na PoYo: o formato Anthropic Messages em
POST https://api.poyo.ai/v1/messagesou o endpoint compatível com a OpenAIPOST https://api.poyo.ai/v1/chat/completions. Os SDKs oficiais da Anthropic funcionam com o URL base definido comohttps://api.poyo.ai. - O raciocínio (thinking) está sempre ativo. Controlas a profundidade e o custo com
output_config.effort. A predefinição éhigh; usamediumoulowno trabalho de rotina. - O raciocínio é faturado como saída. Uma resposta curta pode gastar milhares de tokens de saída com esforço
high, por isso defineeffortexplicitamente e dimensionamax_tokenspara o raciocínio mais a resposta. - Lê primeiro o
stop_reason. Indica se o modelo terminou, chamou uma ferramenta, atingiumax_tokensou devolveu umarefusalde segurança, por isso verifica-o antes de leres o conteúdo.
API do Claude Fable 5.2 num relance
| Claude Fable 5.2 | |
|---|---|
| ID do modelo na API | claude-fable-5-2 |
| Lançamento | 9 de novembro de 2026 |
| Janela de contexto | 1M tokens |
| Saída máxima | 128K tokens por pedido |
| Entrada → saída | Texto e imagens → texto |
| Raciocínio | Adaptativo, sempre ativo |
| Níveis de esforço | low, medium, high (predefinido), xhigh, max |
| Data de corte do conhecimento | junho de 2026 |
| Retenção de dados | Retenção de 30 dias |
| Preço oficial (por 1M tokens) | $8 entrada / $40 saída / $0.20 leitura da cache |
| Preço na PoYo (por 1M tokens) | $6.40 entrada / $32 saída / $0.16 leitura da cache |
| Endpoints da PoYo | /v1/messages, /v1/chat/completions |
A Anthropic posiciona o Fable 5.2 para raciocínio exigente e trabalho com agents de longo horizonte, e recomenda o Claude Opus 5.5 como ponto de partida para a maioria das cargas de trabalho. Se ainda estás a decidir entre os dois, lê primeiro Claude Fable 5.2 vs Opus 5.5. Este guia trata da integração.
Um protótipo de sistema operativo construído por agents do Claude Fable 5.2, a correr num portátil. Vídeo dos materiais de lançamento do Claude Fable 5.2 da Anthropic.
Fable 5, 5.1 ou 5.2: que preço estás a ver?
Uma pesquisa por “Claude Fable 5 pricing” pode referir-se a qualquer um dos três modelos Fable lançados em 2026. Partilham a janela de contexto de 1M e o limite de saída de 128K, e cada um tem o seu preço:
| Modelo | Lançamento | Entrada | Saída | Leitura da cache | ID do modelo na API |
|---|---|---|---|---|---|
| Claude Fable 5 | 9 de junho de 2026 | $10 | $50 | $1.00 | claude-fable-5 |
| Claude Fable 5.1 | 1 de setembro de 2026 | $10 | $50 | $0.25 | claude-fable-5-1 |
| Claude Fable 5.2 | 9 de novembro de 2026 | $8 | $40 | $0.20 | claude-fable-5-2 |
Preços oficiais em USD por milhão de tokens. O Fable 5.2 é a primeira descida de preço no nível Fable e o modelo atual, por isso os projetos novos devem começar por ele. O resto deste guia trata do Fable 5.2.
Preços em resumo
| Encargo (por 1M tokens) | Oficial da Anthropic | PoYo | Créditos PoYo |
|---|---|---|---|
| Entrada | $8.00 | $6.40 | 1 280 |
| Saída (inclui o raciocínio) | $40.00 | $32.00 | 6 400 |
| Leitura da cache | $0.20 | $0.16 | 32 |
| Escrita na cache, 5 minutos | $10.00 | $8.00 | 1 600 |
| Escrita na cache, 1 hora | $16.00 | $12.80 | 2 560 |
A PoYo fatura conforme a utilização, em créditos, a $1 = 200 créditos, sem subscrição. Toda a janela de contexto de 1M é faturada às tarifas standard, por isso um prompt de 900K tokens custa o mesmo por token do que um prompt de 9K tokens. Para todos os outros modelos Claude, consulta o nosso guia de preços da API Claude.
Início rápido
- Cria uma chave de API no painel da PoYo.
- Envia os pedidos para
https://api.poyo.aicom o modelo definido comoclaude-fable-5-2. - Autentica-te com
x-api-key: YOUR_KEYem/v1/messages(Authorization: Bearer YOUR_KEYtambém funciona) ou comAuthorization: Bearer YOUR_KEYem/v1/chat/completions.
curl (formato Anthropic Messages)
curl https://api.poyo.ai/v1/messages \
-H "x-api-key: $POYO_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"output_config": {"effort": "medium"},
"messages": [
{"role": "user", "content": "Encontra a condição de corrida neste worker pool em Go e propõe uma correção: ..."}
]
}'
A resposta é um objeto Message standard da Anthropic. A resposta está no bloco text de content; pode vir antes um bloco thinking.
Python (SDK da Anthropic)
import os
import anthropic
client = anthropic.Anthropic(
base_url="https://api.poyo.ai",
api_key=os.environ["POYO_API_KEY"],
)
with client.messages.stream(
model="claude-fable-5-2",
max_tokens=32000,
output_config={"effort": "medium"},
thinking={"type": "adaptive", "display": "summarized"},
messages=[{"role": "user", "content": "Escreve um plano de migração de REST para gRPC para este serviço: ..."}],
) as stream:
message = stream.get_final_message()
if message.stop_reason == "refusal":
print("Request declined:", message.stop_details)
else:
for block in message.content:
if block.type == "thinking":
print("Thinking summary:", block.thinking)
elif block.type == "text":
print(block.text)
print(message.usage)
O streaming mantém os pedidos longos a salvo dos timeouts de HTTP. Com esforço high ou superior, um único pedido difícil pode demorar vários minutos.
TypeScript (SDK da Anthropic)
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
baseURL: "https://api.poyo.ai",
apiKey: process.env.POYO_API_KEY,
});
const message = await client.messages
.stream({
model: "claude-fable-5-2",
max_tokens: 32000,
output_config: { effort: "medium" },
messages: [{ role: "user", content: "Revê este pull request à procura de problemas de segurança: ..." }],
})
.finalMessage();
if (message.stop_reason === "refusal") {
console.log("Request declined:", message.stop_details);
} else {
for (const block of message.content) {
if (block.type === "text") console.log(block.text);
}
}
Chat Completions compatível com a OpenAI
Se a tua stack já usa o formato de pedido da OpenAI, envia o mesmo ID de modelo para /v1/chat/completions:
curl https://api.poyo.ai/v1/chat/completions \
-H "Authorization: Bearer $POYO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "claude-fable-5-2",
"messages": [
{"role": "system", "content": "És um engenheiro de dados sénior."},
{"role": "user", "content": "Desenha um esquema para a deduplicação de eventos no ClickHouse."}
],
"stream": true
}'
Com o SDK oficial da OpenAI, define base_url como https://api.poyo.ai/v1. Usa /v1/messages quando precisares de controlos específicos do Claude, como output_config.effort, a apresentação do raciocínio, cache_control e definições de ferramentas no estilo da Anthropic.
Esforço: a principal alavanca de qualidade e custo
O Fable 5.2 raciocina de forma adaptativa em todos os pedidos. A definição effort dentro de output_config decide quanto:
| Esforço | Para que usar | Notas |
|---|---|---|
low | Trocas rápidas, tarefas bem especificadas, subagents de grande volume | O mais rápido e o mais barato. Em tarefas longas, acrescenta uma instrução para “terminar a tarefa toda” |
medium | Programação interativa, chat, trabalho de conhecimento do dia a dia | Uma boa predefinição para a maior parte do tráfego de produto |
high (predefinido) | Programação difícil, investigação, trabalho com agents, execuções longas sem supervisão | Segundo a Anthropic, a maior parte do ganho de capacidade já está presente em high |
xhigh | O trabalho de programação e de agents mais difícil e mais longo | Usa-o onde as tuas avaliações mostrem um ganho medido; gasta mais tokens |
max | Medir o teto, ou tarefas raras em que a profundidade conta mais do que o tempo e os tokens | O raciocínio mais profundo e os turnos mais longos |

Como o esforço troca pontuação por custo por tarefa no FrontierCode 2.0. Gráfico dos materiais de lançamento do Claude Fable 5.2 da Anthropic.
Três regras práticas:
- Define o esforço em todos os pedidos. O código copiado do Opus 5.5 corria em
mediumpor predefinição. No Fable 5.2, o mesmo pedido corre emhighe gasta mais tokens de saída. - Usa o esforço para definir quanto o modelo raciocina. Para turnos mais rápidos e mais baratos, a Anthropic recomenda um nível de esforço mais baixo em vez de linhas no prompt como “responde diretamente sem deliberar”. Em
highe acima, o Fable 5.2 raciocina antes de quase todas as respostas, até de um cumprimento. - Usa o prompt para o tamanho da resposta. O esforço define a profundidade do raciocínio; o teu prompt define o comprimento da resposta final.
Para um exemplo medido do efeito do esforço na fatura, vê os resultados práticos em Claude Fable 5.2 vs Opus 5.5: numa tarefa de programação, o Fable 5.2 obteve a mesma pontuação em medium e em high, por cerca de um quarto do custo em medium.
Raciocínio adaptativo: o que “sempre ativo” significa para o teu código
- Omite
thinkingou envia{"type": "adaptive"}. É toda a configuração do raciocínio. A profundidade vem deeffort, que substitui as antigas definiçõesbudget_tokensedisabled. - Os tokens de raciocínio são faturados como saída e contam para
max_tokens. Dimensionamax_tokenspara o raciocínio mais a resposta: 16K é um bom mínimo, e 32K ou mais com streaming adequa-se a tarefas difíceis. - Os resumos do raciocínio são opcionais. Por predefinição, os blocos de thinking chegam com o campo
thinkingvazio, o que mantém o streaming rápido. Acrescenta"display": "summarized"para receberes um resumo legível. Em ambos os modos, a faturação cobre o raciocínio completo. - Deixa a amostragem a cargo do modelo. Envia os pedidos sem
temperature,top_petop_k; o Fable 5.2 gere a amostragem sozinho. - Lê o
usage.output_tokensjá inclui o raciocínio, eoutput_tokens_details.thinking_tokensmostra a parte que lhe corresponde.
Utilização de ferramentas
O Fable 5.2 aceita tool_choice com auto (a predefinição) ou none. Indica o nome da ferramenta no prompt quando quiseres que seja chamada:
{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"output_config": {"effort": "medium"},
"tools": [
{
"name": "get_order_status",
"description": "Look up an order by its ID and return the shipping status and carrier.",
"input_schema": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"]
}
}
],
"tool_choice": {"type": "auto"},
"messages": [
{"role": "user", "content": "Onde está a encomenda A-1042? Verifica com get_order_status."}
]
}
Quando o modelo chama uma ferramenta, a resposta termina com stop_reason: "tool_use". Executa a ferramenta e envia um bloco tool_result na mensagem de utilizador seguinte. Devolve o turno completo do assistente sem alterações, incluindo os blocos de thinking.
Outras regras que vale a pena conhecer:
- Usa
autoounoneemtool_choice. Para garantir que uma ferramenta é executada, indica o nome dela no prompt. Quando precisares de JSON garantido, usa saída estruturada:output_config.formatcom um esquema JSON. - A utilização do computador funciona através do conjunto de ferramentas
computer_toolset_20260801. - Analisa os argumentos das ferramentas com um parser de JSON. Assim lidas com qualquer estilo de escape que o modelo use dentro dos argumentos.
Braços robóticos controlados pelo Claude Fable 5.2 a partir de imagens de câmara, a resolver um cubo-puzzle. Vídeo dos materiais de lançamento do Claude Fable 5.2 da Anthropic.
Contexto de 1M e prompt caching
A janela de 1M tokens comporta cerca de 555 000 palavras em inglês, o suficiente para uma base de código grande ou um conjunto de contratos num único pedido. O Fable 5.2 usa o tokenizador introduzido com o Claude Opus 4.7, que produz mais tokens para o mesmo texto do que os modelos anteriores ao 4.7, por isso conta os tokens dos teus próprios ficheiros antes de planeares em função do limite.
É nos prompts longos que a cache compensa. Uma leitura da cache no Fable 5.2 custa 2,5% do preço de entrada ($0.20 vs $8 por milhão de tokens). Na PoYo, acrescenta um cache_control de nível superior e o último bloco que pode ser guardado em cache fica em cache automaticamente:
{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"cache_control": {"type": "ephemeral", "ttl": "1h"},
"output_config": {"effort": "medium"},
"system": "Respondes a perguntas sobre o contrato abaixo. Cita os números das cláusulas.\n\n<contract>...</contract>",
"messages": [
{"role": "user", "content": "Enumera todos os direitos de rescisão e o respetivo prazo de pré-aviso."}
]
}
Coloca primeiro o conteúdo estável (prompt de sistema, definições de ferramentas, o documento) e no fim a pergunta que muda. Numa conversa com vários turnos ou num ciclo de agent, cada novo turno volta a ler o prefixo anterior a partir da cache. A cache de 5 minutos custa 1,25× o preço de entrada a escrever e compensa após uma leitura; a cache de 1 hora custa 2× e compensa após duas.
Dois hábitos mantêm a cache e o raciocínio do modelo a funcionar ao longo dos turnos:
- Mantém o histórico só com acréscimos. Cada bloco de thinking está ligado ao prompt de sistema, às ferramentas e às mensagens que o antecederam. Mantém
systemetoolsfixos durante uma conversa e acrescenta os novos turnos ao fim demessages. Se editares turnos anteriores e voltares a enviar os blocos de thinking antigos, a verificação de prefixo da API assinala o pedido com a mensagemThe block is bound to a different conversation. Para mudar as instruções, inicia uma conversa nova. - Muda de modelo sempre que quiseres. Podes alterar
modelentre pedidos da mesma conversa. Os blocos de thinking do Fable 5.2 são lidos pelo Fable 5.2 e pelo Mythos 5.2; quando a conversa passa para outro modelo, como o Opus 5.5, a API descarta esses blocos automaticamente, o pedido é concluído com êxito e o novo modelo continua com o seu próprio raciocínio. Cada modelo mantém a sua própria cache.
Tratar recusas
O Fable 5.2 corre classificadores de segurança. Quando um deles trava um pedido, a resposta chega como HTTP 200 com stop_reason: "refusal" e um objeto stop_details que indica a área de política, por exemplo cyber, bio ou reasoning_extraction. O teu código deve:
- Verificar
stop_reasonantes de lercontent, como fazem os exemplos de Python e TypeScript acima. - Registar
stop_details.categorypara veres que prompts a desencadeiam. - Enviar o pedido para outro modelo, como o Opus 5.5, ou mostrar ao utilizador uma mensagem clara.
Para veres como o modelo raciocinou, pede o raciocínio com "display": "summarized". Assim o raciocínio fica fora do texto da resposta, que é a área abrangida pela categoria reasoning_extraction.
Migrar do Fable 5.1 ou do Opus 5.5
| Vens do | O que muda |
|---|---|
| Claude Fable 5.1 | Troca o ID do modelo. Os preços descem de $10 / $50 para $8 / $40. A verificação de prefixo aplica-se agora a todas as contas, por isso mantém os históricos só com acréscimos. Usa computer_toolset_20260801 para a utilização do computador. Com a ferramenta advisor, define o advisor como claude-fable-5-2. Volta a correr a tua comparação de esforço a partir de high |
| Claude Opus 5.5 | O preço por token passa de $4 / $20 para $8 / $40; as leituras da cache mantêm-se a $0.20. O esforço predefinido passa de medium para high, por isso define-o explicitamente. O Fable 5.2 funciona com retenção de dados de 30 dias. As regras de raciocínio e de tool_choice são as mesmas |
| Claude Opus 5 ou anterior | Deixa o raciocínio correr de forma adaptativa e orienta-o com effort em vez de disabled e budget_tokens. Usa tool_choice auto com uma instrução, ou saída estruturada para JSON. Deixa o modelo gerir a amostragem em vez de temperature, top_p e top_k. Dimensiona max_tokens para o raciocínio mais a resposta |
Vale a pena rever os prompts trazidos de modelos anteriores. Em tarefas longas com vários passos, a Anthropic recomenda acrescentar ao prompt de sistema uma instrução para “terminar a tarefa toda”, sobretudo com esforço low e medium. O Fable 5.2 segue as regras de estilo à risca, por isso alivia os limites rígidos de comprimento de frase escritos para modelos mais antigos, para manter a escrita natural. Inicia uma conversa nova quando alterares o prompt.
Quanto custa um pedido
Os tokens de saída abaixo incluem o raciocínio. Todos os preços são por milhão de tokens.
| Cenário | Tokens | Oficial ($8 / $40) | PoYo ($6.40 / $32) |
|---|---|---|---|
| Resposta de chat | 5K de entrada + 1K de saída | 0.005×8 + 0.001×40 = $0.080 | 0.005×6.4 + 0.001×32 = $0.064 (12.8 créditos) |
| Revisão de código | 50K de entrada + 8K de saída | 0.05×8 + 0.008×40 = $0.72 | 0.05×6.4 + 0.008×32 = $0.576 (115.2 créditos) |
| Sessão de agent | 2M de leituras em cache + 300K de entrada nova + 150K de saída | 2×0.2 + 0.3×8 + 0.15×40 = $8.80 | 2×0.16 + 0.3×6.4 + 0.15×32 = $7.04 |
| Documento de 800K tokens, primeira pergunta | 800K escritos na cache de 5 minutos + 10K de saída | 0.8×10 + 0.01×40 = $8.40 | 0.8×8 + 0.01×32 = $6.72 |
| Mesmo documento, pergunta seguinte | 800K de leitura da cache + 10K de saída | 0.8×0.2 + 0.01×40 = $0.56 | 0.8×0.16 + 0.01×32 = $0.45 |
As linhas do documento mostram porque é que a cache importa: depois da primeira pergunta, cada pergunta seguinte custa cerca de um quinze avos. Na sessão de agent, a saída representa cerca de dois terços da fatura, e é por isso que o esforço é a primeira definição a afinar.
Usar o Claude Fable 5.2 na PoYo
A PoYo dá-te o Fable 5.2 20% abaixo das tarifas oficiais por token da Anthropic, com alguns extras práticos:
- Uma chave de API para todos os modelos. O Fable 5.2, o Opus 5.5, o Sonnet 5.5, os modelos GPT e os modelos de imagem, vídeo e áudio partilham a mesma chave e o mesmo painel.
- Pagas conforme a utilização. Os créditos são faturados por token, sem subscrição.
- Os dois formatos de pedido. Chama o Fable 5.2 no formato Anthropic Messages ou no formato OpenAI Chat Completions com o mesmo ID de modelo.
Testa prompts no Playground da página do modelo Claude Fable 5.2 e depois leva o mesmo ID de modelo para produção. Para o comparares com a predefinição do dia a dia, muda "model" para claude-opus-5-5 na página do Claude Opus 5.5, com a mesma chave.
Perguntas frequentes
Quanto custa a API do Claude Fable 5.2?
$8 por milhão de tokens de entrada e $40 por milhão de tokens de saída na API da Anthropic, com as leituras da cache a $0.20. Na PoYo, o mesmo modelo custa $6.40 de entrada, $32 de saída e $0.16 nas leituras da cache, por milhão de tokens. Os tokens de raciocínio são faturados à tarifa de saída.
Qual é o preço do Claude Fable 5?
O Claude Fable 5 (junho de 2026) custa $10 / $50 por milhão de tokens de entrada/saída, com as leituras da cache a $1. O Fable 5.1 manteve o preço de $10 / $50 e baixou as leituras da cache para $0.25. O Fable 5.2 desce para $8 / $40, com leituras da cache a $0.20.
Qual é o ID do modelo Claude Fable 5.2?
claude-fable-5-2, exatamente como está escrito. Usa-o em /v1/messages ou em /v1/chat/completions.
Posso usar o SDK da Anthropic com a PoYo?
Sim. Define o URL base como https://api.poyo.ai e passa a tua chave da PoYo como chave de API. O SDK envia x-api-key e anthropic-version por ti, e o streaming funciona com os helpers de stream do SDK.
Como faço o Fable 5.2 raciocinar menos?
Define output_config.effort como low ou medium. O raciocínio adaptativo corre em todos os pedidos e acompanha o nível de esforço, por isso um nível mais baixo dá respostas mais rápidas e mais baratas.
Que nível de esforço devo usar?
Começa em medium para trabalho interativo e programação de rotina, e em high para tarefas de agent difíceis e longas. Passa para xhigh onde as tuas avaliações mostrem um ganho, e usa low para chamadas simples e de grande volume.
Como é faturado o contexto longo?
Toda a janela de 1M tokens é faturada à tarifa standard, por isso os prompts longos custam o mesmo por token do que os curtos. O prompt caching reduz ainda mais o custo de voltar a ler contexto longo.
Posso mudar de modelo ou editar mensagens a meio de uma conversa?
Podes mudar de modelo em qualquer momento: envia o pedido seguinte com outro model, e a API descarta automaticamente os blocos de thinking anteriores onde for preciso, para que o pedido seja concluído com êxito. Quanto a edições, mantém system e tools fixos, acrescenta mensagens novas e devolve cada turno do assistente exatamente como o recebeste; a verificação de prefixo assinala os históricos cujos turnos anteriores mudaram depois de um bloco de thinking ter sido produzido. Para mudar as instruções, inicia uma conversa nova.
Em que é que o Fable 5.2 difere do Mythos 5.2?
Partilham as mesmas capacidades, especificações e preços. O Mythos 5.2 é disponibilizado a organizações verificadas através dos programas da Anthropic, como o Cyber Verification Program, enquanto o Fable 5.2 está aberto a todos os programadores.