---
title: "Migrar desde la API de OpenAI: cambios de código y pruebas"
description: "Los cambios de código para pasar de OpenAI a una API compatible: cliente, de Responses a Chat Completions, herramientas, streaming, embeddings y una prueba rápida."
url: https://broadrouter.com/es/blog/migrate-from-openai-api-code-walkthrough/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/migrate-from-openai-api-code-walkthrough/) (actualizado el 2026-11-15).

# Migrar desde la API de OpenAI: el código en Python, Node y cURL

Por el equipo de BroadNet Inference · 6 min de lectura · Publicado 2026-11-15

Cambie la URL base del cliente, la clave de API y el ID del modelo. Eso basta para las llamadas a Chat Completions. El código sobre la Responses API debe reescribirse a Chat Completions: input pasa a messages, output\_text a choices\[0\].message.content y las herramientas pierden un nivel de anidación. Deje los embeddings en otro cliente si el nuevo proveedor no los ofrece y haga una prueba rápida antes de mover el tráfico.

## Puntos clave

-   En el código de Chat Completions, el cambio son tres valores: base\_url, api\_key y model. Los dos SDK oficiales también leen OPENAI\_BASE\_URL y OPENAI\_API\_KEY del entorno.
-   Configurar OPENAI\_BASE\_URL mueve todas las llamadas, embeddings incluidos. Si el nuevo proveedor no tiene endpoint de embeddings, dé a los embeddings su propio cliente.
-   El código de la Responses API requiere reescritura: input a messages, instructions a un mensaje de sistema, text.format a response\_format y definiciones de herramientas planas a anidadas.
-   BroadNet Inference documenta /v1/chat/completions, /v1/audio/transcriptions y GET /v1/models, y ningún endpoint de embeddings, archivos ni lotes. Su documentación lista herramientas y salida estructurada para GLM 5.3 y Qwen3.8 27B.
-   Pruebe antes de cambiar: chat simple, uso en streaming, un presupuesto de razonamiento y una clave incorrecta, además de una llamada a herramienta si usa herramientas.

**En esta página**

1.  ¿Qué cambia en la configuración del cliente?
2.  ¿Y si mi código usa la Responses API?
3.  ¿Cómo cambian las llamadas a herramientas?
4.  ¿Y la salida estructurada?
5.  ¿Qué pasa con los embeddings?
6.  ¿Cómo cambia el código de streaming?
7.  ¿Cambian el manejo de errores y los reintentos?
8.  ¿Qué parámetros se comportan de forma distinta?
9.  ¿Cómo se prueba el cambio?
10.  ¿Qué falla con más frecuencia?
11.  Dónde encaja BroadNet Inference

Pasar una aplicación de OpenAI a un proveedor compatible con OpenAI es un cambio pequeño de código si usa Chat Completions, y una reescritura si usa la Responses API. Este artículo muestra los cambios exactos en Python, Node y cURL, qué hacer con Responses, las herramientas, la salida estructurada y los embeddings, y una prueba rápida que conviene ejecutar antes de mover cualquier tráfico. Los ejemplos usan BroadNet Inference en `https://inference.broadnet.ai/v1`; los mismos pasos sirven para cualquier proveedor.

