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

Streaming de audio bidireccional

Lección 3 de 18 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Streaming de audio bidireccional
  2. Formato de audio PCM16
  3. Envío de audio: captura del micrófono
  4. Recepción del audio de respuesta
  5. Aplicación completa: conversación de voz
  6. Puntos clave

Actualizado el 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 sustituto 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 la síntesis de voz se traslada a la Realtime API); gpt-realtime, gpt-4o-realtime y los modelos de audio heredados 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.

Streaming de audio bidireccional

El streaming de audio bidireccional es el núcleo de la Realtime API. Envías continuamente fragmentos de audio desde el micrófono y el modelo devuelve continuamente fragmentos de audio de respuesta. Estas dos transmisiones son independientes y pueden operar simultáneamente, lo que hace que la conversación resulte natural.

Formato de audio PCM16

La Realtime API utiliza el formato PCM mono de 16 bits a 24 kHz. Se trata de un formato crudo y sin comprimir: cada muestra es un entero con signo de 16 bits. Esta elección prioriza la baja latencia frente a la eficiencia del ancho de banda.

24 kHz
Frecuencia de muestreo
16 bit
Profundidad de muestra
Mono
Canal único
48 KB/s
Tasa de bits de audio crudo

Los fragmentos de audio se envían codificados en Base64 dentro de eventos JSON. Cada fragmento representa habitualmente entre 20 y 100 ms de audio.

Envío de audio: captura del micrófono

Así es como puedes capturar el micrófono y transmitir el audio:

import asyncio
import sounddevice as sd
import numpy as np
import base64
import json

SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)

async def stream_microphone(ws):
    """Captura el micrófono y envía fragmentos a la Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Advertencia de audio: {status}")
        # Convertir a int16 y poner en la cola
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Iniciar captura
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Micrófono activo — habla ahora...")
        while True:
            pcm_data = await audio_queue.get()
            audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")

            await ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": audio_b64
            }))

El búfer de audio del lado del servidor

Los fragmentos enviados mediante input_audio_buffer.append se acumulan en un búfer en el servidor. Este búfer se procesa de dos formas:

  • Modo VAD automático (server_vad): el servidor detecta cuando dejas de hablar y confirma el búfer automáticamente.
  • Modo manual: envías explícitamente input_audio_buffer.commit para desencadenar el procesamiento.
# Confirmar manualmente el búfer de audio
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# O limpiar el búfer sin procesarlo
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Recepción del audio de respuesta

Las respuestas de audio llegan en fragmentos mediante eventos response.output_audio.delta. Debes decodificarlos y reproducirlos continuamente:

import pyaudio

async def play_response_audio(ws):
    """Recibe y reproduce el audio de respuesta."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=SAMPLE_RATE,
        output=True,
        frames_per_buffer=CHUNK_SIZE
    )

    try:
        async for raw_message in ws:
            event = json.loads(raw_message)

            if event["type"] == "response.output_audio.delta":
                # Decodificar el fragmento de audio en Base64
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Respuesta de audio finalizada")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Transcripción de texto de la respuesta
                print(event["delta"], end="", flush=True)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Aplicación completa: conversación de voz

Así es como puedes ensamblar la captura y la reproducción para una conversación completa:

async def conversation_vocale():
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Esperar a session.created
        await ws.recv()

        # Configurar la sesión
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": "Eres un asistente de voz. Responde en inglés.",
                "audio": {
                    "input": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 700
                        }
                    },
                    "output": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "voice": "marin"
                    }
                }
            }
        }))
        await ws.recv()  # session.updated

        # Lanzar captura y reproducción en paralelo
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Gestión de transmisiones concurrentes

El reto del streaming bidireccional es que envías y recibes simultáneamente por el mismo WebSocket. asyncio.gather lanza ambas corrutinas en paralelo, pero comparten el mismo objeto WebSocket. La biblioteca websockets gestiona esta concurrencia correctamente.

Puntos clave

  • El audio se transmite como PCM mono de 16 bits a 24 kHz, codificado en Base64 dentro de eventos JSON
  • Los fragmentos suelen ser de 20 a 100 ms de audio para lograr un buen equilibrio entre latencia y sobrecarga
  • El búfer de audio del lado del servidor acumula fragmentos hasta su confirmación (automática en modo VAD)
  • La reproducción de la respuesta ocurre fragmento a fragmento mediante response.output_audio.delta
  • asyncio.gather permite la captura y reproducción simultáneas en el mismo WebSocket