Ir al contenido principal
Español— Elegir un idioma
Menú

Integración de telefonía (Twilio, etc.)

Lección 15 de 18 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Integración de telefonía (Twilio, etc.)
  2. Arquitectura de telefonía
  3. Implementación con Twilio
  4. Alternativas a Twilio
  5. Puntos clave

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 anteriormente g711_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-hd y gpt-4o-mini-tts dejarán de funcionar el 6 de enero de 2027 (el reemplazo indicado es gpt-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-realtime y 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-transcribe y /v1/audio/translations el 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:

1

Llamada entrante → Twilio

El usuario marca un número de teléfono. Twilio recibe la llamada y envía un webhook a tu servidor.

2

Tu servidor → Flujo multimedia

Tu servidor responde con instrucciones TwiML que abren un WebSocket de flujo multimedia bidireccional.

3

Flujo multimedia ↔ Realtime API

Tu servidor retransmite el audio entre el flujo multimedia de Twilio y la Realtime API de OpenAI.

4

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