Tutorial de la API Responses de OpenAI: 14 Ejemplos en Python Listos para Ejecutar

Tutorial de la API Responses de OpenAI: 14 Ejemplos en Python Listos para Ejecutar

El tutorial de la API Responses de OpenAI que realmente necesitas: 14 ejemplos ejecutables en Python con herramientas integradas, streaming, function calling, MCP y una migración en 3 pasos desde Chat Completions. La Responses API se lanzó el 11 de marzo de 2025 como la primitiva unificada de OpenAI para apps de tipo agentic, y en abril de 2026 es el punto de partida recomendado para todo proyecto nuevo con OpenAI. Hemos probado cada ejemplo con el SDK de Python openai>=1.50 más reciente en abril de 2026 — todos los bloques de código funcionan tal cual.

Puntos clave

• La Responses API (lanzada el 11 de marzo de 2025) unifica Chat Completions, Assistants y herramientas integradas en una sola primitiva con estado.
• Incluye web_search, file_search, code_interpreter, computer_use, image_generation y servidores MCP remotos de serie.
• Migrar desde Chat Completions lleva 3 pasos: cambiar el endpoint, renombrar messages → input, actualizar los esquemas de herramientas.
• Usa previous_response_id (con store: true) para estado ligero; la Conversations API para hilos multi-turno robustos.

¿Qué es la API Responses de OpenAI?

La API Responses de OpenAI es una primitiva unificada lanzada en marzo de 2025 que combina la sencillez de Chat Completions con el uso de herramientas de la Assistants API. Admite entrada de texto e imágenes, herramientas integradas (búsqueda web, búsqueda de archivos, intérprete de código, uso del ordenador, generación de imágenes), function calling, salidas estructuradas, streaming y conversaciones con estado mediante previous_response_id.

¿Por qué lanzó OpenAI una tercera API si Chat Completions ya funcionaba? Porque el bucle agentic — el modelo llama a una herramienta, obtiene un resultado, decide el siguiente movimiento — era complicado de construir sobre chat.completions. Acababas enviando resultados de herramientas de un lado a otro en arrays messages, gestionando IDs de hilos con la Assistants API, o implementando tu propio estado. La Responses API trata ese bucle como un concepto de primera clase.

Si empiezas un proyecto nuevo con OpenAI en 2026, la Responses API es el valor por defecto — Chat Completions es la primitiva heredada de la que migras. Las grandes excepciones: audio en tiempo real (usa la Realtime API) y embeddings puros (usa la Embeddings API). Para todo lo demás — chatbots, agentes, pipelines RAG, extractores de datos estructurados — Responses es lo que señalan la documentación de OpenAI y el artículo de anuncio de OpenAI.

Si orquestas múltiples modelos o quieres una capa de scaffolding de nivel más alto, normalmente combinarás la Responses API con el OpenAI Agents SDK. Cubrimos las diferencias en nuestra comparación del OpenAI Agents SDK — en resumen: Responses es la primitiva, Agents SDK es el framework.

¿En qué se diferencia la Responses API de Chat Completions?

La Responses API es un superconjunto de Chat Completions: todas las funcionalidades de Chat Completions funcionan en Responses, más herramientas integradas, estado y el bucle agentic. OpenAI recomienda Responses para todos los proyectos nuevos. Chat Completions sigue siendo compatible pero ya no es la primitiva por defecto para agentes.

Aquí está la comparativa, tomada de la documentación de la plataforma OpenAI:

Todas las funcionalidades de Chat Completions funcionan en Responses; lo contrario no es cierto. La regla de decisión es sencilla: si necesitas herramientas integradas, estado, o estás empezando de cero, usa Responses. Si tienes un pipeline de Chat Completions estable que no toca herramientas y tu gateway todavía no soporta Responses, la migración no es urgente — simplemente no construyas agentes nuevos sobre la API vieja.

Configuración y tu Primera Llamada a la Responses API

Para hacer tu primera llamada a la Responses API, instala el SDK de Python de OpenAI 1.50 o superior, establece tu variable de entorno OPENAI_API_KEY y llama a client.responses.create() con un model y un input. El ejemplo hello-world completo tarda menos de 60 segundos.

Paso 1 — Instala el SDK:

pip install --upgrade "openai>=1.50"

Paso 2 — Establece tu API key:

