Anthropic lanzó Claude Fable 5 el 9 de junio de 2026, y si te dedicas a escribir código, la API de Claude Fable 5 es la parte que te interesa. Funciona con la misma API de Mensajes que ya conoces, por lo que la cadena del modelo es lo único que realmente cambia: claude-fable-5. Esta guía te lleva por cada llamada que necesitas para obtener código funcional ante una respuesta real, desde una solicitud curl de una línea hasta streaming, uso de herramientas, manejo de errores y cálculo de costos. Si ya has trabajado con Claude antes, la estructura te resultará familiar. Si migraste desde un modelo más antiguo, el cambio es principalmente un intercambio de cadenas, de la misma manera que lo fue para la API de Claude Opus 4.8.
TL;DR
Obtén una clave API desde la Consola de Anthropic, configúrala como ANTHROPIC_API_KEY, luego POST a la API de Mensajes con model: "claude-fable-5", un valor de max_tokens y un array de messages. Usa el SDK oficial de Anthropic para Python o TypeScript, o HTTP puro. Transmite las salidas largas para evitar tiempos de espera de solicitud. El precio es de $10 por millón de tokens de entrada y $50 por millón de tokens de salida.
Antes de empezar
Necesitas cuatro cosas antes de tu primera solicitud:
- Una cuenta de Anthropic. Regístrate en console.anthropic.com. La Consola es donde gestionas las claves, el uso y la facturación.
- Una clave API. Crea una en la Consola bajo "Claves API". Cópiala una vez; no la volverás a ver. Trátala como una contraseña.
- Facturación o un plan Enterprise. Fable 5 está disponible en la API estándar de Claude y está totalmente disponible en los planes Enterprise basados en consumo. Añade un método de pago o confirma que tu plan lo cubre antes de enviar tráfico. Si aún estás decidiendo si Fable 5 se ajusta a tu caso de uso, la descripción general de qué es Claude Fable 5 cubre las fortalezas del modelo en términos sencillos.
- Un SDK (opcional pero recomendado). Instala el SDK oficial de Anthropic para tu lenguaje. También puedes llamar al endpoint HTTP puro con curl o cualquier cliente HTTP si lo prefieres.
Configura la clave como una variable de entorno para que nunca termine en tu código fuente:
export ANTHROPIC_API_KEY="sk-ant-..."
Ambos SDK leen ANTHROPIC_API_KEY del entorno automáticamente, por lo que rara vez la pasas en el código. Mantén las claves fuera de git. Si una clave se filtra, gírala en la Consola de inmediato.
Un comportamiento a conocer de antemano: Fable 5 viene con salvaguardias que dirigen un pequeño segmento de consultas sensibles (ciberseguridad, biología y química, e intentos de destilación de modelos) a Claude Opus 4.8 en su lugar. Esto se activa en menos del 5% de las sesiones. No necesitas configurar nada para ello, pero explica la respuesta ocasional que regresa etiquetada como un modelo diferente. Más sobre esto en la sección de manejo de errores.
Tu primera llamada a la API de Claude Fable 5
Comienza con curl para que puedas ver la solicitud y la respuesta en bruto sin obstáculos. El endpoint es POST https://api.anthropic.com/v1/messages, documentado en la referencia de la API de Mensajes de Anthropic, y necesita tres encabezados más un cuerpo 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."}]}'
Aquí importan tres encabezados. x-api-key lleva tu clave. anthropic-version fija la versión de la API (2023-06-01 es el valor estable actual). content-type le dice al servidor que estás enviando JSON. El cuerpo tiene tres campos obligatorios: model, max_tokens y messages. Ese es todo el contrato.
La respuesta regresa como un objeto JSON. La parte que te interesa es content, que es una lista de bloques:
{
"id": "msg_01ABC...",
"type": "message",
"role": "assistant",
"model": "claude-fable-5",
"content": [
{ "type": "text", "text": "- Predictable, resource-oriented URLs..." }
],
"stop_reason": "end_turn",
"usage": { "input_tokens": 18, "output_tokens": 96 }
}
content es una lista, no una cadena, porque una única respuesta puede mezclar texto, bloques de uso de herramientas y bloques de pensamiento. Siempre recorre la lista y verifica el type de cada bloque antes de leer text. El stop_reason te dice por qué el modelo se detuvo (end_turn es un final limpio), y usage te da el recuento de tokens que usarás para el cálculo de costos más adelante.
Llamando a Fable 5 desde Python
El SDK oficial de Anthropic para Python elimina el encabezado y la estructura JSON. Instálalo primero:
pip install anthropic
Aquí está la llamada básica. El cliente lee tu clave del entorno, por lo que no necesitas pasarla en el código:
import anthropic
client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY from env
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Summarize what makes a good REST API."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
El patrón es similar a la llamada curl. Pasas model, max_tokens y messages, y recibes una respuesta cuyo content es una lista de bloques. El bucle se protege con block.type == "text" para que nunca te encuentres con un bloque que no sea de texto.
Añadiendo un mensaje de sistema
Un mensaje de sistema establece el rol del modelo y las reglas básicas para toda la conversación. Pásalo como el campo system, separado de messages:
response = client.messages.create(
model="claude-fable-5",
max_tokens=2048,
system="You are a senior backend engineer. Be concise and use code examples.",
messages=[{"role": "user", "content": "Write a Flask route that validates a JSON body."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
El mensaje de sistema es el lugar adecuado para la persona, las reglas de formato de salida y las restricciones que deseas mantener en cada turno. Mantenlo estable, porque cambiarlo en cada solicitud anula el almacenamiento en caché de los mensajes si lo añades más tarde.
Transmisión de salidas largas
Para cualquier cosa que produzca una respuesta larga, transmítela. La transmisión envía tokens a medida que se generan, por lo que muestras el progreso de inmediato y evitas los tiempos de espera de las solicitudes que afectan a las respuestas grandes no transmitidas. El trabajo de largo horizonte de Fable 5 lo convierte en la opción predeterminada para cargas de trabajo reales:
with client.messages.stream(
model="claude-fable-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Explain idempotency keys for payment APIs."}],
) 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 produce fragmentos de texto a medida que llegan. El flush=True es importante para que cada fragmento se imprima de inmediato en lugar de ser almacenado en búfer. Cuando la transmisión finaliza, stream.get_final_message() te entrega el mensaje completo ensamblado, incluyendo los números finales de usage, para que obtengas la experiencia de usuario transmitida y el objeto completo sin una segunda solicitud.
Llamando a Fable 5 desde TypeScript / Node
El SDK de Node sigue la misma estructura. Instálalo:
npm install @anthropic-ai/sdk
Luego, haz la llamada. El cliente lee ANTHROPIC_API_KEY del entorno, al igual que Python:
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic(); // reads ANTHROPIC_API_KEY
const msg = await client.messages.create({
model: "claude-fable-5",
max_tokens: 1024,
messages: [{ role: "user", content: "List 3 common API security mistakes." }],
});
console.log(msg.content);
msg.content es la misma lista de bloques que viste en Python y curl. Para extraer solo el texto, filtra por el tipo de bloque:
const text = msg.content
.filter((block) => block.type === "text")
.map((block) => block.text)
.join("");
console.log(text);
La transmisión funciona de la misma manera que en Python. Usa client.messages.stream({...}) e itera los eventos, o espera finalMessage() para obtener el resultado ensamblado. Si estás conectando esto a un chat de frontend, transmite desde una ruta del servidor y reenvía los fragmentos al navegador. Los mismos hábitos de prueba se aplican tanto si construyes en Node como en Python, y una herramienta como Apidog facilita la verificación del contrato antes de escribir cualquier código de cliente, lo cual es el mismo flujo de trabajo cubierto en probando la API de ChatGPT con Apidog.
Uso de herramientas (llamada a funciones) con Fable 5
El uso de herramientas permite a Fable 5 llamar a funciones que tú defines. Describes una herramienta con un esquema JSON, el modelo decide cuándo llamarla, y tú ejecutas la función real y devuelves el resultado. Fable 5 es fuerte en el uso de herramientas, por lo que encaja bien en los bucles de agentes.
Define una herramienta con un nombre, una descripción y un input_schema:
tools = [
{
"name": "get_order_status",
"description": "Look up the status of a customer order by ID.",
"input_schema": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
}
]
Pasa tools a la solicitud de la misma manera que pasas messages:
messages = [{"role": "user", "content": "What's the status of order A1855?"}]
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
Cuando el modelo quiere usar una herramienta, la respuesta regresa con stop_reason == "tool_use" y un bloque tool_use que lleva el nombre de la herramienta y la entrada que eligió. El bucle es sencillo: añade la respuesta del asistente, ejecuta la herramienta y luego envía el resultado como un bloque tool_result en un nuevo turno de usuario:
if response.stop_reason == "tool_use":
tool_use = next(b for b in response.content if b.type == "tool_use")
# Run your real function with the model's chosen input
result = lookup_order(tool_use.input["order_id"]) # your code
messages.append({"role": "assistant", "content": response.content})
messages.append({
"role": "user",
"content": [{
"type": "tool_result",
"tool_use_id": tool_use.id,
"content": result,
}],
})
# Send the result back; the model now answers using it
followup = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
El detalle clave es tool_use_id: el bloque tool_result debe hacer referencia al id exacto del bloque tool_use para que el modelo sepa a qué llamada responde tu resultado. Para agentes de varios pasos, envuelves esto en un bucle que continúa hasta que stop_reason sea end_turn. El SDK de Python también incluye un ejecutor de herramientas que maneja el bucle por ti, pero la versión manual anterior muestra lo que está sucediendo internamente y te da un lugar para agregar puertas de aprobación o registro.
Pensamiento adaptativo y esfuerzo
Fable 5 admite el pensamiento adaptativo, donde el modelo decide por sí mismo cuándo y con qué profundidad razonar antes de responder. Es opcional. Actívalo pasando thinking, y ajusta la profundidad general y el gasto de tokens con 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": "Design a retry strategy for a flaky webhook receiver."}],
)
effort controla cuánto piensa y trabaja el modelo: menor esfuerzo significa respuestas más concisas y rápidas, mayor esfuerzo significa un razonamiento más exhaustivo a un mayor costo de tokens. Déjalos desactivados para búsquedas simples y respuestas cortas, donde el razonamiento adicional no vale los tokens. Úsalos para problemas difíciles y de varios pasos, el tipo de planificación a largo plazo para el que Fable 5 está diseñado. Mantenlo simple para empezar; puedes añadir thinking más tarde una vez que sepas que una ruta lo necesita.
Manejo de errores y el fallback de salvaguardia
Las integraciones reales deben manejar los fallos de manera limpia. El SDK lanza excepciones tipadas, así que atrapa la clase específica en lugar de coincidir cadenas de error. Las tres que verás con más frecuencia se corresponden con HTTP 401, 429 y 400:
import anthropic
client = anthropic.Anthropic()
try:
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain CORS preflight requests."}],
)
except anthropic.AuthenticationError:
# 401: bad or missing API key. Check ANTHROPIC_API_KEY.
print("Invalid API key. Rotate it in the Console and re-export.")
except anthropic.RateLimitError as e:
# 429: too many requests. Back off and retry.
retry_after = e.response.headers.get("retry-after", "60")
print(f"Rate limited. Retry after {retry_after}s.")
except anthropic.BadRequestError as e:
# 400: malformed request (bad params, empty messages, wrong shape).
print(f"Bad request: {e.message}")
Aquí está lo que significa cada uno y cómo solucionarlo:
- 401 (
AuthenticationError): la clave falta, está mal formada o revocada. Confirma queANTHROPIC_API_KEYestá configurada en el entorno donde tu código realmente se ejecuta y que la clave sigue activa en la Consola. - 429 (
RateLimitError): superaste tu límite de solicitudes por minuto o tokens por minuto. El SDK ya reintenta los errores 429 y 5xx con retroceso exponencial (dos reintentos por defecto). Lee el encabezadoretry-aftersi añades un retroceso personalizado. - 400 (
BadRequestError): la solicitud está mal formada. Las causas comunes son un arraymessagesvacío, unmax_tokensfaltante o mensajes que no alternan los roles correctamente. El mensaje de error suele nombrar el campo.
Ahora, el fallback de salvaguardia. Fable 5 redirige un pequeño conjunto de consultas sensibles (ciberseguridad, biología y química, e intentos de destilación de modelos) a Claude Opus 4.8 en lugar de responder directamente. Esto se activa en menos del 5% de las sesiones. No es un error y tu solicitud aún tiene éxito, pero la respuesta puede venir etiquetada con un modelo diferente. Si registras o afirmas sobre response.model, no falles estrepitosamente cuando no sea claude-fable-5; la solicitud fue manejada, solo que por un modelo diferente internamente. Si tu aplicación necesita estrictamente saber qué modelo respondió, lee response.model del objeto devuelto en lugar de asumir que coincide con lo que enviaste.
Estimación del costo por solicitud
El precio es de $10 por millón de tokens de entrada y $50 por millón de tokens de salida. Cada respuesta lleva los recuentos exactos en usage, por lo que puedes calcular el costo por solicitud con precisión en lugar de adivinar:
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Write a SQL query to find duplicate emails."}],
)
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"Input: {input_tokens} tokens = ${input_cost:.6f}")
print(f"Output: {output_tokens} tokens = ${output_cost:.6f}")
print(f"Total: ${total:.6f}")
Los tokens de salida cuestan cinco veces más que los tokens de entrada, por lo que la palanca más barata que tienes es mantener las respuestas concisas. Una solicitud con 2,000 tokens de entrada y 500 tokens de salida cuesta 2000 / 1M * $10 + 500 / 1M * $50, lo que equivale a $0.02 + $0.025 = $0.045. Multiplica por tu volumen de solicitudes para establecer un presupuesto. Si el costo de salida domina tu factura, limita max_tokens y solicita respuestas concisas en el mensaje del sistema. La fijación de precios de salida es el mismo cálculo que ejecutarías para el modelo de precios de Claude Opus 4.8, solo que con los números de Fable 5.
Prueba y depura la API de Claude Fable 5 con Apidog
Antes de escribir código de cliente, vale la pena enviar algunas solicitudes manualmente y observar exactamente lo que regresa. Apidog es un cliente API construido para esto: envías solicitudes reales a https://api.anthropic.com/v1/messages, inspeccionas la respuesta transmitida y guardas la solicitud para que todo tu equipo trabaje desde la misma definición. Aquí hay un camino claro desde cero hasta una solicitud guardada y funcional.
- Crea la solicitud. En Apidog, haz una nueva solicitud HTTP, establece el método en
POSTy pega la URLhttps://api.anthropic.com/v1/messages. Este es el mismo endpoint que utilizan todos los ejemplos de esta guía. - Almacena tu clave como una variable de entorno. Crea una variable de entorno en Apidog, llámala algo como
anthropic_api_keyy pega tu clave como un valor secreto. Mantener la clave en el entorno significa que se mantiene fuera de la solicitud guardada y de cualquier exportación que compartas. - Configura los encabezados. Añade
x-api-keycon el valor{{anthropic_api_key}}, luegoanthropic-version: 2023-06-01ycontent-type: application/json. Si prefieres una variable secreta tipo Bearer, almacena el token de la misma manera y haz referencia a él con la sintaxis{{...}}para que el valor en bruto nunca aparezca en la solicitud. - Añade el cuerpo JSON. Inserta la carga útil mínima:
{"model": "claude-fable-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explain idempotency keys for payment APIs."}]}. Envíala y lee la respuesta. Deberías ver los bloquescontent,stop_reasonyusagedirectamente en el panel de respuesta. - Visualiza las respuestas transmitidas. Establece
"stream": trueen el cuerpo y vuelve a enviar. Apidog renderiza los eventos enviados por el servidor a medida que llegan, para que puedas ver los tokens transmitirse y confirmar que tu lógica de transmisión coincide con lo que la API realmente envía antes de implementarlo en una aplicación. - Guarda y genera código. Guarda la solicitud en una colección para que los compañeros de equipo puedan reutilizarla, luego usa la generación de código de Apidog para exportar un fragmento funcional en Python, JavaScript, curl u otro lenguaje. Esto te da un punto de partida probado en lugar de un archivo en blanco.
Este flujo es la forma más rápida de aprender la forma exacta de la respuesta de la API y de depurar una solicitud que se comporta mal en tu aplicación, ya que puedes comparar la solicitud de tu código con una conocida y buena lado a lado. Cuando estés listo para configurarlo, Descarga Apidog y comienza con el cuerpo mínimo anterior.