DEV Community

Cover image for Cómo usar la API de GPT-Live-1.1
Roobia
Roobia

Posted on Originally published at apidog.com

Cómo usar la API de GPT-Live-1.1

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.

Prueba Apidog hoy

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í:

  1. Abre wss://api.openai.com/v1/live/sessions con Authorization: Bearer $OPENAI_API_KEY y sin parámetros de consulta.
  2. Envía session.start como primer mensaje, con tu configuración de session.
  3. Espera a recibir session.started antes de enviar audio.
  4. 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");
});
Enter fullscreen mode Exit fullscreen mode

Algunas reglas de configuración de la guía de conversación:

  • instructions admite hasta 16 384 tokens. Puedes añadir más a mitad de sesión con session.instructions.append (500 tokens por inserción).
  • audio.output.voice usa marin como valor predeterminado. Otros nombres disponibles en la API son quartz, stone, meridian y willow.
  • Los formatos para WebSocket son audio/pcm a 24 000 o 16 000 Hz, y audio/pcmu o audio/pcma a 8 000 Hz para telefonía.
  • store se establece en false por defecto. Cambiar el model requiere 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
Enter fullscreen mode Exit fullscreen mode

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.

Architecture of a GPT-Live-1.1 app: the browser sends an SDP offer to your server, which calls POST /v1/live/sessions with the API key; audio flows over WebRTC between the browser and GPT-Live-1.1, which delegates to a gpt-6-luna backend that calls your tool API

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
  }
}
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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
}
Enter fullscreen mode Exit fullscreen mode

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" }));
});
Enter fullscreen mode Exit fullscreen mode

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 de call_id duplicados o no coincidentes se rechazan.
  • Los eventos response.completed reenviados contienen un response.output vacío. Lee los eventos individuales de los elementos de salida.

Sequence of a GPT-Live-1.1 function call: the caller asks about order 123, GPT-Live-1.1 acknowledges and delegates, the backend model sends a function_call to your app inside response.event, your app returns function_call_output and response.create, and GPT-Live-1.1 speaks the answer

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
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)