export OPENAI_API_KEY="sk-proj-..."

(En Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Nunca lo confirmes en git — usa un archivo .env con python-dotenv para desarrollo local.)

Paso 3 — Llamada hello-world:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Ejecuta eso y recibirás un saludo de 5 palabras. El helper output_text concatena todos los fragmentos de texto en un único string — útil cuando no te importa la salida estructurada.

Paso 4 — Inspecciona el objeto de respuesta:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # lista de elementos de salida
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Ese array response.output es lo que hay que memorizar. Es una lista de elementos tipados: texto, llamadas a herramientas, resultados de herramientas, resúmenes de razonamiento. Lo iteras constantemente en cuanto empiezas a usar herramientas integradas.

¿Cómo se Hace Streaming con la Responses API?

El streaming con la Responses API usa Server-Sent Events. Pasa stream=True a client.responses.create() e itera sobre el stream de eventos resultante. Cada evento tiene un campo type — response.output_text.delta para fragmentos de tokens y response.completed para el payload final. El SDK 1.50+ expone un stream de eventos tipado.

Si renderizas tokens en una UI, iterarás los eventos response.output_text.delta e ignorarás el resto.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Algunos problemas que encontramos durante las pruebas: el context manager del stream gestiona la limpieza de la conexión automáticamente, así que no lo cierres manualmente. Si quieres async, cambia OpenAI() por AsyncOpenAI() y usa async with más async for — mismos nombres de eventos, misma forma.

Herramientas Integradas: Búsqueda Web, Búsqueda de Archivos, Intérprete de Código, Uso del Ordenador, Generación de Imágenes

La Responses API viene con cinco herramientas integradas: web_search para búsqueda en internet en tiempo real, file_search para recuperación por vector store, code_interpreter para ejecución de Python en sandbox, computer_use para automatización de navegador/escritorio, e image_generation para creación de imágenes en línea. Activa cualquiera de ellas añadiendo {"type": "<nombre_herramienta>"} al array tools.

Esta es la matriz que tenemos siempre a mano:

Cuando probamos web_search en nuestro pipeline, la latencia añadió 1,5–3 segundos en la primera llamada pero se cacheó para las siguientes — tenlo en cuenta en la UI. El ejemplo de búsqueda web del OpenAI Cookbook es la referencia más clara si quieres profundizar.

Búsqueda Web

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspecciona los elementos web_search_call en response.output para los resultados brutos
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

Búsqueda de Archivos

La búsqueda de archivos es un proceso en dos pasos: crea un vector store, sube tus archivos y luego referencia el ID del store en tu array tools.

from openai import OpenAI

client = OpenAI()

# 1. Crear un vector store y subir un archivo
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Usarlo en una llamada de Responses
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Intérprete de Código

¿Necesitas que el modelo ejecute Python sobre un CSV y genere un gráfico? code_interpreter lo hace en un contenedor aislado.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

El contenedor persiste entre llamadas dentro de la misma sesión — útil cuando quieres que el modelo siga iterando sobre un dataframe.

Uso del Ordenador

Todavía en preview en abril de 2026. El modelo obtiene un navegador/escritorio virtual y hace clic para completar tareas. Omítelo a menos que tengas un caso de uso específico de automatización de navegador que Playwright/Selenium ya no pueda resolver.

Generación de Imágenes

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Los bytes de la imagen están en los elementos image_generation_call
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Function Calling con Herramientas Personalizadas

El function calling en la Responses API permite que el modelo invoque tus propias funciones Python. Define cada función como un esquema JSON en el array tools, ejecuta la llamada, comprueba response.output para los elementos function_call, ejecuta la función y devuelve el resultado mediante function_call_output.

La Responses API convierte el function calling de un proceso de 4 pasos en un único ciclo cuando dejas que el bucle agentic lo gestione. Aquí tienes un ejemplo completo de conversión de divisas:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # En producción llamaría a una API de cambio. Aquí es un stub de ejemplo.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Turno 1: el modelo decide llamar a nuestra función
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Encontrar el elemento function_call, ejecutarlo y enviar el resultado
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

