Transmisión de audio en tiempo real
En esta página
Actualización 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 (sustituto:gpt-realtime-2.1-mini, que la guía de TTS de OpenAI indica que no es compatible con/v1/audio/speech: la migración de la síntesis de voz se traslada a la API en tiempo real);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. Actualizado el 3 de noviembre de 2026: La canalización LLM → TTS procesaba anteriormente cualquier evento que contuviera un campodelta, incluidos los argumentos de llamadas a funciones o resúmenes de razonamiento; ahora filtra estrictamenteresponse.output_text.delta, que es el texto real de la respuesta.
Transmisión de audio en tiempo real
En un agente de voz, esperar a que se genere el archivo de audio completo antes de iniciar la reproducción introduce una latencia inaceptable. La transmisión de TTS te permite comenzar la reproducción tan pronto como lleguen los primeros bytes, reduciendo el tiempo hasta la primera respuesta a unos pocos cientos de milisegundos.
Transmisión con la API de TTS
La API de TTS admite la transmisión de forma nativa. En lugar de esperar al archivo completo, recibes el audio en fragmentos:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Genera y reproduce audio en modo de transmisión."""
# Inicializa el reproductor de audio
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Crea la respuesta en streaming
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # PCM crudo para reproducción directa
) as response:
# Lee y reproduce fragmento a fragmento
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Hello, here is a real-time streaming response.")
El formato pcm es ideal para la transmisión porque no requiere decodificación: los bytes crudos están listos para reproducirse de inmediato.
Medición de la latencia
El tiempo hasta el primer byte (TTFB, por sus siglas en inglés) es la métrica clave para el rendimiento de la transmisión:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Mide las latencias de transmisión de TTS."""
start_time = time.time()
first_byte_time = None
total_bytes = 0
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
for chunk in response.iter_bytes(chunk_size=4096):
if first_byte_time is None:
first_byte_time = time.time()
total_bytes += len(chunk)
end_time = time.time()
return {
"ttfb_ms": round((first_byte_time - start_time) * 1000),
"total_ms": round((end_time - start_time) * 1000),
"total_bytes": total_bytes,
"audio_duration_s": round(total_bytes / (24000 * 2), 2)
}
metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")
Transmisión asíncrona
Para aplicaciones del lado del servidor, utiliza el cliente asíncrono:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Transmisión asíncrona de TTS para servidores."""
chunks = []
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
chunks.append(chunk)
# Aquí enviarías el fragmento al cliente mediante WebSocket
yield chunk
# Uso en un servidor FastAPI
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
app = FastAPI()
@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
return StreamingResponse(
stream_tts_async(text, voice),
media_type="audio/pcm"
)
Precarga del búfer
Para garantizar una reproducción fluida sin interrupciones, acumula un pequeño búfer antes de comenzar:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Número de fragmentos para precargar
):
"""Reproducción de TTS con un búfer de precarga."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
buffer = []
playback_started = False
try:
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
buffer.append(chunk)
if not playback_started and len(buffer) >= buffer_size:
playback_started = True
# Vacia el búfer inicial
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Reproduce los fragmentos restantes
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integración con una canalización LLM + TTS
En un agente de voz que no utiliza la API en tiempo real, puedes combinar la transmisión del LLM con la transmisión de TTS:
async def llm_to_tts_pipeline(user_message: str):
"""Canalización: LLM en streaming → TTS en tiempo real."""
# Fase 1: Acumular la respuesta del LLM por oraciones
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Solo se debe hablar el texto de la respuesta
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Detectar el final de la oración
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Fase 2: Transmitir esta oración a TTS
stream_tts_to_speaker(sentence)
# Procesar el búfer restante
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Puntos clave
- La transmisión de TTS reduce el TTFB a unos pocos cientos de milisegundos al iniciar la reproducción antes de que finalice la generación
- El formato
pcmes óptimo para la transmisión: no requiere decodificación, reproducción directa - Un búfer de precarga de 2–3 fragmentos evita interrupciones al inicio de la reproducción
- El cliente asíncrono es esencial para servidores que gestionan múltiples conexiones simultáneas
- Combinar un LLM en streaming con un TTS en streaming permite crear un agente de voz receptivo sin necesidad de la API en tiempo real