Streaming de audio bidireccional
En esta página
Actualizado el 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 sustituto 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 la síntesis de voz se traslada a la Realtime API);gpt-realtime,gpt-4o-realtimey 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-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.
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.
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.commitpara 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.gatherpermite la captura y reproducción simultáneas en el mismo WebSocket