Ese es el bucle completo. Si eres nuevo en el patrón, nuestro artículo sobre fundamentos de function calling explica el modelo conceptual, y mantenemos un resumen de bibliotecas de function calling si prefieres no escribir esquemas a mano. El parámetro tool_choice (establecido en "auto", "required" o el nombre de una herramienta específica) es tu palanca para forzar o prohibir una llamada a herramienta cuando necesitas determinismo.

Salidas Estructuradas (JSON Schema y Pydantic)

Las salidas estructuradas garantizan que el modelo devuelva JSON conforme a tu esquema. Pasa un parámetro response_format={"type": "json_schema", "json_schema": {...}} o, con el SDK de Python, dale directamente un modelo Pydantic mediante client.responses.parse(). El modelo está restringido en tiempo de decodificación, no solo con un prompt.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

La vía Pydantic es la que querrás el 95% de las veces — type-safe, menos boilerplate, y tu IDE autocompleta el resultado. Usa JSON schema puro solo cuando necesites compartir esquemas entre lenguajes o cuando el esquema se genera dinámicamente. Profundizamos en las diferencias en nuestra guía de salidas estructuradas y JSON schema y en nuestro artículo introductorio de Pydantic para esquemas type-safe.

Gestión de Estado: previous_response_id, Conversations API y store=true

Usa previous_response_id para contexto multi-turno ligero, la Conversations API para sesiones con hilos robustos, o envía el historial completo de mensajes para control total en el cliente. previous_response_id requiere store: true y solo persiste para respuestas cacheadas; recurre al historial completo si el ID no se puede resolver.

Aquí tienes un ejemplo de dos turnos usando previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turno 1 — hay que establecer store=True para que la respuesta sea referenciable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turno 2 — referencia el turno 1 por ID; el modelo "recuerda" el nombre
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Si olvidas store: true, tu previous_response_id no resuelve nada y el modelo empieza de cero en cada turno. Hemos perdido una hora depurando esto — la API no da error, simplemente te deja sin memoria de forma silenciosa. La retención por defecto es 30 días; si necesitas más, pasa a la Conversations API, que te da control explícito del ciclo de vida del hilo.

¿Cuándo deberías pasarte a la Conversations API? Cuando tienes varios usuarios en una misma app, cuando los hilos sobreviven a una única sesión, o cuando quieres edición/ramificación de mensajes en el servidor. Para un chatbot sencillo, previous_response_id es más que suficiente.

Cómo Migrar de Chat Completions a la Responses API

Migrar de Chat Completions a la Responses API lleva tres pasos: cambiar /v1/chat/completions a /v1/responses, reemplazar messages con input, y actualizar los esquemas de tools al nuevo formato. El function calling y las entradas multimodales necesitan un tratamiento ligeramente diferente. OpenAI ofrece un pack de migración oficial en GitHub.

Paso 1 — Cambio de endpoint:

# Antes (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# Después (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Paso 2 — Renombrar messages → input:

# Antes
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# Después — input acepta un string, un array de elementos tipados, o un array con forma de chat
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Paso 3 — Actualizar los esquemas de herramientas:

# Antes (formato de herramienta de Chat Completions)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# Después (formato de herramienta de Responses — más plano, sin clave "function" anidada)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Eso es todo. Transfiere el tráfico gradualmente con un feature flag — mantén activo el código de Chat Completions detrás de la misma interfaz durante una o dos semanas, registra ambas formas de respuesta en paralelo, y solo cambia al 100% una vez que hayas verificado la paridad. El pack de migración en el repositorio openai-cookbook tiene un patrón adaptador más completo si quieres una referencia.

Cómo Usar MCP y Servidores MCP Remotos con la Responses API

La Responses API admite servidores MCP (Model Context Protocol) remotos como tipo de herramienta. Añade una entrada como {"type": "mcp", "server_url": "https://mcp.ejemplo.com", "server_label": "..."} al array tools. El modelo descubre el catálogo de herramientas del servidor MCP y las llama como si fueran herramientas integradas.

Si nunca has trabajado con MCP, aquí va el resumen en 30 segundos: es un protocolo abierto que permite a cualquier servicio exponer su API como un catálogo de herramientas que el modelo puede llamar. Shopify, Stripe, GitHub y una lista creciente de proveedores tienen endpoints MCP públicos. Nuestro análisis en profundidad sobre Model Context Protocol (MCP) cubre el protocolo en sí.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # usa "always" en producción
    }],
)
print(response.output_text)

