Integratie in de browser en best practices
Op deze pagina
Bijgewerkt op 3 november 2026, gebaseerd op de xAI-pagina Text to Speech: validatie aan de serverzijde hanteert de huidige limiet van 60.000 tekens per verzoek. Bron: Text to Speech.
TTS implementeren in een webapplicatie
Het integreren van TTS in een browser brengt specifieke uitdagingen met zich mee: codec-ondersteuning, geheugenbeheer, Safari-eigenaardigheden en prestaties. Deze laatste les biedt u alles wat u nodig heeft voor een robuuste productie-integratie.
Ondersteuning van browsercodecs
Niet elke browser ondersteunt elk audioformaat. Kies de juiste codec voor uw doelgroep:
| Codec | Chrome | Firefox | Safari | Edge | Aanbevolen |
|---|---|---|---|---|---|
| MP3 | Ja | Ja | Ja | Ja | Ja |
| WAV | Ja | Ja | Ja | Ja | Ja |
| Raw PCM | Nee | Nee | Nee | Nee | Nee |
| mulaw/alaw | Nee | Nee | Nee | Nee | Nee |
De simpele regel: gebruik MP3 of WAV in de browser. PCM, mulaw en alaw zijn bedoeld voor serverapplicaties en telefonie, niet voor weergave op het web.
// Vraag MP3 aan via de API (via uw backend)
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
text: "Hello from the browser.",
voice_id: "eve",
language: "en"
// Het is niet nodig output_format in te stellen: MP3 is de standaard
})
});
Het AudioContext-probleem in Safari
Safari legt een beveiligingsbeperking op: een AudioContext mag alleen worden gemaakt binnen een gebeurtenisafhandelaar van de gebruiker (klik, toetsaanslag, tap). Als u probeert een AudioContext te maken wanneer de pagina laadt, blokkeert Safari dit stilletjes.
De verkeerde aanpak
// Werkt NIET in Safari
const audioContext = new AudioContext(); // Geblokkeerd!
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext is onderbroken in Safari...
}
De juiste aanpak
let audioContext = null;
// Maak de AudioContext bij de eerste klik van de gebruiker
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Hervat indien onderbroken
if (audioContext.state === "suspended") {
await audioContext.resume();
}
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
text: "Hello from 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);
});
Deze aanpak werkt in elke browser, niet alleen in Safari. Het is een goede universele praktijk.
Blob-URL’s en geheugenlekken
Wanneer u Blob-URL’s maakt om audio af te spelen, gebruikt elke URL geheugen totdat u deze expliciet vrijgeeft. Zonder opschoning zal uw applicatie geheugen lekken.
Het probleem
// Elke aanroep maakt een Blob-URL die nooit wordt vrijgegeven
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Geheugenlek!
const audio = new Audio(url);
audio.play();
}
De oplossing
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);
// Geef het geheugen vrij wanneer het afspelen eindigt
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// Geef het ook vrij bij een fout
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
Voor applicaties die veel audio genereren, houdt u een lijst bij van actieve URL’s en ruimt u deze periodiek op:
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() {
// Geef elke actieve URL vrij
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Best practices voor productie
Rate limiting op de backend
Bescherm uw backend tegen misbruik door het aantal verzoeken per gebruiker te beperken:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minuut
max: 10, // 10 verzoeken per minuut per IP
message: { error: "Too many TTS requests" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy naar de xAI API
});
Tekstvalidatie
Valideer en sanitizeer de tekst voordat u deze naar de API verzendt:
function validateTTSInput(text) {
if (!text || typeof text !== "string") {
throw new Error("Text is required");
}
if (text.length > 60000) {
throw new Error("Text too long (60,000 characters max)");
}
// Verwijder besturingstekens
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Audio-caching
Voor herhaalde teksten (begroetingen, standaardinstructies) cacheert u de gegenereerde audio:
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;
}
Vooraf genereren
Voor content die u van tevoren kent (e-learning, IVR), genereert u de audiobestanden vooraf tijdens de build-fase in plaats van op het moment zelf.
Belangrijkste punten
- Gebruik MP3 of WAV in de browser, nooit PCM/mulaw/alaw
- Maak in Safari de AudioContext aan binnen een gebeurtenisafhandelaar van de gebruiker
- Geef Blob-URL’s altijd vrij met
URL.revokeObjectURL()na gebruik - Voeg rate limiting toe aan uw backend-proxy
- Valideer en sanitizeer tekst voordat u deze naar de API verzendt
- Cache de audio voor herhaalde teksten om API-aanroepen te besparen
- Genereer audio vooraf voor content die u van tevoren kent
Test uw kennis
xAI-spraaksynthese: van de eerste aanroep tot de streaming-pipeline.
1. Hoe werkt de basis TTS-aanroep?
Antwoord: Een POST naar /v1/tts met de tekst, de gekozen stem (die u via de API kunt opvragen) en de parameters. Het antwoord is de audio, gefactureerd op basis van het gesynthetiseerde volume.
2. Wat kunt u doen met expressieve tags?
Antwoord: Spraak sturen vanuit de tekst: inline en omhullende tags voor intonatie, pauzes en nadruk, die u kunt combineren voor natuurlijke, gestuurde voorleesbeurten.
3. Wanneer schakelt u over naar TTS WebSocket?
Antwoord: Voor real-time toepassingen: de tekst gaat als stream de deur uit en de audio komt continu binnen. Het is de basis van LLM → TTS-pipelines, waarbij de stem begint voordat de generatie is voltooid.
4. Hoe beveiligt u een browserintegratie?
Antwoord: Plaats de API-sleutel nooit in de client: de browser gaat via uw server of gebruikt kortstondige referenties, en u behandelt HTTP-fouten correct.
5. Hoe ziet de complete productiepipeline eruit?
Antwoord: Een streaming LLM → tekstsegmenten → TTS WebSocket → audio-afspelen. Elke schakel streamt, waardoor de waargenomen latentie instort, en de best practices uit deze cursus sluiten de cirkel.
Tags voor expressiviteit, WebSocket voor real-time, uw server voor geheimen: uw applicaties zijn klaar om te spreken.