La API de GPT-Live-1.1 es el modelo de voz dúplex completo de OpenAI, servido en v1/live/sessions. Abres una sesión por WebRTC, WebSocket o SIP, envías una configuración de session con el modelo, las instrucciones y la voz, y dejas que delegue el razonamiento y las llamadas a herramientas en un modelo backend de Responses mediante delegation. Cuesta 0,05 $ por minuto activo y 0,02 $ por minuto en espera.
OpenAI puso GPT-Live-1.1 a disposición en la API el 20 de noviembre de 2026, según su anuncio de OpenAI Developers. Si leíste nuestra cobertura de julio, ¿Existe una API de GPT-Live? respondía «todavía no». Eso cambió. Esta guía te lleva paso a paso por una sesión funcional, una configuración de delegación, una herramienta de función y un entorno de prueba para el backend al que llama tu agente de voz.
¿Qué es la API de GPT-Live-1.1?
GPT-Live-1.1 es un modelo que recibe voz y produce voz, y que escucha mientras habla. Funciona en el endpoint v1/live/sessions, no en v1/realtime ni en v1/responses. Su única tarea es la conversación. El razonamiento más pesado y el uso de herramientas se envían a un modelo backend que tú configuras, de modo que la voz sigue respondiendo con fluidez mientras el trabajo se ejecuta.
Esto es lo que la página del modelo GPT-Live-1.1 indica actualmente:
| Elemento | GPT-Live-1.1 |
|---|---|
| ID del modelo |
gpt-live-1.1 (una única instantánea) |
| Entrada / salida | Audio y texto de entrada, audio y texto de salida |
| Endpoint | Solo v1/live/sessions
|
| Transportes | WebRTC (recomendado), WebSocket, SIP |
| Precio activo | 0,05 $ por minuto |
| Precio en espera | 0,02 $ por minuto (WebRTC, con la inferencia en pausa) |
| Modelo backend y herramientas | Facturados por separado a sus tarifas normales |
| Concurrencia | Límite independiente del de GPT-Live-1, por organización |
Para conocer el contexto del producto, consulta qué es GPT-Live y en qué se diferencia de GPT Realtime.
GPT-Live-1.1 frente a GPT-Live-1: qué cambió
La página del modelo y la guía de prompting enumeran cuatro diferencias prácticas:
- Transcripción: la versión 1.1 «transcribe el habla con mayor precisión».
- Voz: la versión 1.1 mantiene «un acento y una voz más consistentes entre idiomas».
-
Prompts de delegación: la versión 1.1 acepta lenguaje natural («Delega en el backend cuando:»). GPT-Live-1 requiere el marcador
<|SpawnThinking|>en su política. - Redacción de la facturación: GPT-Live-1 se factura por segundo y nunca se redondea al minuto completo. La página de la versión 1.1 solo indica «facturado por duración».
Ambos modelos comparten el mismo endpoint, los mismos precios y la misma estructura de sesión, así que pasar a la versión 1.1 consiste básicamente en cambiar la cadena del modelo y usar un prompt más limpio.
Cómo abrir una sesión de GPT-Live-1.1
La guía de inicio de GPT-Live recomienda WebRTC para audio en navegador, móvil y servidor. WebSocket es el camino más sencillo para un prototipo del lado del servidor, así que empieza por ahí:
- Abre
wss://api.openai.com/v1/live/sessionsconAuthorization: Bearer $OPENAI_API_KEYy sin parámetros de consulta. - Envía
session.startcomo primer mensaje, con tu configuración desession. - Espera a recibir
session.startedantes de enviar audio. - Transmite el audio en el formato que hayas elegido. El valor predeterminado es PCM de 24 kHz.
import WebSocket from "ws";
const ws = new WebSocket("wss://api.openai.com/v1/live/sessions", {
headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
});
ws.on("open", () => {
ws.send(JSON.stringify({
type: "session.start",
event_id: "start_1",
session: {
model: "gpt-live-1.1",
instructions: "You are the voice agent for Acme order support. Keep answers short.",
audio: {
format: { type: "audio/pcm", rate: 24000 },
output: { voice: "marin" },
},
},
}));
});
ws.on("message", (raw) => {
const msg = JSON.parse(raw);
if (msg.type === "session.started") console.log("Session ready");
});
Algunas reglas de configuración de la guía de conversación:
-
instructionsadmite hasta 16 384 tokens. Puedes añadir más a mitad de sesión consession.instructions.append(500 tokens por inserción). -
audio.output.voiceusamarincomo valor predeterminado. Otros nombres disponibles en la API sonquartz,stone,meridianywillow. - Los formatos para WebSocket son
audio/pcma 24 000 o 16 000 Hz, yaudio/pcmuoaudio/pcmaa 8 000 Hz para telefonía. -
storese establece enfalsepor defecto. Cambiar elmodelrequiere una nueva sesión.
Para producción en un navegador, cambia a WebRTC. Tu servidor guarda la clave de la API y reenvía la oferta SDP del navegador:
const res = await fetch("https://api.openai.com/v1/live/sessions", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
session: { model: "gpt-live-1.1", instructions: "..." },
transport: { type: "webrtc", sdp: offerSdp },
}),
});
const { session, transport } = await res.json(); // HTTP 201
// session.id looks like "live_123"; return transport.sdp to the browser
Omite audio.format en las solicitudes de WebRTC, y no envíes session.start por el canal de datos. Ten en cuenta un detalle de facturación: crear una sesión WebRTC factura 15 segundos durante la inicialización, que se acreditan una vez que la sesión se pone en marcha.
Delegación en GPT-Live-1.1: deja que un modelo backend haga el razonamiento
La delegación es la razón de ser de esta API. El modelo de voz sigue hablando mientras un modelo backend razona, busca o llama a herramientas. Eliges uno de los dos modos al crear la sesión, y no puedes cambiar de modo a mitad de sesión.
| Modo | delegation.type |
Quién ejecuta el backend | Ideal para |
|---|---|---|---|
| Responses | "responses" |
OpenAI, usando el modelo y las herramientas que configures | La mayoría de las aplicaciones; herramientas alojadas, function calling |
| Cliente |
"client" (también el valor predeterminado) |
Tu aplicación | Tu propio bucle de agente o un backend que no sea de OpenAI |
La guía de delegación sugiere empezar con gpt-6-luna y probar gpt-6-sol para tareas backend más exigentes. Si aún no has elegido uno, nuestra visión general de GPT-6 Luna cubre las diferencias.
"delegation": {
"type": "responses",
"responses": {
"model": "gpt-6-luna",
"instructions": "Look up orders with get_order. Answer in one sentence.",
"tools": [{ "type": "web_search" }],
"tool_choice": "auto",
"parallel_tool_calls": false
}
}
El bloque responses también admite max_output_tokens (16 o más), service_tier (auto, default, flex o priority, donde priority es el modo rápido) y las opciones de reasoning y text que admita tu modelo backend. Puedes modificar estos campos a mitad de sesión con session.update. La validación es asíncrona: una configuración incorrecta llega como un error con el código responses_validation_failed, y la sesión permanece abierta.
Luego indica al modelo de voz cuándo delegar. Con la versión 1.1, esto se hace en lenguaje natural dentro de instructions:
Delegate to the backend when: the caller asks about an order, a refund or anything you must look up.
Do not delegate when: the caller greets you, asks you to repeat, or says goodbye.
While the backend works, briefly say what you are checking.
La guía de prompting advierte que un «Estoy verificando eso» dicho en voz alta no prueba que el trabajo del backend haya comenzado. En su lugar, vigila session.delegation.created en tus registros.
Añadir function calling a una sesión de GPT-Live-1.1
Las herramientas alojadas, como la búsqueda web, se ejecutan dentro de OpenAI. Tus propias funciones se ejecutan en tu aplicación. Coloca una herramienta de función estándar de Responses en delegation.responses.tools:
{
"type": "function",
"name": "get_order",
"description": "Get the shipping status of an order by its ID.",
"parameters": {
"type": "object",
"properties": { "order_id": { "type": "string" } },
"required": ["order_id"],
"additionalProperties": false
},
"strict": true
}
Los eventos del backend te llegan envueltos en un sobre response.event que contiene un delegation_id y un event anidado. Una llamada a función completada llega como un response.output_item.done anidado cuyo elemento tiene call_id, name y arguments. Ejecuta la función, envía un response.item.create con el resultado y después envía response.create:
ws.on("message", async (raw) => {
const msg = JSON.parse(raw);
if (msg.type !== "response.event") return;
const ev = msg.event;
if (ev.type !== "response.output_item.done" || ev.item?.type !== "function_call") return;
const { order_id } = JSON.parse(ev.item.arguments);
const order = await fetch(`${ORDERS_API}/orders/${order_id}`).then((r) => r.json());
ws.send(JSON.stringify({
type: "response.item.create",
item: { type: "function_call_output", call_id: ev.item.call_id, output: JSON.stringify(order) },
}));
ws.send(JSON.stringify({ type: "response.create" }));
});
Tres detalles suelen causar problemas:
- Añadir solo el resultado no reanuda el backend. Necesitas el
response.create. - Si omites un resultado pendiente, recibirás
function_call_outputs_required. Los valores decall_idduplicados o no coincidentes se rechazan. - Los eventos
response.completedreenviados contienen unresponse.outputvacío. Lee los eventos individuales de los elementos de salida.
Precios y límites de GPT-Live-1.1
El tiempo de voz es fácil de calcular. Una llamada de soporte de 5 minutos que permanece activa todo el tiempo cuesta 5 × 0,05 $ = 0,25 $ en tiempo de voz. Mil llamadas así suman 250 $, más lo que facturen el modelo backend y las herramientas a sus tarifas normales.
| Concepto de coste | Tarifa |
|---|---|
| Voz activa | 0,05 $ por minuto |
| Voz en espera (WebRTC, inferencia en pausa) | 0,02 $ por minuto |
| Inicialización de WebRTC | 15 segundos, acreditados una vez que la sesión se ejecuta |
| Modelo backend y herramientas | Precio normal de ese modelo y herramienta |
Los límites de tarificación cuentan sesiones simultáneas, no tokens. GPT-Live-1.1 y GPT-Live-1 tienen límites independientes que se aplican en todas las regiones de inferencia. La página de GPT-Live-1 indica 50, 300 y 500 sesiones simultáneas para los niveles Build, Launch y Grow, sin acceso en el nivel Free. La página de la versión 1.1 no ofrece cifras, así que consulta la página de límites de tu organización antes de un lanzamiento.
Deja que tu agente de programación pruebe el backend de herramientas con Apidog CLI
Tu agente de voz es tan fiable como la API detrás de get_order. Una respuesta lenta o malformada se convierte en silencio incómodo o en una respuesta incorrecta dicha en voz alta. Así que prueba ese backend antes de que cualquier usuario lo escuche, y deja que tu agente de programación lo haga con Apidog CLI.
Configúralo una sola vez:
npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install
Luego dale a Claude Code, Codex o Cursor un único prompt:
Import ./orders-openapi.yaml into Apidog project <projectId>. Create test cases for
GET /orders/{order_id}: a known ID returns 200 with a status field in under 800 ms,
and an unknown ID returns 404 with a JSON error. Run them against the staging
environment and tell me what failed.
El agente lee el esquema, valida su payload, crea los casos y los ejecuta:
apidog import --project <projectId> --format openapi --file ./orders-openapi.yaml
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json
El presupuesto de 800 ms importa en el caso de la voz: el usuario percibe cada milisegundo que tarda tu herramienta. Incluye el mismo apidog run con -r junit en CI para que una regresión rompa la compilación, como se muestra en nuestra guía de CI/CD con Apidog CLI. ¿Nuevo en el flujo de trabajo con agentes? Empieza con Apidog CLI en Claude Code. El plan Free de Apidog cubre hasta 4 usuarios.
Preguntas frecuentes
¿Está GPT-Live-1.1 disponible en la API? Sí. Desde el 20 de noviembre de 2026, puedes llamar a gpt-live-1.1 en v1/live/sessions mediante WebRTC, WebSocket o SIP. No se sirve en v1/realtime, v1/responses ni en Chat Completions.
¿Cuánto cuesta la API de GPT-Live-1.1? 0,05 $ por minuto activo y 0,02 $ por minuto en espera. Las llamadas al modelo backend y las herramientas se facturan por separado a sus propias tarifas.
¿Cuál es la diferencia entre GPT-Live-1.1 y GPT Realtime? GPT-Live funciona en su propio endpoint, factura por duración de voz y delega el razonamiento en un modelo backend. GPT Realtime funciona en v1/realtime. Consulta nuestra comparación entre GPT-Live y GPT Realtime.
¿Qué modelo backend debo usar para la delegación? La guía de OpenAI sugiere empezar con gpt-6-luna y usar gpt-6-sol para tareas backend más complejas. Configura service_tier en priority si la latencia importa más que el coste.
¿Puedo usar mi propio agente en lugar de un modelo de Responses? Sí. Configura delegation.type en client. Tu aplicación ejecuta el trabajo del backend y devuelve los resultados con session.commentary.append. También gestionas las transcripciones por tu cuenta.
¿Admite GPT-Live-1.1 el function calling? Sí, mediante la delegación de Responses. Define las funciones en delegation.responses.tools, lee las llamadas desde response.event y devuelve los resultados con response.item.create junto con response.create.


Top comments (0)