OpenRouter: la API unificada para 400+ modelos de IA — guía completa (2026)

¿Qué es OpenRouter?

OpenRouter es una API unificada que te da acceso a 400+ modelos de IA de 70+ proveedores a través de un único endpoint, una sola API key y una sola factura. En lugar de gestionar cuentas separadas en Anthropic, OpenAI, Google, Meta, DeepSeek, Zhipu AI y docenas de labs más, OpenRouter las consolida en una sola interfaz compatible con OpenAI.

Pero OpenRouter no es solo un aggregator. Es una capa de routing inteligente que balancea carga entre proveedores, hace failover automático cuando uno cae, te da control sobre precios y latencia, y te permite cambiar de modelo con una línea de código.

¿Qué problema resuelve OpenRouter?

Si construyes aplicaciones con IA, te enfrentas a estos problemas:

• Múltiples cuentas y API keys: Una para Anthropic, otra para OpenAI, otra para Google, otra para DeepSeek... cada una con su billing, sus rate limits, sus SDKs
• Caídas de proveedores: Si la API de Anthropic cae a mitad de tráfico, tu app devuelve un 500. No hay fallback automático
• Gestión de costes fragmentada: No sabes cuánto gastas en total hasta que llegan las facturas de cada proveedor
• Cambiar de modelo es caro: Migrar de GPT a Claude requiere reescribir el código de integración
• Rate limits individuales: Cada proveedor tiene sus propios límites. Si los agotas, no puedes recurrir a otro

OpenRouter resuelve todo esto con una sola API que pasa los precios de los proveedores sin markup, pooling su uptime, y dando fallbacks automáticos para que obtengas mejor disponibilidad que yendo directo al proveedor.

Características principales

1. Una API para cualquier modelo

Acceso a todos los modelos principales через una interfaz unificada. El SDK de OpenAI funciona out-of-the-box. Solo cambias el base_url y el model.

2. Mayor disponibilidad con failover automático

OpenRouter enruta cada request a través de 70+ proveedores. Si uno cae o te rate-limitea, automáticamente prueba el siguiente. Esto pasa de forma transparente para tu app.

Hay dos capas de recuperación:

Capa	Qué recupera	Default
Provider failover	Caída o 429 del proveedor que sirve tu modelo	Activado (allow_fallbacks: true)
Model fallbacks	Modelo entero no disponible, errores de contexto, moderación	Opt-in vía array models

3. Routing inteligente de proveedores

Por defecto, OpenRouter envía tu request al proveedor más barato y confiable, ponderado por el inverso cuadrado del precio. Un proveedor a $1/M tokens es 9 veces más probable de ser elegido que uno a $3/M, porque (1/1²) vs (1/3²).

Proveedores con outage en los últimos 30 segundos se despriorizan automáticamente.

4. Políticas de datos personalizadas

Control granular sobre qué modelos y proveedores pueden recibir tus prompts. Ideal para entornos regulados donde ciertos proveedores no son aceptables por políticas de privacidad o jurisdicción.

5. Edge computing para mínima latencia

OpenRouter corre en el edge para minimizar la latencia entre tus usuarios y la inferencia. Cada modelo muestra su latencia (time to first token) y throughput para que puedas estimar tiempos.

Tipos de conexión y compatibilidad

OpenRouter soporta tres tipos de conexión principales, cada uno diseñado para un caso de uso diferente:

Tipo 1: API compatible con OpenAI

El endpoint principal de OpenRouter implementa la especificación OpenAI. Cualquier SDK de OpenAI funciona sin cambios:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-tu-api-key",
)

completion = client.chat.completions.create(
    model="anthropic/claude-sonnet-4.5",
    messages=[{"role": "user", "content": "¿Qué es RAG?"}],
)
print(completion.choices[0].message.content)

Tipo 2: API compatible con Anthropic (Anthropic Skin)

OpenRouter expone un endpoint compatible con la Anthropic Messages API en /api/v1/messages. Esto permite usar Claude Code, Cline, y cualquier herramienta que hable el protocolo de Anthropic:

from anthropic import Anthropic

client = Anthropic(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-tu-api-key",
)

message = client.messages.create(
    model="anthropic/claude-opus-4.8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explica transformers"}],
)

La "Anthropic Skin" de OpenRouter se comporta exactamente como la API de Anthropic: maneja model mapping, pasa features avanzadas como "Thinking" blocks y tool use nativo.

Tipo 3: API REST directa de OpenRouter

Para control máximo, usa la REST API directa con todos los parámetros de routing:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer sk-or-tu-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-4.5",
    "messages": [{"role": "user", "content": "Hola"}],
    "models": ["openai/gpt-5.4", "meta-llama/llama-4-maverick"],
    "provider": {
      "sort": "price",
      "max_price": {"prompt": 0.001, "completion": 0.002}
    }
  }'

