DEV Community

Cover image for Cómo usar la API de Claude Fable 5
Roobia
Roobia

Posted on • Originally published at apidog.com

Cómo usar la API de Claude Fable 5

Anthropic lanzó Claude Fable 5 el 9 de junio de 2026. Si construyes integraciones o herramientas para desarrolladores, lo importante es que se usa con la misma API de Mensajes de Claude: solo cambias el modelo a claude-fable-5. En esta guía verás cómo hacer la primera llamada, usar Python y TypeScript, activar streaming, trabajar con herramientas, manejar errores y calcular costos por solicitud.

Prueba Apidog hoy

TL;DR

  1. Crea una clave en la Consola de Anthropic.
  2. Expórtala como variable de entorno: 
export ANTHROPIC_API_KEY="sk-ant-..."
Enter fullscreen mode Exit fullscreen mode
  1. Envía un POST a https://api.anthropic.com/v1/messages con: 
{
  "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

Puedes usar curl, HTTP puro o los SDK oficiales de Anthropic para Python y TypeScript. Para respuestas largas, usa streaming. El precio indicado es de $10 por millón de tokens de entrada y $50 por millón de tokens de salida.

Claude Fable 5 API

Antes de empezar

Necesitas cuatro cosas:

  1. Una cuenta de Anthropic. Regístrate en console.anthropic.com.
  2. Una clave API. Créala desde la sección de claves API de la consola. Cópiala una sola vez y trátala como una contraseña.
  3. Facturación activa o plan Enterprise. Fable 5 está disponible en la API estándar de Claude y en planes Enterprise basados en consumo. Si todavía estás evaluando el modelo, revisa la guía sobre qué es Claude Fable 5.
  4. Un SDK opcional. Puedes usar el SDK oficial de Anthropic o hacer llamadas HTTP directamente.

Consola de Anthropic

Configura la clave fuera del código fuente:

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

Los SDK oficiales leen ANTHROPIC_API_KEY automáticamente desde el entorno. No guardes claves en Git. Si una clave se filtra, rótala inmediatamente desde la consola.

Un detalle importante: Fable 5 puede redirigir un pequeño segmento de consultas sensibles —por ejemplo, ciberseguridad, biología, química o intentos de destilación de modelos— a Claude Opus 4.8. Esto ocurre en menos del 5% de las sesiones. No necesitas configurarlo, pero puede explicar por qué response.model a veces devuelve un modelo distinto.

Primera llamada a la API de Claude Fable 5

Empieza con curl para validar la solicitud sin SDKs:

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

El endpoint es:

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

La solicitud requiere estos encabezados:

Encabezado Uso
x-api-key Tu clave API
anthropic-version Versión de API, por ejemplo 2023-06-01
content-type Debe ser application/json

El cuerpo mínimo necesita:

Campo Descripción
model Usa claude-fable-5
max_tokens Máximo de tokens de salida
messages Lista de mensajes de la conversación

Ejemplo de respuesta:

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

No trates content como una cadena. Es una lista de bloques. Una respuesta puede incluir texto, llamadas a herramientas u otros bloques. Recorre la lista y valida type antes de leer text.

for block in response.content:
    if block.type == "text":
        print(block.text)
Enter fullscreen mode Exit fullscreen mode

stop_reason indica por qué terminó la generación. usage contiene los tokens de entrada y salida, útiles para calcular costos.

Usar Claude Fable 5 desde Python

Instala el SDK oficial:

pip install anthropic
Enter fullscreen mode Exit fullscreen mode

Ejemplo básico:

import anthropic

client = anthropic.Anthropic()  # lee ANTHROPIC_API_KEY del entorno

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

La estructura es la misma que en curl: defines model, max_tokens y messages.

Añadir un mensaje de sistema

Usa system para definir el rol, formato y restricciones globales del modelo:

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

Usa el mensaje de sistema para reglas persistentes, por ejemplo:

  • tono de respuesta;
  • idioma;
  • formato esperado;
  • nivel de detalle;
  • restricciones técnicas.

Mantén este mensaje estable si luego quieres aprovechar caché de prompts.

Streaming en Python

Para respuestas largas, usa streaming. Así puedes mostrar tokens conforme llegan y evitar timeouts en respuestas grandes:

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

stream.text_stream produce fragmentos de texto. Al final, stream.get_final_message() devuelve el mensaje completo con usage, sin hacer una segunda solicitud.

Usar Claude Fable 5 desde TypeScript / Node

Instala el SDK:

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

Ejemplo básico:

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

const client = new Anthropic(); // lee 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);
Enter fullscreen mode Exit fullscreen mode

Para extraer solo texto:

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

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

Si vas a conectar esto a una interfaz de chat, transmite desde una ruta de servidor y reenvía los fragmentos al navegador. Antes de escribir el cliente, puedes validar el contrato con Apidog siguiendo un flujo similar al de probar la API de ChatGPT con Apidog.

Uso de herramientas con Fable 5

El uso de herramientas permite que el modelo solicite la ejecución de funciones que tú defines. El flujo es:

  1. Defines una herramienta con esquema JSON.
  2. Envías la herramienta junto con el prompt.
  3. El modelo devuelve un bloque tool_use si quiere llamarla.
  4. Tu aplicación ejecuta la función real.
  5. Devuelves el resultado como tool_result.
  6. El modelo responde usando ese resultado.

Define una herramienta:

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

Pásala en la solicitud:

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

Procesa la llamada a herramienta:

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

    # Ejecuta tu función real con el input elegido por el modelo
    result = lookup_order(tool_use.input["order_id"])

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

    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

El campo crítico es tool_use_id. Debe coincidir con el id del bloque tool_use. Para agentes de varios pasos, envuelve este patrón en un bucle hasta que stop_reason sea end_turn.

Pensamiento adaptativo y esfuerzo

Fable 5 admite pensamiento adaptativo. Esto permite que el modelo decida cuándo razonar más profundamente antes de responder.

Actívalo así:

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

Usa effort según el tipo de tarea:

Valor Cuándo usarlo
low Respuestas cortas, transformaciones simples, clasificación
medium Diseño técnico moderado, explicaciones con pasos
high Problemas complejos, planificación, debugging avanzado

No lo actives por defecto en todas las rutas. Para búsquedas simples o respuestas breves, el razonamiento adicional puede aumentar el costo sin aportar valor.

Manejo de errores

En producción, captura excepciones tipadas. No compares strings de error.

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: clave inválida o ausente
    print("Invalid API key. Rotate it in the Console and re-export.")

except anthropic.RateLimitError as e:
    # 429: demasiadas solicitudes
    retry_after = e.response.headers.get("retry-after", "60")
    print(f"Rate limited. Retry after {retry_after}s.")

except anthropic.BadRequestError as e:
    # 400: solicitud mal formada
    print(f"Bad request: {e.message}")
Enter fullscreen mode Exit fullscreen mode

Errores comunes:

Error Causa probable Solución
401 AuthenticationError Clave ausente, inválida o revocada Revisa ANTHROPIC_API_KEY y la consola
429 RateLimitError Límite de RPM o TPM superado Aplica backoff y respeta retry-after
400 BadRequestError JSON inválido, messages vacío, falta max_tokens Valida el payload antes de enviar

El SDK reintenta errores 429 y 5xx con retroceso exponencial, con dos reintentos por defecto.

Manejar el fallback de salvaguardia

Fable 5 puede redirigir algunas consultas sensibles a Claude Opus 4.8. No es un error: la solicitud puede completarse correctamente, pero response.model puede no ser claude-fable-5.

No hagas esto:

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

Haz esto:

actual_model = response.model
print(f"Respuesta generada por: {actual_model}")
Enter fullscreen mode Exit fullscreen mode

Si tu sistema necesita auditoría estricta del modelo que respondió, guarda response.model desde el objeto devuelto.

Calcular costo por solicitud

El precio indicado es:

  • Entrada: $10 por millón de tokens
  • Salida: $50 por millón de tokens

Cada respuesta incluye usage, así que calcula el costo con datos reales:

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

Ejemplo:

2,000 tokens de entrada * $10 / 1,000,000 = $0.020
500 tokens de salida * $50 / 1,000,000 = $0.025

Total = $0.045
Enter fullscreen mode Exit fullscreen mode

Los tokens de salida cuestan más, así que optimiza primero la longitud de las respuestas:

  • limita max_tokens;
  • pide respuestas concisas en system;
  • evita prompts que pidan explicaciones innecesariamente largas;
  • usa streaming para respuestas extensas, pero recuerda que streaming no reduce el costo por sí mismo.

El cálculo es el mismo tipo de estimación que usarías al revisar los precios de Claude Opus 4.8, cambiando los valores por los de Fable 5.

Probar y depurar la API de Claude Fable 5 con Apidog

Antes de integrar el SDK en tu aplicación, prueba la llamada manualmente. Apidog te permite enviar solicitudes reales a https://api.anthropic.com/v1/messages, inspeccionar respuestas y guardar la configuración para tu equipo.

Probar Claude Fable 5 con Apidog

1. Crea una solicitud HTTP

En Apidog, crea una nueva solicitud:

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

2. Guarda la clave como variable

Crea una variable de entorno, por ejemplo:

anthropic_api_key
Enter fullscreen mode Exit fullscreen mode

Guárdala como valor secreto. Así no queda expuesta en la solicitud ni en exportaciones compartidas.

3. Configura los encabezados

Añade:

x-api-key: {{anthropic_api_key}}
anthropic-version: 2023-06-01
content-type: application/json
Enter fullscreen mode Exit fullscreen mode

4. Añade el cuerpo JSON mínimo 

{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Explain idempotency keys for payment APIs."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Envía la solicitud y revisa:

  • content;
  • stop_reason;
  • usage;
  • model.

5. Prueba streaming

Agrega stream: true:

{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Explain idempotency keys for payment APIs."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Esto te permite validar cómo llegan los eventos antes de implementar streaming en tu backend.

6. Guarda la solicitud y genera código

Guarda la solicitud en una colección. Luego puedes generar snippets en Python, JavaScript, curl u otros lenguajes desde una solicitud ya verificada.

Cuando estés listo para configurarlo, descarga Apidog y empieza con el cuerpo mínimo anterior.

Top comments (0)