Claude Opus 5 · API

Inicio rápido

Dos pasos: envía una petición y luego recibe la respuesta en streaming. Sustituye YOUR_API_KEY por tu clave y los comandos de abajo funcionan tal cual. El endpoint sigue el formato Chat Completions de OpenAI, así que al código de OpenAI que ya tengas solo hay que cambiarle base_url y model.

Paso 1 · Envía una petición

curl https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-opus-5", "messages": [{"role": "user", "content": "Explica la fotosíntesis en una frase"}]}'

Respuesta (HTTP 200)

{
  "id": "chatcmpl-7f3c9a1e2b4d6f8a",
  "object": "chat.completion",
  "created": 1791281400,
  "model": "claude-opus-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "La fotosíntesis es el proceso por el que las plantas usan la luz solar para transformar el dióxido de carbono y el agua en azúcar y liberar oxígeno."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 42,
    "total_tokens": 60
  }
}

message.content es la respuesta y usage recoge los tokens que se cobran en esta petición; para ver cómo se cobra la caché, consulta la sección de caché de prompts más abajo.

Paso 2 · Recibe la respuesta en streaming (recomendado)

curl -N https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-opus-5", "stream": true, "messages": [{"role": "user", "content": "Explica la fotosíntesis en una frase"}]}'

El streaming es SSE estándar: cada fragmento lleva texto en choices[0].delta.content, el último fragmento lleva usage y al final llega data: [DONE]. Usa streaming con respuestas largas y con modelos de razonamiento: una petición sin streaming se corta pasados unos 10 minutos.

Python (SDK de OpenAI)

from openai import OpenAI

client = OpenAI(base_url="https://nezhagate.com/v1", api_key="YOUR_API_KEY")

# 1. Una petición, una respuesta
resp = client.chat.completions.create(
    model="claude-opus-5",
    messages=[{"role": "user", "content": "Explica la fotosíntesis en una frase"}],
)
print(resp.choices[0].message.content)

# 2. En streaming
stream = client.chat.completions.create(
    model="claude-opus-5",
    messages=[{"role": "user", "content": "Explica la fotosíntesis en una frase"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

O usa el SDK de Anthropic (API nativa)

import anthropic

client = anthropic.Anthropic(base_url="https://nezhagate.com/anthropic", api_key="YOUR_API_KEY")
msg = client.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explica la fotosíntesis en una frase"}],
)
print(next(b.text for b in msg.content if b.type == "text"))

En el SDK de Anthropic, el base_url termina en /anthropic: el SDK añade /v1/messages por su cuenta. La clave es la misma que arriba.

Autenticación

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Crea una clave API en la consola para empezar.

De un vistazo

Parámetros de la petición

El cuerpo JSON de POST /v1/chat/completions, igual que en la API Chat Completions de OpenAI. Estos son los parámetros habituales y lo que hace cada uno en este modelo:

Los demás parámetros de OpenAI (como stop, seed o user) se pasan al modelo tal cual; que tengan efecto o no depende del modelo.

Precio

Se cobra por token, a las tarifas vigentes de la tabla de abajo (por millón de tokens). Los tokens que se escriben en la caché de prompts se cobran a la tarifa de escritura en caché, y los aciertos de caché, a la tarifa de acierto. Solo se cobran las peticiones que salen bien, según el uso real. 1 crédito = $0.005.

Por ejemplo, una petición con 2 000 tokens de entrada y 1 000 tokens de salida (razonamiento incluido) cuesta aproximadamente $0.028.

Razonamiento

Razonamiento adaptativo, activado por defecto: el modelo decide cuánto merece razonar cada pregunta. reasoning_effort acepta low / medium / high / xhigh / max y se pasa a Claude como output_config.effort; el nivel también puede ir en el ID del modelo, por ejemplo claude-opus-5-high, y se cobra como claude-opus-5.

Para obtener resúmenes del razonamiento, usa la API nativa /anthropic con "thinking": {"type": "adaptive", "display": "summarized"} en la petición; el esfuerzo va en "output_config": {"effort": "high"}.

Este modelo permite desactivar el razonamiento: envía "thinking": {"type": "disabled"}.

Los tokens de razonamiento cuentan como tokens de salida y se cobran al precio de salida.

Caché de prompts

Los prompts largos pueden escribirse en la caché automáticamente aunque no lleven ninguna marca (a la tarifa de escritura en caché), y después un prefijo repetido se cobra a la tarifa de acierto de caché. En la API nativa /anthropic puedes decidir tú dónde va la caché con "cache_control": {"type": "ephemeral"} en el prompt de sistema o en un bloque de mensaje; Claude Code lo hace por ti.

La API nativa devuelve los tokens de caché en usage.cache_creation_input_tokens (escritos) y usage.cache_read_input_tokens (aciertos), y el cobro se calcula con esas cifras.

Entrada de imágenes

Pon una parte image_url en el array content. Lo recomendado es un data URI en base64 (data:image/png;base64,...), que todas las líneas pueden leer; un enlace público a una imagen tiene que descargarlo la línea, y alguna línea puede no conseguirlo o agotar el tiempo de espera. Las imágenes cuentan como tokens de entrada según las reglas del proveedor.

curl https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-opus-5", "messages": [{"role": "user", "content": [{"type": "text", "text": "¿Qué hay en esta imagen?"}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBORw0KGgo..."}}]}]}'

