API Compatible con OpenAI: Qué es, Quién lo Soporta y Cómo Cambiar de Forma Segura
Tabla de contenidos:
Respuesta rápida: Una API compatible con OpenAI acepta las mismas solicitudes y devuelve las mismas respuestas que la API de OpenAI.
Por lo tanto, el SDK oficial de OpenAI y las herramientas construidas sobre él pueden llamar a otros modelos cambiando tres valores: la URL base, la clave API y el nombre del modelo. Anthropic, Google Gemini, Mistral, Groq, DeepSeek, OpenRouter, Ollama, vLLM y muchos otros ofrecen uno.
-
Lo que se mantiene igual: la forma de la solicitud, el SDK, la mayoría de tu código.
-
Lo que puede romperse: esquemas JSON estrictos, llamadas de herramientas, detalles de streaming, parámetros ignorados, mensajes de error y encabezados de límite de velocidad.
-
¿SDK nativo o API compatible? Usa la API compatible para cambiar y comparar rápidamente. Usa el SDK nativo cuando necesites características exclusivas del proveedor.
-
Antes de cambiar: ejecuta una prueba de humo breve y mantén un rollback de una línea.
La mayoría de las aplicaciones de IA comienzan con la API de OpenAI, por lo que la mayoría del código está escrito para el SDK de OpenAI.
Una API compatible con OpenAI te permite mantener ese código y enviar las mismas solicitudes a Claude, Gemini, modelos de código abierto o tu propio servidor.
Es la razón por la que cambiar de modelo puede tomar minutos en lugar de una reescritura.
"Compatible" no significa "idéntico", sin embargo, y las diferencias aparecen en producción.
Esta guía explica cómo funcionan las APIs compatibles con OpenAI, qué proveedores ofrecen una, qué se rompe cuando cambias y cómo probar un proveedor antes de confiar en él.
Si prefieres llegar a varios proveedores a través de una sola clave y una sola factura, la API compatible con OpenAI de ScriptRun funciona con el SDK de OpenAI que ya usas.
Qué es una API compatible con OpenAI
Una API compatible con OpenAI es cualquier API que copia la interfaz de la API de OpenAI: los mismos puntos finales, el mismo formato de solicitud y respuesta JSON y la misma autenticación de token Bearer.
Debido a que la forma coincide, cualquier cliente construido para OpenAI puede comunicarse con ella.
De todos los puntos finales de API compatibles con OpenAI, el que casi todos los proveedores copian es Chat Completions, /v1/chat/completions, porque es lo que la mayoría de los SDKs y marcos llaman.
Muchos también copian /v1/models y /v1/embeddings. La compatibilidad con puntos finales más nuevos, como Responses, archivos, lotes o audio, varía mucho más.
El formato de OpenAI se convirtió en el estándar común porque llegó primero y casi todos los marcos lo adoptaron: LangChain, LlamaIndex, el Vercel AI SDK, n8n y muchos otros.
Los proveedores de modelos lo copiaron para que los desarrolladores pudieran probar sus modelos sin aprender un nuevo SDK.
Los servidores autohospedados como vLLM, Hugging Face Text Generation Inference (TGI), Ollama y LM Studio lo copiaron para que los modelos locales pudieran conectarse a las mismas herramientas.
Cómo funciona una API compatible con OpenAI
Apuntas el SDK de OpenAI a un servidor diferente cambiando tres valores:
-
URL base: el punto final del proveedor, como https://generativelanguage.googleapis.com/v1beta/openai/ para Gemini.
-
Clave API: la clave del proveedor, no tu clave de OpenAI.
-
Nombre del modelo: un ID de modelo de ese proveedor, como gemini-3.8-flash.
Todo lo demás, incluidos tus mensajes, parámetros y manejo de respuestas, se mantiene igual. Aquí está la misma solicitud en tres idiomas, utilizando el punto final de Gemini documentado por Google.
Python
from openai import OpenAI
client = OpenAI(
api_key="GEMINI_API_KEY",
base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
)
response = client.chat.completions.create(
model="gemini-3.8-flash",
messages=[
{
"role": "user",
"content": "Explain an OpenAI compatible API in one sentence."
}
],
)
print(response.choices[0].message.content)
Node.js
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.GEMINI_API_KEY,
baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
});
const response = await client.chat.completions.create({
model: "gemini-3.8-flash",
messages: [
{
role: "user",
content: "Explain an OpenAI compatible API in one sentence."
}
],
});
console.log(response.choices[0].message.content);
curl
curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEMINI_API_KEY" \
-d '{
"model": "gemini-3.8-flash",
"messages": [
{
"role": "user",
"content": "Hello"
}
]
}'
📌 CONSEJO: copia cada URL base exactamente como la documenta el proveedor.
El SDK de OpenAI agrega rutas como /chat/completions a lo que le des, por lo que un /v1 faltante o extra es el error de configuración más común.
Qué proveedores ofrecen una API compatible con OpenAI
Casi todos los principales proveedores de modelos, plataformas en la nube, puertas de enlace y servidores de inferencia autohospedados ahora ofrecen uno.
La API compatible con OpenAI de Groq, la API compatible con OpenAI de DeepSeek y el punto final compatible con OpenAI de Together AI aceptan todas las mismas solicitudes; solo cambian la URL base, la clave y el modelo.
Estas son las URLs base documentadas.
| Proveedor | Tipo | URL base compatible con OpenAI |
|---|---|---|
| OpenAI | API de referencia | https://api.openai.com/v1 |
| Anthropic (Claude) | Proveedor de modelo | https://api.anthropic.com/v1/ |
| API de Google Gemini | Proveedor de modelo | https://generativelanguage.googleapis.com/v1beta/openai/ |
| Mistral AI | Proveedor de modelo | https://api.mistral.ai/v1 |
| DeepSeek | Proveedor de modelo | https://api.deepseek.com |
| xAI (Grok) | Proveedor de modelo | https://api.x.ai/v1 |
| Groq | Proveedor de inferencia | https://api.groq.com/openai/v1 |
| Together AI | Proveedor de inferencia | https://api.together.ai/v1 |
| Fireworks AI | Proveedor de inferencia | https://api.fireworks.ai/inference/v1 |
| Azure OpenAI / Microsoft Foundry | Plataforma en la nube | https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/ |
| Amazon Bedrock | Plataforma en la nube | https://bedrock-runtime.{region}.amazonaws.com/openai/v1 |
| OpenRouter | Puerta de enlace | https://openrouter.ai/api/v1 |
| Ollama | Servidor local | http://localhost:11434/v1/ |
| LM Studio | Servidor local | http://localhost:1234/v1 |
| vLLM | Servidor autohospedado | http://localhost:8000/v1 |
Las URLs base de Anthropic y Gemini se verificaron contra su propia documentación el 13 de noviembre de 2026.
Los otros provienen de la referencia de compatibilidad de DevelopersDigest, que fue verificada contra la documentación de cada proveedor el 18 de octubre de 2026.
Los proveedores cambian estos, así que revisa la documentación antes de desplegar.
Compatible no es idéntico: qué se rompe cuando cambias
La compatibilidad de API de OpenAI significa que un proveedor acepta el formato de OpenAI. No promete el comportamiento de OpenAI.
Las llamadas simples funcionan casi en todas partes; los problemas aparecen en las características en las que confían las aplicaciones en producción.
| Área | Lo que generalmente funciona | Lo que frecuentemente difiere |
|---|---|---|
| Chat básico | Mensajes adentro, opciones afuera | Cómo se manejan los mensajes del sistema |
| Parámetros | temperature, max_tokens, stop | Los campos no compatibles (seed, logprobs, penalties) a menudo se ignoran silenciosamente, no se rechazan |
| Salida estructurada | Salida JSON básica en muchos modelos | Qué tipos de response_format se aceptan y si los esquemas "strict" se aplican |
| Llamadas de herramientas | Definir herramientas y obtener una llamada | Esquemas de argumentos estrictos, llamadas paralelas, opciones de tool_choice |
| Streaming | Fragmentos token a token | Límites de fragmentos, opciones vacías, si el uso llega al final |
| Entradas | Texto, frecuentemente imágenes | Audio, archivos y PDFs |
| Errores y límites | Códigos de estado HTTP | Mensajes de error y encabezados de límite de velocidad (consulta nuestra guía de límites de velocidad de API de OpenAI) |
| Otros puntos finales | Lista de modelos, frecuentemente embeddings | API de Responses, lotes, archivos, audio |
API compatible con OpenAI de Anthropic: qué es diferente
Anthropic es inusualmente clara sobre su capa. Su documentación dice que la capa está "destinada principalmente a probar y comparar capacidades de modelos, y no se considera una solución lista para producción a largo plazo para la mayoría de los casos de uso".
También enumeran diferencias específicas:
-
El parámetro strict para llamadas de funciones se ignora, por lo que no se garantiza que los argumentos de las herramientas coincidan con tu esquema.
-
response_format acepta solo json_schema con strict: true; json_object o text devuelve un error 400.
-
Las entradas de audio y archivo devuelven un error 400, y el almacenamiento en caché de solicitudes no es compatible con esta capa.
-
Los campos como logprobs, seed, presence_penalty y frequency_penalty se ignoran silenciosamente.
-
Los formatos de error coinciden con los de OpenAI, pero los mensajes de error detallados no, y algunos encabezados de límite de velocidad tienen nombres diferentes.
Fuente: Anthropic, compatibilidad del SDK de OpenAI.
API compatible con OpenAI de Gemini: qué es diferente
La capa de Google cubre más terreno: chat, streaming, llamadas de funciones, comprensión de imágenes y audio, salida estructurada, embeddings y partes de la API por lotes.
Las opciones exclusivas de Gemini como configuraciones de pensamiento y contenido en caché van en extra_body. Google aún etiqueta el soporte de bibliotecas de OpenAI como beta y dice: "Si aún no estás usando las bibliotecas de OpenAI, te recomendamos que llames a la API de Gemini directamente".
Fuente: Google, compatibilidad de API de Gemini con OpenAI.
API compatible con OpenAI o SDK nativo del proveedor
Ninguno es siempre correcto. Elige según lo que necesites.
| Elige una API compatible con OpenAI cuando… | Elige el SDK nativo cuando… |
|---|---|
| Tu aplicación ya usa el SDK de OpenAI o un marco construido sobre él | Estás comenzando de nuevo con un proveedor |
| Deseas comparar modelos o cambiar de proveedor rápidamente | Necesitas características exclusivas del proveedor, como almacenamiento en caché de solicitudes de Anthropic y soporte de PDF, u opciones de grounding y almacenamiento en caché de Gemini |
| Usas varios proveedores y deseas una ruta de código | Necesitas un comportamiento garantizado que la capa compatible no promete |
| Deseas conmutación por error entre proveedores sin código de integración nuevo | El proveedor te dice que su capa no está destinada a producción, como lo hace Anthropic |
Muchos equipos hacen ambas cosas.
Usan una API compatible con OpenAI para la mayoría del tráfico y un SDK nativo para una o dos características que lo necesitan.
Directamente a cada proveedor o a través de una puerta de enlace
Puedes apuntar tu aplicación directamente al punto final compatible de cada proveedor o a una puerta de enlace que ofrezca un punto final compatible con OpenAI para muchos proveedores.
| Directamente a cada proveedor | Una puerta de enlace compatible con OpenAI | |
|---|---|---|
| Configuración | Una cuenta, clave y facturación por proveedor | Una cuenta, una clave, una factura |
| Cambio de modelos | Cambiar URL base, clave y modelo | Cambiar el nombre del modelo |
| Interrupciones y límites de velocidad | Construyes reintentos y conmutación por error | Frecuentemente incorporado (verifica cómo) |
| Latencia | Sin saltos adicionales | Un salto de red adicional |
| Dependencia | Cada proveedor | Cada proveedor más la puerta de enlace |
| Ruta de datos | Tu aplicación al proveedor | Tu aplicación a la puerta de enlace al proveedor |
Una puerta de enlace se amortiza una vez que usas más de un proveedor, necesitas conmutación por error o deseas gastos y límites en un lugar.
Pregunta a cualquier puerta de enlace, incluida ScriptRun, cuánta latencia agrega, cuál es su registro de tiempo de actividad y cómo maneja tus datos.
Para saber cómo se enrutan las solicitudes entre modelos, consulta nuestra guía de enrutadores de LLM.
Prueba cualquier API compatible con OpenAI en cinco minutos
No confíes en una etiqueta "compatible" hasta que hayas probado las características que usa tu aplicación.
Este script verifica cinco cosas contra cualquier proveedor: chat básico con datos de uso, streaming, llamadas de herramientas, esquema JSON estricto y manejo de errores.
Establece tres variables de entorno - LLM_BASE_URL, LLM_API_KEY y LLM_MODEL; ejecuta el script y lee las líneas PASS y FAIL.
Python
import json
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ["LLM_BASE_URL"],
api_key=os.environ["LLM_API_KEY"]
)
MODEL = os.environ["LLM_MODEL"]
def basic_chat():
r = client.chat.completions.create(
model=MODEL,
messages=[{"role": "user", "content": "Reply with the word OK."}],
max_tokens=10
)
assert r.choices[0].message.content, "empty reply"
assert r.usage and r.usage.total_tokens > 0, "no usage data"
def streaming():
stream = client.chat.completions.create(
model=MODEL,
messages=[{"role": "user", "content": "Count to 3."}],
stream=True
)
text = "".join(
c.choices[0].delta.content or ""
for c in stream if c.choices
)
assert text, "empty stream"
def tool_calling():
tool = {
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the weather for a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"}
},
"required": ["city"]
}
}
}
r = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "user", "content": "What's the weather in Paris?"}
],
tools=[tool]
)
call = r.choices[0].message.tool_calls[0]
assert json.loads(call.function.arguments)["city"], "no city argument"
def json_schema():
schema = {
"type": "object",
"properties": {
"answer": {"type": "string"}
},
"required": ["answer"],
"additionalProperties": False
}
r = client.chat.completions.create(
model=MODEL,
messages=[{"role": "user", "content": "Say hello."}],
response_format={
"type": "json_schema",
"json_schema": {
"name": "reply",
"schema": schema,
"strict": True
}
}
)
assert "answer" in json.loads(r.choices[0].message.content)
def error_handling():
try:
client.chat.completions.create(
model="model-that-does-not-exist",
messages=[{"role": "user", "content": "hi"}]
)
except Exception as err:
status = getattr(err, "status_code", None)
assert status and 400 <= status < 500, f"unexpected error: {err!r}"
return
raise AssertionError("no error for an unknown model")
for name, test in [
("basic chat + usage", basic_chat),
("streaming", streaming),
("tool calling", tool_calling),
("strict JSON schema", json_schema),
("error handling", error_handling)
]:
try:
test()
print(f"PASS {name}")
except Exception as err:
print(f"FAIL {name}: {err}")
Un FAIL no siempre descarta a un proveedor. Te dice qué parte de tu código necesita una solución alternativa o qué solicitudes deben permanecer en otro modelo.
Lista de verificación de migración: cambio sin romper la producción
-
Lista lo que usas. Puntos finales, parámetros, herramientas, esquemas JSON, streaming, imágenes y archivos.
-
Verifica la página de compatibilidad del proveedor para cada elemento, especialmente los campos que se ignoran silenciosamente.
-
Ejecuta la prueba de humo con tus solicitudes y modelos reales.
-
Mueve la configuración a variables de entorno: URL base, clave y modelo. El cambio es entonces un cambio de configuración, no una implementación.
-
Compara salidas en una muestra de solicitudes reales: calidad, latencia y costo por 1.000 solicitudes.
-
Despliegue gradualmente. Comienza con una pequeña porción de tráfico o una característica interna.
-
Vigila errores y límites de velocidad y mantén el proveedor antiguo listo como respaldo para las primeras semanas.
Usar la API compatible con OpenAI de ScriptRun
Open API de ScriptRun te da un punto final compatible con OpenAI y una clave API para modelos de OpenAI, Anthropic (Claude) y Google (Gemini).
Mantienes el SDK de OpenAI y cambias dos líneas:
from openai import OpenAI
client = OpenAI(
base_url="SCRIPTRUN_BASE_URL", # from your ScriptRun dashboard
api_key="YOUR_SCRIPTRUN_KEY",
)
response = client.chat.completions.create(
model="MODEL_ID", # any model available in ScriptRun
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)
Lo que obtienes además del formato compatible:
-
Una cuenta en lugar de muchas: sin registros separados o verificaciones KYC con cada proveedor, y una sola factura.
-
Enrutamiento inteligente y conmutación por error: elige modelos por calidad, costo y tamaño de contexto, con cambio automático entre proveedores durante interrupciones.
-
Confiabilidad incorporada: reintentos con retroceso e idempotencia a nivel de solicitud, por lo que una llamada reintentada no se procesa dos veces.
-
Control: claves por proyecto, límites y cuotas.
-
Acceso y facturación para equipos globales: acceso sin VPN, tarjetas, criptomonedas y SWIFT, más contratos e facturas para empresas.
-
Flujos de trabajo cuando los necesites: la API de flujo de trabajo agrega ramificación, webhooks, tiempos de espera y reintentos para tareas de IA de múltiples pasos.
La misma precaución se aplica que con cualquier puerta de enlace: ejecuta la prueba de humo anterior contra ScriptRun con tus propios solicitudes antes de mover el tráfico de producción.
Obtén una clave de API de ScriptRun e intenta con el código que ya tienes.
Preguntas frecuentes sobre la API compatible con OpenAI
¿Es la API de Claude compatible con OpenAI?
Sí. Anthropic ofrece una capa de compatibilidad con el SDK de OpenAI en https://api.anthropic.com/v1/. Anthropic dice que es principalmente para probar y comparar modelos, no para uso en producción a largo plazo, y algunas características se comportan de manera diferente. Para las características completas de Claude, utiliza la API nativa o una puerta de enlace que sea compatible con Claude.
¿Es la API de Gemini compatible con OpenAI?
Sí. Establezca la URL base en https://generativelanguage.googleapis.com/v1beta/openai/, use una clave API de Gemini y un nombre de modelo de Gemini. Google etiqueta este soporte como beta.
¿Es la API de Ollama compatible con OpenAI?
Sí. La API compatible con OpenAI de Ollama se ejecuta en su servidor local en http://localhost:11434/v1/. El SDK de OpenAI necesita un valor de clave API, pero Ollama local lo ignora.
¿Es OpenRouter compatible con OpenAI?
Sí. La URL base compatible con OpenAI de OpenRouter es https://openrouter.ai/api/v1.
¿Hay una API compatible con OpenAI gratuita?
Los servidores locales como Ollama, LM Studio y vLLM son gratuitos para ejecutar en tu propio hardware. Varios proveedores alojados también tienen niveles gratuitos con límites.
¿Es la API de Groq compatible con OpenAI?
Sí. La URL base compatible con OpenAI de Groq es https://api.groq.com/openai/v1. Tenga en cuenta la /openai adicional en la ruta: usar una URL /v1 simple es un error común de configuración. Cambias la URL base, la clave API y el nombre del modelo, y tu código permanece igual a menos que dependas de funciones que Groq maneja de manera diferente.
Publicaciones relacionadas
API de LLM más barata en 2026: precios verificados por cada 1 millón de tokens
¿Cuál es la API de LLM más barata? Precios verificados de OpenAI, Claude, Gemini, DeepSeek, Qwen, Mistral y Groq, además de costos reales de carga de trabajo y tarifas ocultas.
Mercado de agentes de IA: los 10 mejores lugares para encontrar, ejecutar y vender agentes de IA en 2026
Qué es un marketplace de agentes de IA, una comparativa de 10 plataformas destacadas según el costo de prueba y quién puede vender, una lista de verificación de seguridad y cómo publicar tu propio agente en 2026.
API de LLM Gratuita: Qué Proveedores Siguen Siendo Gratuitos en 2026 (Límites, Claves y Trampas)
Cada API de LLM gratuita que vale la pena usar en 2026, verificada contra documentación oficial: niveles gratuitos vs créditos, límites, términos de datos, cómo obtener una clave y código de respaldo.
Alternativas a OpenRouter: 7 puertas de enlace de LLM comparadas en enrutamiento, precios y dependencia
Alternativas de OpenRouter comparadas: tarifas, enrutamiento, BYOK y auto-hospedaje en 7 puertas de enlace de LLM, con lista de verificación de migración y precios verificados de 2026.