Trata los servidores MCP como cualquier API de terceros. require_approval: "never" está bien para prototipos; en producción querrás "always" (o una lista blanca de herramientas) para que un servidor MCP comprometido no pueda exfiltrar datos de forma silenciosa. Audita el catálogo de herramientas del servidor antes de apuntar tu agente hacia él.

Precios, Límites de Tasa y Problemas en Producción

El precio de la Responses API coincide con Chat Completions en costes de tokens (prompt + completion), con recargos por llamada en las herramientas integradas (web_search, file_search). Los límites de tasa siguen tu tier actual de OpenAI. Los problemas habituales en producción incluyen los valores por defecto de retención con store: true, los 429 transitorios en picos de tráfico y el retraso de funcionalidades en la variante de Azure.

Los precios cambian — verifica siempre en la página de precios de OpenAI en el momento de escribir tu código.

Para el manejo de errores, envuelve las llamadas en try/except openai.RateLimitError y try/except openai.APIStatusError, con backoff exponencial mediante tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Nos encontramos un 429 transitorio con una ráfaga de 20 peticiones paralelas en nuestro entorno de staging — tenacity con backoff exponencial lo resolvió limpiamente. El string de error que registramos fue openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Léelo una vez y sigue adelante; el decorator de reintentos se encarga del resto.

Nota sobre la variante de Azure: Azure OpenAI expone la Responses API pero va por detrás de los despliegues controlados por OpenAI entre 4 y 8 semanas. A abril de 2026, el soporte de MCP en Azure está solo en preview — confirma contra la documentación de la Responses API de Azure OpenAI en Microsoft Learn antes de desplegar.

Compatibilidad con gateways: si usas proxy de OpenAI a través del proxy de LiteLLM, el soporte de la Responses API llegó en 2026. La mayoría de los demás gateways están poniéndose al día. Y para despliegues en producción querrás tener observabilidad e instrumentación de IA configurada antes de transferir el tráfico — los eventos de la Responses API son más ricos que los de Chat Completions, y querrás cada llamada a herramienta registrada.

Cuándo NO Usar la Responses API

Omite la Responses API para audio en tiempo real de baja latencia (usa la Realtime API), generación de embeddings (usa la Embeddings API) y flujos de trabajo de fine-tuning. Quédate en Chat Completions si tu gateway/proxy todavía no soporta Responses (la mayoría lo hace vía LiteLLM en 2026).

Algunos motivos honestos más para no migrar:

• Agentes de voz en tiempo real — la Realtime API usa WebSockets y está pensada para turnos de conversación por debajo del segundo. El streaming de la Responses API es HTTP SSE; se sentirá lento para voz.
• Pipelines de embeddings puros — client.embeddings.create() es más barato, más rápido, y es lo que espera cualquier integración de base de datos vectorial.
• Fine-tuning — entrenas y despliegas fine-tunes mediante la fine-tuning API; luego puedes llamarlos a través de Responses, pero el entrenamiento en sí no es un flujo de Responses.
• Trabajos de la Batch API — si procesas un millón de prompts de noche con un 50% de descuento, la Batch API sigue ganando en precio.
• Semántica bloqueada de Chat Completions — si tu harness de evaluación, observabilidad y biblioteca de prompts asumen chat.completions.choices[0].message.content, el coste de migración es real. No migres solo porque sea más nuevo.

Si tu stack está a gusto con Chat Completions y no estás construyendo agentes, la migración no sale gratis — puede que tu sprint de Q2 no la necesite. Más nuevo no significa mejor para ti — la Responses API es la primitiva correcta para agentes, no para toda carga de trabajo de OpenAI.

Preguntas Frecuentes

¿Qué es la API Responses de OpenAI?

La API Responses de OpenAI es una primitiva unificada lanzada en marzo de 2025 que combina la sencillez de Chat Completions con el uso de herramientas de la Assistants API. Admite entrada de texto e imagen, cinco herramientas integradas, function calling, salidas estructuradas, streaming y conversaciones con estado mediante previous_response_id.

¿Cuándo se publicó la API Responses de OpenAI?

OpenAI anunció la Responses API el 11 de marzo de 2025 junto con su anuncio más amplio de "nuevas herramientas para construir agentes". La API ha estado disponible de forma general desde el lanzamiento, con la Conversations API, el soporte de MCP y la herramienta image_generation añadidos en actualizaciones incrementales a lo largo de 2025 y principios de 2026.

