scriptRun Beta

API Compatible con OpenAI: Qué es, Quién lo Soporta y Cómo Cambiar de Forma Segura

AnnaAnna
17 noviembre 2026
Negocio
Flujos de trabajo con IAAutomatización
API Compatible con OpenAI: Cómo funciona y qué se rompe

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:

  1. URL base: el punto final del proveedor, como https://generativelanguage.googleapis.com/v1beta/openai/ para Gemini.

  2. Clave API: la clave del proveedor, no tu clave de OpenAI.

  3. 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.

ProveedorTipoURL base compatible con OpenAI
OpenAIAPI de referenciahttps://api.openai.com/v1
Anthropic (Claude)Proveedor de modelohttps://api.anthropic.com/v1/
API de Google GeminiProveedor de modelohttps://generativelanguage.googleapis.com/v1beta/openai/
Mistral AIProveedor de modelohttps://api.mistral.ai/v1
DeepSeekProveedor de modelohttps://api.deepseek.com
xAI (Grok)Proveedor de modelohttps://api.x.ai/v1
GroqProveedor de inferenciahttps://api.groq.com/openai/v1
Together AIProveedor de inferenciahttps://api.together.ai/v1
Fireworks AIProveedor de inferenciahttps://api.fireworks.ai/inference/v1
Azure OpenAI / Microsoft FoundryPlataforma en la nubehttps://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/
Amazon BedrockPlataforma en la nubehttps://bedrock-runtime.{region}.amazonaws.com/openai/v1
OpenRouterPuerta de enlacehttps://openrouter.ai/api/v1
OllamaServidor localhttp://localhost:11434/v1/
LM StudioServidor localhttp://localhost:1234/v1
vLLMServidor autohospedadohttp://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.

ÁreaLo que generalmente funcionaLo que frecuentemente difiere
Chat básicoMensajes adentro, opciones afueraCómo se manejan los mensajes del sistema
Parámetrostemperature, max_tokens, stopLos campos no compatibles (seed, logprobs, penalties) a menudo se ignoran silenciosamente, no se rechazan
Salida estructuradaSalida JSON básica en muchos modelosQué tipos de response_format se aceptan y si los esquemas "strict" se aplican
Llamadas de herramientasDefinir herramientas y obtener una llamadaEsquemas de argumentos estrictos, llamadas paralelas, opciones de tool_choice
StreamingFragmentos token a tokenLímites de fragmentos, opciones vacías, si el uso llega al final
EntradasTexto, frecuentemente imágenesAudio, archivos y PDFs
Errores y límitesCódigos de estado HTTPMensajes de error y encabezados de límite de velocidad (consulta nuestra guía de límites de velocidad de API de OpenAI)
Otros puntos finalesLista de modelos, frecuentemente embeddingsAPI 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 élEstás comenzando de nuevo con un proveedor
Deseas comparar modelos o cambiar de proveedor rápidamenteNecesitas 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ódigoNecesitas un comportamiento garantizado que la capa compatible no promete
Deseas conmutación por error entre proveedores sin código de integración nuevoEl 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 proveedorUna puerta de enlace compatible con OpenAI
ConfiguraciónUna cuenta, clave y facturación por proveedorUna cuenta, una clave, una factura
Cambio de modelosCambiar URL base, clave y modeloCambiar el nombre del modelo
Interrupciones y límites de velocidadConstruyes reintentos y conmutación por errorFrecuentemente incorporado (verifica cómo)
LatenciaSin saltos adicionalesUn salto de red adicional
DependenciaCada proveedorCada proveedor más la puerta de enlace
Ruta de datosTu aplicación al proveedorTu 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

  1. Lista lo que usas. Puntos finales, parámetros, herramientas, esquemas JSON, streaming, imágenes y archivos.

  2. Verifica la página de compatibilidad del proveedor para cada elemento, especialmente los campos que se ignoran silenciosamente.

  3. Ejecuta la prueba de humo con tus solicitudes y modelos reales.

  4. 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.

  5. Compara salidas en una muestra de solicitudes reales: calidad, latencia y costo por 1.000 solicitudes.

  6. Despliegue gradualmente. Comienza con una pequeña porción de tráfico o una característica interna.

  7. 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.


¿Útil?
¡Comparte este artículo!

Crea workflows de IA en minutos

Crea automatizaciones, conecta APIs y accede a más de 50 modelos de IA desde una sola plataforma.

Constructor visual de workflows
API compatible con OpenAI
Mercado de workflows y plantillas
Empieza gratis, planes desde $5

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.

Más contenido de nuestro blog

Publicaciones relacionadas

Flujos de trabajo con IAAutomatización
API de LLM más barata en 2026: precios verificados por cada 1 millón de tokens
Negocio 20 noviembre 2026

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.

1734
AnnaAnna
Mercado de IAFlujos de trabajo con IAAutomatización
Mercado de agentes de IA: comparación de las 10 mejores plataformas (2026)
Negocio 19 noviembre 2026

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.

1886
AnnaAnna
Flujos de trabajo con IAAutomatización
API LLM Gratuita: Proveedores 2026, Límites y Trampas Reales
Negocio 18 noviembre 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.

1905
AnnaAnna
Flujos de trabajo con IAAutomatización
Alternativas a OpenRouter: 7 Puertas de Enlace para Enrutamiento de LLM
Negocio 16 noviembre 2026

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.

1560
AnnaAnna
© 2024-2026 PIXEL LORIS IT SERVICES L.L.C. All rights reserved.