Endpoints disponibles

Endpoint	Función
POST /v1/chat/completions	Chat completions (compatible OpenAI)
POST /v1/completions	Text completions
POST /v1/embeddings	Embeddings
POST /v1/messages	Anthropic Messages API (compatible Anthropic)
GET /v1/models	Listar todos los modelos disponibles
GET /v1/credits	Saldo y créditos restantes

Autenticación

OpenRouter usa tres métodos de autenticación:

1. Cookie-based: Para la interfaz web y chatroom
2. API keys (Bearer token): Para la API de completions y endpoints core
3. Management API keys: Para gestionar API keys programáticamente

Variantes de modelos

OpenRouter ofrece sufijos especiales que se añaden al model slug para cambiar su comportamiento. Hay dos tipos: estáticas (solo modelos específicos) y dinámicas (todos los modelos).

Variantes estáticas

Sufijo	Efecto
:free	Modelo gratis, rate limits bajos
:extended	Contexto más largo de lo normal
:thinking	Modelo soporta razonamiento por defecto

Variantes dinámicas

Sufijo	Efecto	Ideal para
:nitro	Ordena proveedores por throughput (velocidad)	Chat user-facing donde la latencia se siente
:floor	Ordena proveedores por precio (más barato)	Batch jobs donde el coste es la restricción
:exacto	Ordena por calidad, optimizado para tool-calling	Agentes y function calling confiable
:online	Busca en web y adjunta resultados (deprecado, usar web_search tool)	Búsqueda en tiempo real

Modelos destacados

OpenRouter da acceso a 400+ modelos. Estos son algunos de los más relevantes a mediados de 2026:

Modelos frontier (propietarios)

Modelo	Provider	Contexto
Claude Opus 4.8	Anthropic	1M tokens
Claude Sonnet 4.6	Anthropic	200K tokens
GPT-5.5	OpenAI	256K tokens
GPT-5.4-mini	OpenAI	128K tokens
Gemini 3.1 Pro	Google	2M tokens
Claude Fable 5	Anthropic	1M tokens

Modelos open source

Modelo	Provider	Licencia
GLM-5.2	Zhipu AI (Z.ai)	MIT
DeepSeek V4	DeepSeek	MIT
Llama 4 Maverick	Meta	Llama 4 Community
Qwen 3.6	Alibaba	Apache 2.0
Mistral Large 3	Mistral	Apache 2.0
Gemma 4	Google	Gemma
GPT-OSS 120B	OpenAI	Apache 2.0

Modelos gratis

OpenRouter tiene 20+ modelos gratis con $0 de coste por token. La lista incluye Llama 3.3 70B, Qwen3 Coder, GPT-OSS 120B, y NVIDIA Nemotron 3 Super. Los rate limits son:

• Sin créditos: 50 requests/día, 20 requests/minuto
• Con $10+ en créditos: 1,000 requests/día, 20 RPM (el depósito no expira)

También existe el Free Models Router (openrouter/free) que selecciona automáticamente un modelo gratis para cada request.

Auto Router: deja que OpenRouter elija el modelo

Si no sabes qué modelo usar para cada prompt, usa openrouter/auto:

completion = client.chat.completions.create(
    model="openrouter/auto",
    messages=[{"role": "user", "content": "Resume este documento"}],
)

El Auto Router, potenciado por NotDiamond, selecciona el modelo óptimo para cada prompt desde un pool curado. Útil cuando tienes cargas mixtas: algunas requests necesitan razonamiento fuerte, otras completión rápida. No hay recargo por usar Auto Router — pagas lo mismo que si llamaras al modelo directamente.

Routing avanzado con el objeto provider

Para control fino sobre qué proveedor sirve tu modelo, usa el objeto provider en la request:

Controlar el orden de proveedores

"provider": {
  "order": ["Anthropic", "Amazon Bedrock", "Google Vertex"],
  "allow_fallbacks": true
}

Excluir proveedores

"provider": {
  "ignore": ["Provider X", "Provider Y"]
}

Restringir a un allowlist

"provider": {
  "only": ["Anthropic"]
}

Techo de precio duro

"provider": {
  "max_price": {
    "prompt": 0.005,
    "completion": 0.025
  }
}

Si ningún proveedor cumple el techo, la request falla en lugar de gastar más de lo planeado.

Filtrar por quantización

"provider": {
  "quantizations": ["fp8", "bf16"]
}

Requerir data privacy

"provider": {
  "data_collection": "deny"
}

Solo enruta a proveedores que no loggean ni usan tus prompts para entrenamiento.

