Integración en el navegador y buenas prácticas
En esta página
Actualizado el 3 de noviembre de 2026, según la página Text to Speech de xAI: la validación del lado del servidor utiliza el límite actual de 60.000 caracteres por solicitud. Fuente: Text to Speech.
Despliegue de TTS en una aplicación web
Integrar TTS en un navegador conlleva desafíos específicos: compatibilidad de códecs, gestión de memoria, peculiaridades de Safari y rendimiento. Esta última lección te proporciona lo necesario para una integración robusta en producción.
Compatibilidad de códecs en el navegador
No todos los navegadores admiten todos los formatos de audio. Elige el códec adecuado para tu audiencia:
| Códec | Chrome | Firefox | Safari | Edge | Recomendado |
|---|---|---|---|---|---|
| MP3 | Sí | Sí | Sí | Sí | Sí |
| WAV | Sí | Sí | Sí | Sí | Sí |
| PCM sin formato | No | No | No | No | No |
| mulaw/alaw | No | No | No | No | No |
La regla sencilla: usa MP3 o WAV en el navegador. PCM, mulaw y alaw están diseñados para aplicaciones de servidor y telefonía, no para reproducción web.
// Solicitar MP3 desde la API (a través de tu backend)
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
text: "Hola desde el navegador.",
voice_id: "eve",
language: "en"
// No es necesario establecer output_format: MP3 es el predeterminado
})
});
El problema de AudioContext en Safari
Safari impone una restricción de seguridad: un AudioContext solo puede crearse dentro de un manejador de eventos de usuario (clic, pulsación de tecla, toque). Si intentas crear un AudioContext cuando se carga la página, Safari lo bloquea en silencio.
El enfoque incorrecto
// NO funciona en Safari
const audioContext = new AudioContext(); // ¡Bloqueado!
async function playTTS() {
const audio = await fetchTTS("Hola");
// audioContext está suspendido en Safari...
}
El enfoque correcto
let audioContext = null;
// Crear el AudioContext en el primer clic del usuario
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Reanudar si está suspendido
if (audioContext.state === "suspended") {
await audioContext.resume();
}
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
text: "Hola desde Safari.",
voice_id: "eve",
language: "en"
})
});
const arrayBuffer = await response.arrayBuffer();
const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
const source = audioContext.createBufferSource();
source.buffer = audioBuffer;
source.connect(audioContext.destination);
source.start(0);
});
Este enfoque funciona en todos los navegadores, no solo en Safari. Es una buena práctica universal.
URLs de Blob y fugas de memoria
Cuando creas URLs de Blob para reproducir audio, cada URL consume memoria hasta que la liberas explícitamente. Sin limpieza, tu aplicación sufrirá fugas de memoria.
El problema
// Cada llamada crea una URL de Blob que nunca se libera
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // ¡Fuga de memoria!
const audio = new Audio(url);
audio.play();
}
La solución
async function playTTS(text) {
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ text, voice_id: "eve", language: "en" })
});
const blob = await response.blob();
const url = URL.createObjectURL(blob);
const audio = new Audio(url);
// Liberar la memoria cuando finalice la reproducción
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// También liberarla en caso de error
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
Para aplicaciones que generan mucho audio, mantén una lista de URLs activas y límpialas periódicamente:
class AudioManager {
constructor() {
this.activeUrls = new Set();
}
async play(text) {
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ text, voice_id: "eve", language: "en" })
});
const blob = await response.blob();
const url = URL.createObjectURL(blob);
this.activeUrls.add(url);
const audio = new Audio(url);
audio.addEventListener("ended", () => this.release(url));
audio.addEventListener("error", () => this.release(url));
audio.play();
return audio;
}
release(url) {
URL.revokeObjectURL(url);
this.activeUrls.delete(url);
}
cleanup() {
// Liberar cada URL activa
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Buenas prácticas para producción
Limitación de tasa en el backend
Protege tu backend del abuso limitando las solicitudes por usuario:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minuto
max: 10, // 10 solicitudes por minuto por IP
message: { error: "Demasiadas solicitudes de TTS" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy a la API de xAI
});
Validación de texto
Valida y sanea el texto antes de enviarlo a la API:
function validateTTSInput(text) {
if (!text || typeof text !== "string") {
throw new Error("El texto es obligatorio");
}
if (text.length > 60000) {
throw new Error("Texto demasiado largo (máximo 60.000 caracteres)");
}
// Eliminar caracteres de control
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Caché de audio
Para textos repetidos (saludos, instrucciones estándar), almacena en caché el audio generado:
const audioCache = new Map();
async function getTTS(text, voice, language) {
const cacheKey = `${text}:${voice}:${language}`;
if (audioCache.has(cacheKey)) {
return audioCache.get(cacheKey);
}
const audio = await fetchTTSFromAPI(text, voice, language);
audioCache.set(cacheKey, audio);
return audio;
}
Pregeneración
Para contenido que conoces de antemano (e-learning, IVR), pregenera los archivos de audio en tiempo de compilación en lugar de hacerlo sobre la marcha.
Puntos clave
- Usa MP3 o WAV en el navegador; nunca PCM/mulaw/alaw
- En Safari, crea el AudioContext dentro de un manejador de eventos de usuario
- Libera siempre las URLs de Blob con
URL.revokeObjectURL()tras su uso - Añade limitación de tasa a tu proxy de backend
- Valida y sanea el texto antes de enviarlo a la API
- Almacena en caché el audio para textos repetidos y ahorra llamadas a la API
- Pregenera el audio para contenido que conoces de antemano
Comprueba tu comprensión
Síntesis de voz de xAI: desde la primera llamada hasta la canalización de streaming.
1. ¿Cómo funciona la llamada básica a TTS?
Respuesta: Una petición POST a /v1/tts con el texto, la voz elegida (que puedes listar mediante la API) y los parámetros. La respuesta es el audio, facturado por el volumen sintetizado.
2. ¿Qué te permiten hacer las etiquetas expresivas?
Respuesta: Controlar el habla desde dentro del texto: etiquetas en línea y envolventes para entonación, pausas y énfasis, que puedes combinar para lecturas naturales y dirigidas.
3. ¿Cuándo debes cambiar a TTS WebSocket?
Respuesta: Para tiempo real: el texto sale como un flujo y el audio regresa continuamente. Es la base de las canalizaciones LLM → TTS, donde la voz comienza antes de que finalice la generación.
4. ¿Cómo aseguras una integración en el navegador?
Respuesta: Nunca coloques la clave de API en el cliente: el navegador pasa por tu servidor o usa credenciales de corta duración, y gestionas los errores HTTP correctamente.
5. ¿Cuál es el aspecto de la canalización completa de producción?
Respuesta: Un LLM en streaming → segmentos de texto → TTS WebSocket → reproducción de audio. Cada eslabón transmite en flujo, por lo que la latencia percibida se desploma, y las buenas prácticas de este curso cierran el ciclo.
Etiquetas para expresividad, WebSocket para tiempo real, tu servidor para los secretos: tus aplicaciones están listas para hablar.