Este es el complemento de código de la [lista de verificación para migrar](https://broadrouter.com/es/blog/openai-compatible-api-migration-checklist/), que cubre límites de frecuencia, errores y la planificación del cambio. Para las URL base de otros proveedores, consulte [URL base compatibles con OpenAI, verificadas](https://broadrouter.com/es/blog/openai-compatible-api-base-urls/).

## ¿Qué cambia en la configuración del cliente?

Tres valores: la URL base, la clave de API y el ID del modelo.

**Python**

```python
import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)
```

**Node**

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);
```

**cURL**

```bash
curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'
```

Fíjese en la ruta: la URL base ya termina en `/v1`, y el SDK añade `/chat/completions`. Duplicar `/v1` es el primer error más habitual.

### ¿Puedo cambiar sin tocar el código?

Sí, en el código de Chat Completions. El SDK de Python lee `OPENAI_BASE_URL` cuando no se pasa `base_url`, y el cliente de Node toma por defecto `baseURL` de `process.env['OPENAI_BASE_URL']`. Ambos leen `OPENAI_API_KEY`. Configurar dos variables de entorno mueve todas las llamadas.

Ese es también el riesgo. Se mueven **todas las llamadas**, incluidos los embeddings, la moderación, la subida de archivos y cualquier otra cosa que el nuevo proveedor quizá no tenga. Use el cambio por entorno solo cuando su aplicación haga llamadas de chat y nada más.

## ¿Y si mi código usa la Responses API?

Los README de los SDK de OpenAI llaman ahora a la Responses API la API principal; el README de Python llama a Chat Completions “the previous standard (supported indefinitely)” (Traducción: «el estándar anterior (con soporte indefinido)»). Muchos proveedores compatibles solo implementan Chat Completions. BroadNet documenta `POST /v1/chat/completions` y `POST /v1/audio/transcriptions`, así que las llamadas a Responses deben reescribirse. La correspondencia:

| Responses API | Chat Completions |
| --- | --- |
| `client.responses.create(...)` | `client.chat.completions.create(...)` |
| `instructions="..."` | Primer mensaje `{"role": "system", "content": "..."}` |
| `input="..."` o una lista de elementos | `messages=[...]` |
| `response.output_text` | `response.choices[0].message.content` |
| `max_output_tokens` | `max_tokens` (documentación de BroadNet) o `max_completion_tokens` |
| `text={"format": {...}}` | `response_format={...}` |
| `previous_response_id`, conversaciones | Reenvíe usted mismo el historial completo de mensajes |
| Herramienta `{"type": "function", "name": ...}` | Herramienta `{"type": "function", "function": {"name": ...}}` |
| Elemento de salida `function_call`, respuesta con `function_call_output` y `call_id` | `message.tool_calls`, respuesta con rol `tool` y `tool_call_id` |
| Herramientas integradas (búsqueda web, búsqueda en archivos) | No disponibles; ejecute su propia herramienta |

El antes y el después de una llamada sencilla:

```python
# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content
```

El mayor cambio estructural es el estado. Responses puede guardar el estado de la conversación del lado de OpenAI con `previous_response_id`. Chat Completions no tiene estado en el servidor, así que su código guarda la lista de mensajes y la envía completa en cada turno. Téngalo en cuenta en el presupuesto: todo el historial son tokens de entrada en cada llamada.

## ¿Cómo cambian las llamadas a herramientas?

En Chat Completions, la definición de una herramienta anida la función bajo una clave `function`, y la respuesta vuelve como un mensaje `tool`:

```python
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
```

El modelo importa más que la forma. La documentación de BroadNet lista herramientas solo para [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) y [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/). No conecte un bucle de herramientas a un modelo cuya documentación no las liste, y valide los argumentos antes de ejecutar nada. [Llamadas a herramientas con modelos abiertos](https://broadrouter.com/es/blog/tool-calling-open-models/) incluye un bucle completo con validación.

## ¿Y la salida estructurada?

`client.chat.completions.parse(..., response_format=MyPydanticModel)` y `zodResponseFormat` en Node envían `response_format` con un JSON Schema. Solo funcionan si el proveedor acepta esa forma en ese modelo. BroadNet lista salida estructurada para GLM 5.3 y Qwen3.8 27B, pero no nombra el parámetro de la solicitud. Ejecute una vez por modelo la prueba de cuatro pasos de [modo JSON o json\_schema](https://broadrouter.com/es/blog/structured-output-json-schema/) y siga validando el resultado analizado, prometa lo que prometa el proveedor.

## ¿Qué pasa con los embeddings?

Si cambia la URL base en un cliente compartido y el proveedor no tiene endpoint de embeddings, todas las llamadas a `client.embeddings.create` fallan. BroadNet no vende [embeddings](https://broadrouter.com/es/glossary/embeddings/). Mantenga dos clientes:

```python
chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))
```

Nunca mezcle vectores de dos modelos de embeddings en un mismo índice. Si también cambia de proveedor de embeddings, vuelva a generar los embeddings de todo el corpus. La [calculadora de costos de embeddings](https://broadrouter.com/tools/embedding-cost-calculator/) calcula cuánto cuesta.

Lo mismo se aplica a todo lo que no es chat: generación de imágenes, texto a voz, moderación, la Batch API y el almacenamiento de archivos. BroadNet no ofrece ninguno. La voz a texto sí se mueve: `client.audio.transcriptions.create` funciona contra `/v1/audio/transcriptions` con WAV o MP3 y un campo `language` ([guía de voz a texto en árabe](https://broadrouter.com/es/guides/arabic-speech-to-text-api/)).

## ¿Cómo cambia el código de streaming?

La Responses API transmite eventos tipados, como `response.output_text.delta` y `response.completed`. Chat Completions transmite fragmentos, y el texto está en `choices[0].delta.content`. El uso no se envía salvo que lo pida, y entonces llega en un fragmento final con una lista `choices` vacía.

```javascript
// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}
```

Dos hábitos mantienen seguro el código de streaming tras el cambio. Proteja el acceso a `choices[0]`, porque el fragmento de uso no tiene choices. Y trate como incompleto un stream que termina antes de la línea final `data: [DONE]`; la documentación de BroadNet indica registrar el `X-Request-ID` y decidir si es seguro enviar una solicitud nueva. [Streaming de chat completions](https://broadrouter.com/es/guides/streaming-chat-completions/) muestra el patrón completo en Python.

## ¿Cambian el manejo de errores y los reintentos?

Las clases de error del SDK siguen siendo las mismas: `AuthenticationError` para 401, `RateLimitError` para 429 y `APIStatusError` para el resto. Lo que cambia es el significado de cada estado en el nuevo proveedor. En BroadNet, un 401 puede significar una asignación de pago por uso agotada, no solo una clave incorrecta, y un 402 significa saldo insuficiente para una compra. Ninguno se resuelve con un reintento. Un 429 puede venir del límite de frecuencia, de concurrencia, de tasa de tokens o de gasto. Reintente los 429 y 5xx con backoff, y corrija todo lo demás. La [guía de errores y reintentos](https://broadrouter.com/es/guides/errors-and-retries/) tiene la tabla completa.

El SDK reintenta por defecto dos veces los errores de conexión, 408, 409, 429 y 5xx. Si añade su propio bucle de reintentos, configure `max_retries=0` en el cliente para que no se sumen.

## ¿Qué parámetros se comportan de forma distinta?

| Parámetro | Qué comprobar |
| --- | --- |
| `max_tokens` / `max_completion_tokens` | OpenAI marca `max_tokens` como obsoleto; la documentación de BroadNet lo usa. En los modelos de razonamiento incluye el razonamiento, así que valores pequeños devuelven respuestas vacías ([por qué](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)) |
| `reasoning_effort` | BroadNet documenta `low`; pruebe otros valores antes de depender de ellos |
| `stream_options: {"include_usage": true}` | Documentado por BroadNet; el uso llega en el último fragmento |
| `n`, `logprobs`, `seed`, `logit_bias` | No figuran en la documentación de BroadNet; pruébelos o elimínelos |
| `store`, `metadata` | Funcionalidades de almacenamiento de OpenAI; elimínelas |
| Partes de contenido `image_url` | Solo en los modelos que listan imágenes: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |

## ¿Cómo se prueba el cambio?

Ejecute una prueba rápida y breve contra el nuevo proveedor antes de mover tráfico. Esta comprueba el chat simple, el uso en streaming, el presupuesto de razonamiento y la autenticación. Añada un caso de llamada a herramienta si usa herramientas.

```python
import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")
```

Después compare la calidad, no solo la forma. Reproduzca una muestra de prompts reales en ambos proveedores y puntúe las respuestas; [evaluar un LLM antes de cambiar](https://broadrouter.com/es/blog/evaluate-llm-before-switching/) muestra cómo. La [herramienta de migración de OpenAI a BroadNet](https://broadrouter.com/tools/openai-to-broadnet-migration/) le ayuda a reescribir un fragmento y lista las funcionalidades que usa.

## ¿Qué falla con más frecuencia?

-   **Una URL base global** que también mueve los embeddings y las llamadas de archivos.
-   **Asistentes exclusivos de Responses**, como `output_text`, que quedan en un código que ahora llama a Chat Completions.
-   **ID de modelo.** Los nombres `gpt-...` no existen en otros proveedores. En BroadNet se parecen a `broadnet/glm-5.3`.
-   **Respuestas vacías** de modelos de razonamiento con un `max_tokens` pequeño.
-   **Límites de frecuencia.** Una clave de pago por uso de BroadNet permite 30 solicitudes por minuto y 4 en curso. Los trabajos masivos necesitan una cola ([manejo del error 429](https://broadrouter.com/es/blog/handle-llm-api-429-rate-limits/)).

## Dónde encaja BroadNet Inference

BroadNet Inference encaja con aplicaciones cuyo uso de OpenAI es chat y transcripción: asistentes, extracción, resúmenes, traducción y voz en árabe. También encaja con aplicaciones que quieren planes de tarifa plana de [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) para sus agentes. No es el destino adecuado si depende del estado en el servidor de la Responses API, de las herramientas integradas, de embeddings, de generación de imágenes, de texto a voz, de voz en tiempo real o de la Batch API. Lleve esas funciones a proveedores que las ofrezcan, o manténgalas en OpenAI y mueva solo las llamadas de chat. Gemma 4 VL 26B y los dos modelos de transcripción funcionan con el crédito inicial de $5; GLM 5.3, Qwen3.8 27B y DeepSeek V4.1 Flash requieren antes una recarga.

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Embeddings (vectores de texto)](https://broadrouter.com/es/glossary/embeddings/)

Los embeddings son listas de números de punto flotante (vectores) que un modelo produce para representar un texto, una imagen u otra entrada. Las entradas de significado parecido obtienen vectores cercanos, así que la distancia entre vectores sirve para ordenar resultados de búsqueda, agrupar documentos o encontrar elementos relacionados.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[API de Chat Completions](https://broadrouter.com/es/glossary/chat-completions-api/)

La API de Chat Completions es el endpoint HTTP de OpenAI, POST /v1/chat/completions, que recibe un nombre de modelo y una lista de mensajes etiquetados con su rol y devuelve el siguiente mensaje del modelo. Su forma de solicitud y respuesta se convirtió en el formato común que reutilizan los proveedores y SDKs compatibles con OpenAI.

[Streaming (respuestas en tiempo real)](https://broadrouter.com/es/glossary/streaming/)

El streaming es una forma de devolver la respuesta de un modelo de lenguaje en pequeños fragmentos mientras aún se genera, en lugar de una sola respuesta al final. Las APIs compatibles con OpenAI hacen streaming mediante server-sent events cuando la solicitud define stream como true.

[URL base (base URL)](https://broadrouter.com/es/glossary/base-url/)

La URL base es la dirección raíz fija de una API, como https://api.example.com/v1, que un cliente antepone a cada ruta de endpoint, como /chat/completions. En los SDKs compatibles con OpenAI, cambiar la URL base, junto con la clave de API y el ID del modelo, dirige el mismo código a otro proveedor.

[Pago por uso (pay-as-you-go)](https://broadrouter.com/es/glossary/pay-as-you-go/)

El pago por uso es un modelo de precios en el que usted paga solo lo que usa, medido por unidades como tokens, solicitudes o minutos de audio, sin suscripción ni compromiso mínimo. La mayoría de las APIs de LLM cobran así, desde un saldo prepagado o con una factura periódica.

[Salida estructurada (structured output)](https://broadrouter.com/es/glossary/structured-output/)

La salida estructurada es una función de las APIs de LLM que restringe la respuesta del modelo a un formato que define el desarrollador, normalmente un JSON Schema, para que el código pueda procesarla de forma fiable. Es más estricta que JSON mode, que garantiza JSON válido pero no una forma concreta.

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

## Preguntas frecuentes

### ¿Necesito otro SDK para usar una API compatible con OpenAI?

No. Mantenga el paquete oficial openai y pase otra base\_url (Python) o baseURL (Node), junto con la clave del nuevo proveedor. Los objetos de solicitud y respuesta no cambian en los endpoints que el proveedor admite.

### ¿Una API compatible con OpenAI admite la Responses API?

Algunas sí; muchas solo admiten Chat Completions. Revise la lista de endpoints del proveedor. BroadNet Inference documenta /v1/chat/completions y /v1/audio/transcriptions, así que el código de Responses debe reescribirse a Chat Completions.

### ¿Qué pasa con mis embeddings al cambiar?

Fallan si el nuevo proveedor no tiene endpoint de embeddings y usted cambió la URL base de forma global. BroadNet no vende embeddings, así que mantenga un cliente de embeddings apuntando a su proveedor de embeddings. Nunca mezcle vectores de dos modelos de embeddings en un mismo índice.

### ¿Debo enviar max\_tokens o max\_completion\_tokens?

OpenAI marca max\_tokens como obsoleto en favor de max\_completion\_tokens. Muchos proveedores compatibles documentan max\_tokens, y la documentación de BroadNet usa max\_tokens. Envíe lo que documente el proveedor y confirme en su prueba rápida que el límite se aplica.

### ¿Seguirán funcionando los asistentes de salida estructurada de OpenAI?

Solo si el proveedor acepta response\_format con json\_schema en el modelo que usa. BroadNet lista salida estructurada para GLM 5.3 y Qwen3.8 27B, pero no nombra el parámetro de la solicitud, así que pruébelo y siga validando el resultado analizado.

## Siga leyendo

-   [Cambiar a una API compatible con OpenAI: lista de verificación](https://broadrouter.com/es/blog/openai-compatible-api-migration-checklist/)
-   [URL base de APIs compatibles con OpenAI: 14 proveedores verificados](https://broadrouter.com/es/blog/openai-compatible-api-base-urls/)
-   [Tool calling con modelos abiertos: esquemas, paralelismo, reintentos](https://broadrouter.com/es/blog/tool-calling-open-models/)
-   [Modo JSON o json\_schema: salida estructurada que no falla](https://broadrouter.com/es/blog/structured-output-json-schema/)
-   [Cómo evaluar un LLM antes de cambiar de proveedor](https://broadrouter.com/es/blog/evaluate-llm-before-switching/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: Usar el SDK de OpenAI para Node.js con BroadNet Inference](https://broadrouter.com/es/guides/openai-node-sdk/)
-   [Guía: Primera solicitud a BroadNet Inference con curl](https://broadrouter.com/es/guides/curl-quickstart/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-migrate-from-openai-api-code-walkthrough&utm_content=page-cta) ·

**Fuentes**

-   [Referencia de la API de BroadNet Inference: endpoints, ID de modelo, capacidades, uso en streaming, errores (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-migrate-from-openai-api-code-walkthrough&utm_content=sources)
-   [README de openai-python: Responses es la API principal, Chat Completions con soporte indefinido, reintentos (consultado el 2026-11-15)](https://github.com/openai/openai-python)
-   [Código fuente del cliente openai-node: baseURL toma por defecto OPENAI\_BASE\_URL (consultado el 2026-11-15)](https://github.com/openai/openai-node/blob/master/src/client.ts)
-   [OpenAI, migrar a la Responses API: diferencias en salida estructurada, herramientas y almacenamiento (consultado el 2026-11-15)](https://developers.openai.com/api/docs/guides/migrate-to-responses)
-   [Guía de function calling de OpenAI: forma de las herramientas en ambas API (consultado el 2026-11-15)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Referencia de Chat Completions de OpenAI: max\_tokens obsoleto en favor de max\_completion\_tokens (consultado el 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