Model fallbacks: resiliencia cross-modelo

Si todos los proveedores de tu modelo primario fallan, el array models entra en acción:

completion = client.chat.completions.create(
    model="anthropic/claude-opus-4.8",
    extra_body={
        "models": ["openai/gpt-5.5", "google/gemini-3.1-pro"]
    },
    messages=[{"role": "user", "content": "Hola"}],
)

Los fallbacks se triggeran en: caída de todos los proveedores, rate limits, errores de context-length, y rechazos de moderación. No pagas por las requests que fallan — solo por el modelo que efectivamente corre.

Con la Anthropic Messages API, usa el parámetro fallbacks (máximo 3 entradas):

message = client.beta.messages.create(
    model="anthropic/claude-opus-4.8",
    fallbacks=[{"model": "anthropic/claude-sonnet-4.6"}],
    messages=[{"role": "user", "content": "Hola"}],
)

Precios y billing

Modelo de pricing

OpenRouter pasa los precios de los proveedores sin markup. Pagas lo mismo que irías directo al proveedor. El coste se deduce de tus créditos por cada request, basado en los tokens procesados.

Tarifa por compra de créditos

Método de pago	Fee	Mínimo
Stripe (tarjeta de crédito)	5.5%	$0.80
Criptomoneda (USDC)	5%	—

BYOK (Bring Your Own Key)

Si ya tienes API keys de Anthropic, OpenAI u otros proveedores, puedes usarlas a través de OpenRouter:

• Primeros 1M de requests BYOK por mes: Gratis
• Requests adicionales: 5% del coste normal del modelo en OpenRouter

Esto te permite gestionar tus propios rate limits y costes con el proveedor, mientras aprovechas la interfaz unificada de OpenRouter.

Descuento por opt-in de logging

Si optas a que OpenRouter loggee tus prompts y completions, recibes un 1% de descuento en el coste de uso. Por defecto, OpenRouter no loggea prompts ni completions — solo metadata (timestamps, modelo, token counts).

Gestión de créditos

• Moneda base: Dólares estadounidenses (USD)
• Auto top up: Recarga automática cuando el balance baja de un umbral
• Expiración: Créditos no usados pueden expirar después de 1 año
• Refunds: Dentro de 24 horas de la compra (las platform fees no son reembolsables; crypto no es reembolsable)
• Métodos de pago: Tarjetas de crédito, AliPay, USDC (PayPal en camino)

Ejemplo de costes reales

Modelo	Input/1M	Output/1M	Notas
Claude Opus 4.8	$5.00	$25.00	Mismo precio que Anthropic directo
GPT-5.5	$3.00	$15.00	Mismo precio que OpenAI directo
GLM-5.2	$1.40	$4.40	Mismo precio que Z.ai directo
Llama 3.3 70B	$0.23	$0.40	Open weight, barato
Modelos :free	$0	$0	Rate limits aplican

Dónde instalarlo y cómo empezar

Paso 1: Crear cuenta

Ve a openrouter.ai y crea una cuenta. Recibirás una pequeña allowance gratis para probar.

Paso 2: Comprar créditos

Ve a Settings → Credits y añade créditos. Con $10+ desbloqueas 1,000 requests/día en modelos gratis. Puedes pagar con tarjeta o crypto (USDC).

Paso 3: Crear API key

Ve a Settings → Keys y genera tu API key. Empieza con sk-or-....

Paso 4: Hacer tu primera request

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-tu-api-key",
)

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4.5",
    messages=[{"role": "user", "content": "¿Qué es OpenRouter?"}],
)

print(response.choices[0].message.content)

Paso 5: Configurar en Claude Code

Si ya usas Claude Code, puedes usar OpenRouter como backend para cualquier modelo:

# Añadir a ~/.zshrc o ~/.bashrc
export OPENROUTER_API_KEY="sk-or-tu-key"
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="$OPENROUTER_API_KEY"
export ANTHROPIC_API_KEY=""
export ANTHROPIC_DEFAULT_SONNET_MODEL="z-ai/glm-5.2"
export ANTHROPIC_DEFAULT_OPUS_MODEL="anthropic/claude-opus-4.8"

O en .claude/settings.local.json para configuración por proyecto:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-tu-key",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "z-ai/glm-5.2"
  }
}

Paso 6: Configurar en VS Code (Continue.dev, Cline, etc.)

Para herramientas que soportan custom OpenAI-compatible providers:

• API Provider: OpenAI Compatible
• Base URL: https://openrouter.ai/api/v1
• API Key: Tu OpenRouter key (sk-or-...)
• Model: Cualquier modelo de OpenRouter (ej: anthropic/claude-sonnet-4.5)