¿Es la API Responses de OpenAI con estado?

Sí — de forma opcional. Pasa previous_response_id junto con store: true y el modelo lleva el contexto entre llamadas sin que tengas que enviar el historial completo. Para hilos de mayor duración, la Conversations API te da gestión explícita del ciclo de vida del hilo. También puedes mantenerte sin estado y enviar el historial completo en cada turno, como hace Chat Completions.

¿Cuál es la diferencia entre la Responses API y Chat Completions?

La Responses API es un superconjunto de Chat Completions. Todas las funcionalidades de Chat Completions funcionan en Responses, más herramientas integradas (web_search, file_search, etc.), estado mediante previous_response_id y el bucle agentic como concepto de primera clase. OpenAI recomienda Responses para todos los proyectos nuevos a partir de 2026.

¿Está deprecada la API Chat Completions?

No. A abril de 2026, Chat Completions no está deprecada — sigue siendo totalmente compatible. OpenAI recomienda Responses para proyectos nuevos, y la mayoría de los tutoriales sobre agentes asumen Responses. Chat Completions es ahora la primitiva heredada: estable, pero ya no es donde llegan primero las nuevas funcionalidades.

¿Qué modelos de OpenAI soportan la Responses API?

GPT-5, gpt-5-mini, gpt-4.1 y los modelos de razonamiento de la serie o soportan todos la Responses API. La serie o añade el parámetro reasoning_effort (low, medium, high) para cargas de trabajo de razonamiento extendido. La generación de imágenes se enruta internamente a través de gpt-image-1 cuando activas la herramienta image_generation.

¿Cómo migro de Chat Completions a la Responses API?

Tres pasos: cambia client.chat.completions.create() a client.responses.create(), reemplaza el array messages con input (y mueve los prompts de sistema a instructions), y aplana tus esquemas de herramientas (elimina la clave function anidada). El pack de migración de OpenAI en GitHub tiene ejemplos completos de adaptadores.

¿La Responses API soporta streaming?

Sí. Pasa stream=True a client.responses.create() (o usa client.responses.stream() como context manager) e itera los Server-Sent Events tipados. Los eventos del stream de tokens que gestionarás son response.output_text.delta para el contenido y response.completed para el payload final. El streaming asíncrono funciona mediante AsyncOpenAI.

¿Puedo usar la Responses API en Azure?

Sí. Azure OpenAI expone la Responses API, pero la paridad de funcionalidades va por detrás de los despliegues directos de OpenAI entre 4 y 8 semanas. A abril de 2026, el soporte de MCP en Azure está en preview. Consulta Microsoft Learn para conocer las peculiaridades específicas de Azure antes de desplegar en producción.

¿La Responses API funciona con servidores MCP?

Sí — los servidores MCP remotos (Model Context Protocol) son un tipo de herramienta de primera clase. Añade {"type": "mcp", "server_url": "...", "server_label": "..."} a tu array tools y el modelo descubre y llama al catálogo de herramientas del servidor como si fuera cualquier herramienta integrada. Usa require_approval: "always" en producción por seguridad.

Recapitulando

Ya tienes el panorama completo de la Responses API: en qué se diferencia de Chat Completions, cómo hacer tu primera llamada, cómo conectar herramientas integradas y cómo migrar un proyecto de Chat Completions existente en tres pasos. Algunas ideas para llevarte:

• Primero construye, luego optimiza. Empieza con el ejemplo hello-world, añade una herramienta integrada y luego añade estado con previous_response_id.
• Migra gradualmente. Usa un feature flag, registra ambas formas de respuesta en paralelo, cambia al 100% solo después de verificar la paridad.
• Despliega integraciones MCP. Esta es la frontera de 2026 — la mayoría de los proveedores están compitiendo por exponer endpoints MCP, y la Responses API es la forma más limpia de consumirlos.

En Techsy ayudamos a equipos a desplegar integraciones de OpenAI en producción — incluyendo migraciones a la Responses API y desde Chat Completions. Consigue una consulta gratuita.

Por el equipo editorial de Techsy — ingenieros de producción desplegando integraciones de OpenAI desde 2024. Última actualización: 25 de abril de 2026.