Integración de telefonía (Twilio, etc.)
En esta página
Actualizado el 3 de noviembre de 2026 según la documentación de la Realtime API: el formato G.711 μ-law se denomina
audio/pcmu(el texto citaba anteriormenteg711_ulaw, que era el nombre de la versión beta). Fuente: Realtime API.
Actualización del 2 de noviembre de 2026 — Modelos de audio. Varios modelos de este curso están obsoletos:
tts-1,tts-1-hdygpt-4o-mini-ttsdejarán de funcionar el 6 de enero de 2027 (el reemplazo indicado esgpt-realtime-2.1-mini, que la guía de TTS de OpenAI especifica que no es compatible con/v1/audio/speech: la migración de síntesis de voz debe realizarse a través de la Realtime API);gpt-realtime,gpt-4o-realtimey los modelos de audio herederos el 20 de enero de 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribey/v1/audio/translationsel 26 de febrero de 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Para la voz a dúplex completo, GPT-Live 1 está disponible en la API desde el 10 de septiembre de 2026.
Integración de telefonía (Twilio, etc.)
Un agente de voz resulta realmente útil cuando es accesible por teléfono. Plataformas de telefonía en la nube como Twilio, LiveKit y Daily te permiten conectar la Realtime API a la red telefónica global. Un usuario marca un número y tu agente responde en tiempo real.
Arquitectura de telefonía
La integración de telefonía añade una capa entre la red telefónica y la Realtime API:
Llamada entrante → Twilio
El usuario marca un número de teléfono. Twilio recibe la llamada y envía un webhook a tu servidor.
Tu servidor → Flujo multimedia
Tu servidor responde con instrucciones TwiML que abren un WebSocket de flujo multimedia bidireccional.
Flujo multimedia ↔ Realtime API
Tu servidor retransmite el audio entre el flujo multimedia de Twilio y la Realtime API de OpenAI.
Respuesta de voz → Usuario
El audio de respuesta de la Realtime API se envía de vuelta a través de Twilio al teléfono del usuario.
Implementación con Twilio
Webhook de llamada entrante
Cuando llega una llamada, Twilio envía una petición HTTP a tu servidor. Tú respondes con TwiML que abre un flujo multimedia:
from fastapi import FastAPI, Request
from fastapi.responses import Response
app = FastAPI()
@app.post("/incoming-call")
async def incoming_call(request: Request):
"""Webhook de Twilio para llamadas entrantes."""
twiml = """<?xml version="1.0" encoding="UTF-8"?>
<Response>
<Say language="en-US">
Bienvenido a Corsen AI. Le conectamos con su asistente de voz.
</Say>
<Connect>
<Stream url="wss://your-server.com/media-stream">
<Parameter name="caller" value="{caller_number}" />
</Stream>
</Connect>
</Response>"""
form_data = await request.form()
caller = form_data.get("From", "unknown")
twiml = twiml.replace("{caller_number}", caller)
return Response(content=twiml, media_type="application/xml")
El puente entre el flujo multimedia y la Realtime API
El servidor WebSocket recibe el audio de Twilio y lo retransmite a la Realtime API:
from fastapi import WebSocket
import websockets
import json
import base64
import audioop
import asyncio
OPENAI_API_KEY = "sk-..."
REALTIME_URL = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1"
@app.websocket("/media-stream")
async def media_stream(twilio_ws: WebSocket):
"""Puente entre el flujo multimedia de Twilio y la Realtime API."""
await twilio_ws.accept()
# Conexión a la Realtime API
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(REALTIME_URL, additional_headers=headers) as openai_ws:
await openai_ws.recv() # session.created
# Configuración de la sesión
await openai_ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "Eres un asistente telefónico. "
"Responde en inglés, de forma concisa.",
"audio": {
"input": {
"format": {"type": "audio/pcmu"},
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"silence_duration_ms": 600
}
},
"output": {
"format": {"type": "audio/pcmu"},
"voice": "marin"
}
}
}
}))
await openai_ws.recv()
stream_sid = None
async def twilio_to_openai():
nonlocal stream_sid
async for message in twilio_ws.iter_text():
data = json.loads(message)
if data["event"] == "media":
audio_b64 = data["media"]["payload"]
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": audio_b64
}))
elif data["event"] == "start":
stream_sid = data["start"]["streamSid"]
async def openai_to_twilio():
async for message in openai_ws:
event = json.loads(message)
if event["type"] == "response.output_audio.delta":
await twilio_ws.send_json({
"event": "media",
"streamSid": stream_sid,
"media": {
"payload": event["delta"]
}
})
await asyncio.gather(twilio_to_openai(), openai_to_twilio())
Formato de audio G.711
La telefonía utiliza el formato G.711 μ-law (8 kHz, un byte por muestra). La Realtime API lo admite de forma nativa bajo el nombre audio/pcmu, que debes declarar tanto para la entrada como para la salida (audio.input.format y audio.output.format, como en el código anterior). Esto evita cualquier conversión en el servidor. El nombre g711_ulaw pertenecía a la versión beta de la API; el equivalente A-law se denomina audio/pcma.
Alternativas a Twilio
| Plataforma | Punto fuerte | Integración con Realtime API |
|---|---|---|
| Twilio | Ecosistema completo, números en más de 100 países | Flujos multimedia WebSocket nativos |
| LiveKit | Código abierto, baja latencia, WebRTC | Plugin oficial de OpenAI |
| Daily | Sencillo, alojado, ideal para prototipos | SDK Pipecat con conector Realtime |
Puntos clave
- Twilio Media Streams te permite conectar una llamada telefónica a un WebSocket bidireccional
- Tu servidor actúa como puente entre el flujo multimedia de Twilio y la Realtime API de OpenAI
- El formato G.711 μ-law es nativo de la telefonía y lo admite directamente la Realtime API
- LiveKit (código abierto, WebRTC) y Daily (alojado) son alternativas viables a Twilio
- La arquitectura es siempre la misma: telefonía → tu servidor → Realtime API