Paso 7: Configurar en LM Studio

Si usas LM Studio y quieres acceder a modelos frontier sin descargarlos localmente, puedes configurar OpenRouter como provider externo en LM Studio apuntando a su endpoint OpenAI-compatible.

SDKs y frameworks soportados

OpenRouter es un drop-in replacement para OpenAI. Cualquier SDK que soporte OpenAI soporta OpenRouter:

• Python: openai SDK, anthropic SDK, langchain, llamaindex
• JavaScript/TypeScript: openai npm, vercel/ai SDK
• Otros: Go, Rust, Java, C# — cualquier cliente HTTP que hable OpenAI

Frameworks e integraciones: LangChain, LlamaIndex, Vercel AI SDK, Continue.dev, Cursor, Cline, Open WebUI, Hermes Agent, OpenClaw, y 250k+ apps más.

Privacidad y datos

¿Qué se loggea?

• Por defecto: Solo metadata (timestamps, modelo usado, token counts). Prompts y completions NO se loggean
• Opt-in: Puedes permitir logging de prompts/completions a cambio de 1% de descuento
• Chatroom: Conversaciones se almacenan localmente en tu dispositivo, no se sincronizan

Políticas de proveedores

OpenRouter trabaja con todos los proveedores para, cuando sea posible, asegurar que prompts y completions no sean loggeados o usados para entrenamiento. Proveedores que sí loggean, o donde no se ha podido confirmar su política, no reciben tráfico a menos que actives el toggle de model training en privacy settings.

Data policies para empresas

Para organizaciones con requisitos de compliance, OpenRouter ofrece políticas de datos fine-grained: puedes especificar que tus prompts solo vayan a modelos y proveedores específicos de tu confianza.

Casos de uso

1. Desarrollo con Claude Code + GLM-5.2

Usa Claude Code con GLM-5.2 vía OpenRouter para programación agéntica a 1/5 del coste de Claude Opus, con 1M de contexto.

2. App con fallback automático

Configura Claude Opus como primario con GPT-5.5 y Gemini 3.1 Pro como fallbacks. Si Anthropic cae, tu app sigue funcionando sin que el usuario note nada.

3. Batch processing al mínimo coste

Usa :floor + max_price en modelos open weight como Llama 3.3 70B o DeepSeek V4 para procesamiento masivo al menor precio posible.

4. Chat user-facing de baja latencia

Usa :nitro para enrutar al proveedor más rápido. Ideal para chatbots donde el time-to-first-token importa.

5. Agentes con tool-calling confiable

Usa :exacto para ordenar proveedores por calidad en tool-calling. Combina con Hermes Agent o OpenClaw para agentes que necesitan function calling fiable.

6. Prototipo gratis

Usa modelos :free o el Free Models Router (openrouter/free) para prototipar sin gastar nada. 50 requests/día sin créditos, 1,000 con $10+.

OpenRouter MCP Server

OpenRouter ofrece un servidor MCP que conecta tu agente de programación al catálogo live de modelos, benchmarks, docs y test inference de OpenRouter — todo sin salir del editor. Disponible para Claude Code, Cline, y cualquier herramienta compatible con MCP.

Cuándo NO usar OpenRouter

• Cuando necesitas features específicas del provider: Si usas una feature que solo la API directa de Anthropic u OpenAI expone pero OpenRouter no surfacea
• Para self-hosting total: Si quieres 100% offline, usa LM Studio o Ollama con modelos locales
• Para inferencia a escala: Si necesitas alta concurrencia y paged attention en producción, considera vLLM
• Cuando el fee de compra molesta: El 5.5% al comprar créditos es el coste de la conveniencia. Si tu volumen es muy alto y no necesitas fallbacks, ir directo al proveedor ahorra ese fee

Conclusión

OpenRouter es la capa de abstracción más madura y completa para acceder a modelos de IA en 2026. Su propuesta de valor es simple: una API, 400+ modelos, 70+ proveedores, failover automático, sin markup en precios. El coste de esa conveniencia es un 5.5% al comprar créditos — menos de lo que cuesta gestionar múltiples cuentas, API keys y facturas separadas.

Para desarrolladores que usan Claude Code, OpenRouter es especialmente valioso: te permite usar GLM-5.2 para tareas rutinarias (ahorrando 5×), Claude Opus para las difíciles, y fallbacks automáticos cuando un proveedor cae. Todo desde el mismo Claude Code, cambiando una variable de entorno.

Y cuando combines OpenRouter con un stack completo — LM Studio para modelos locales, Ollama para servirlos, Hermes Agent para orquestación, OpenClaw para tu asistente, y Supabase self-hosted para el backend — tienes un ecosistema de IA completo, flexible y a tu control.