Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Integratie in de browser en best practices

Les 14 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. TTS implementeren in een webapplicatie
  2. Ondersteuning van browsercodecs
  3. Het AudioContext-probleem in Safari
  4. Blob-URL’s en geheugenlekken
  5. Best practices voor productie
  6. Belangrijkste punten
  7. Test uw kennis

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:

CodecChromeFirefoxSafariEdgeAanbevolen
MP3JaJaJaJaJa
WAVJaJaJaJaJa
Raw PCMNeeNeeNeeNeeNee
mulaw/alawNeeNeeNeeNeeNee

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.