Llamadas a herramientas (function calling)

Describe tus funciones en tools con JSON Schema. Cuando el modelo decide llamar a una, devuelve finish_reason: "tool_calls" con el nombre de la función y los argumentos (una cadena JSON) en message.tool_calls.

curl https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-opus-5", "messages": [{"role": "user", "content": "¿Qué tiempo hace ahora en Shanghái?"}], "tools": [{"type": "function", "function": {"name": "get_weather", "description": "Current weather of a city", "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}}}]}'

Ejecuta la función, añade el resultado como un mensaje role: "tool" con el tool_call_id correspondiente y vuelve a enviar la conversación; entonces el modelo dará su respuesta final. tool_choice acepta auto, none, required o una función concreta.

Búsqueda web

Añade "web_search": true a la petición (o una entrada {"type": "web_search"} en tools): la pasarela primero busca en la web en tiempo real según la conversación, entrega al modelo hasta 5 resultados con sus enlaces como referencia, y el modelo responde citando sus fuentes. La búsqueda en sí es gratis; el texto de referencia se cobra como tokens de entrada.

curl https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-opus-5", "web_search": true, "messages": [{"role": "user", "content": "¿Cuáles son las noticias de tecnología más importantes de hoy?"}]}'

La API nativa de Anthropic (/anthropic)

• El endpoint es https://nezhagate.com/anthropic/v1/messages, y las peticiones y respuestas usan el formato Messages de Anthropic: los eventos de streaming, las llamadas a herramientas (tool_use / tool_result) y los bloques de imagen son idénticos a los de Anthropic, así que el SDK de Anthropic y Claude Code funcionan tal cual.
• Autentícate con x-api-key: YOUR_API_KEY (también vale Authorization: Bearer); la clave es la misma que en /v1. Las cabeceras anthropic-version y anthropic-beta se reenvían tal cual, y max_tokens es obligatorio.
• Aquí solo se sirven modelos Claude; cualquier otro modelo devuelve 404 not_found_error. También están disponibles POST /anthropic/v1/messages/count_tokens (cuenta tokens, gratis) y GET /anthropic/v1/models.
• Resúmenes del razonamiento: "thinking": {"type": "adaptive", "display": "summarized"}; esfuerzo: "output_config": {"effort": "high"} (de low a max). temperature, top_p y top_k se eliminan.
• Los errores llegan en el formato de Anthropic, {"type": "error", "error": {"type": ..., "message": ...}}; si el saldo no alcanza, se devuelve 402 billing_error.
• En este endpoint la búsqueda web está desactivada por defecto (así nunca altera el prefijo que Claude Code repite en cada turno ni rompe su caché); actívala con la cabecera x-web-search: 1.

curl https://nezhagate.com/anthropic/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-opus-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explica la fotosíntesis en una frase"}]}'

Úsalo en Claude Code →

Líneas y fiabilidad

• Cada modelo se sirve por varias líneas. Si una da error, agota el tiempo de espera o está ocupada, la pasarela pasa a la siguiente antes de devolver nada, así que no tienes que reintentar y nunca se cobra dos veces.
• Cuando un streaming empieza a enviar datos, ya no cambia de línea: si se corta a medias, se cobra el uso generado hasta ese momento (consulta Facturación y reembolsos).
• Cuando todas las líneas están ocupadas, la pasarela devuelve 429 con Retry-After: espera esos segundos y reintenta. Las peticiones fallidas no se cobran. El estado de cada modelo aparece en la página de estado.

Errores y reembolsos

Los errores llegan como un objeto error (message, type, code, param); decide según el estado HTTP y code, nunca comparando el texto de message. Las peticiones fallidas no se cobran; la lista completa está en Códigos de error.

Si un streaming falla después de empezar a enviar datos, el código de estado no cambia: el error llega como una línea de datos con error, o el streaming simplemente termina (sin data: [DONE]). Trátalo como interrumpido.