Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Integrering i webbläsare och bästa praxis

Lektion 14 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Distribuera TTS i en webbapp
  2. Codec-stöd i webbläsaren
  3. Problemet med AudioContext i Safari
  4. Blob-URL:er och minnesläckor
  5. Bästa praxis för produktion
  6. Viktiga punkter
  7. Testa din förståelse

Uppdaterat den 3 november 2026, baserat på xAI:s sida Text to Speech: validering på serversidan använder den aktuella gränsen på 60 000 tecken per begäran. Källa: Text to Speech.

Distribuera TTS i en webbapp

Att integrera TTS i en webbläsare medför specifika utmaningar: codec-stöd, minneshantering, Safari-egenskaper och prestanda. Den här sista lektionen ger dig allt du behöver för en robust produktionsintegration.

Codec-stöd i webbläsaren

Inte alla webbläsare stöder alla ljudformat. Välj rätt codec för din målgrupp:

CodecChromeFirefoxSafariEdgeRekommenderas
MP3JaJaJaJaJa
WAVJaJaJaJaJa
Raw PCMNejNejNejNejNej
mulaw/alawNejNejNejNejNej

Den enkla regeln: använd MP3 eller WAV i webbläsaren. PCM, mulaw och alaw är avsedda för serverapplikationer och telefoni, inte för uppspelning på webben.

// Begär MP3 från API:et (via din backend)
const response = await fetch("/api/tts", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Hej från webbläsaren.",
    voice_id: "eve",
    language: "sv"
    // Inget behov av att ange output_format: MP3 är standard
  })
});

Problemet med AudioContext i Safari

Safari har en säkerhetsbegränsning: ett AudioContext kan bara skapas inuti en händelsehanterare för användarinteraktion (klick, tangenttryckning, tryck). Om du försöker skapa ett AudioContext när sidan laddas blockerar Safari det tyst.

Felaktigt tillvägagångssätt

// Fungerar INTE i Safari
const audioContext = new AudioContext(); // Blockerat!

async function playTTS() {
  const audio = await fetchTTS("Hej");
  // audioContext är pausat i Safari...
}

Rätt tillvägagångssätt

let audioContext = null;

// Skapa AudioContext vid användarens första klick
document.getElementById("play-btn").addEventListener("click", async () => {
  if (!audioContext) {
    audioContext = new AudioContext();
  }

  // Återuppta om pausat
  if (audioContext.state === "suspended") {
    await audioContext.resume();
  }

  const response = await fetch("/api/tts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      text: "Hej från Safari.",
      voice_id: "eve",
      language: "sv"
    })
  });

  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);
});

Detta tillvägagångssätt fungerar i alla webbläsare, inte bara Safari. Det är en god universell praxis.

Blob-URL:er och minnesläckor

När du skapar Blob-URL:er för att spela upp ljud använder varje URL minne tills du explicit frigör det. Utan rensning kommer din app att läcka minne.

Problemet

// Varje anrop skapar en Blob-URL som aldrig frigörs
async function playTTS(text) {
  const response = await fetch("/api/tts", { ... });
  const blob = await response.blob();
  const url = URL.createObjectURL(blob); // Minnesläcka!
  const audio = new Audio(url);
  audio.play();
}

Lösningen

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: "sv" })
  });

  const blob = await response.blob();
  const url = URL.createObjectURL(blob);
  const audio = new Audio(url);

  // Frigör minnet när uppspelningen slutar
  audio.addEventListener("ended", () => {
    URL.revokeObjectURL(url);
  });

  // Frigör också vid fel
  audio.addEventListener("error", () => {
    URL.revokeObjectURL(url);
  });

  audio.play();
}

För appar som genererar mycket ljud, håll en lista över aktiva URL:er och rensa dem regelbundet:

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: "sv" })
    });

    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() {
    // Frigör varje aktiv URL
    for (const url of this.activeUrls) {
      URL.revokeObjectURL(url);
    }
    this.activeUrls.clear();
  }
}

Bästa praxis för produktion

Hastighetsbegränsning i backend

Skydda din backend från missbruk genom att begränsa antalet begäran per användare:

const rateLimit = require("express-rate-limit");

const ttsLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 minut
  max: 10, // 10 begäran per minut per IP
  message: { error: "För många TTS-begäran" }
});

app.post("/api/tts", ttsLimiter, async (req, res) => {
  // ... proxy till xAI API
});

Textvalidering

Validera och sanera texten innan du skickar den till API:et:

function validateTTSInput(text) {
  if (!text || typeof text !== "string") {
    throw new Error("Text krävs");
  }
  if (text.length > 60000) {
    throw new Error("Texten är för lång (max 60 000 tecken)");
  }
  // Ta bort kontrolltecken
  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}

Ljudcachelagring

För återkommande texter (hälsningar, standardinstruktioner), cachelagra det genererade ljudet:

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;
}

För-generering

För innehåll du känner till i förväg (e-lärande, IVR), för-generera ljudfilerna vid byggtid istället för i realtid.

Viktiga punkter

  • Använd MP3 eller WAV i webbläsaren, aldrig PCM/mulaw/alaw
  • I Safari, skapa AudioContext inuti en händelsehanterare för användarinteraktion
  • Frigör alltid Blob-URL:er med URL.revokeObjectURL() efter användning
  • Lägg till hastighetsbegränsning i din backend-proxy
  • Validera och sanera text innan du skickar den till API:et
  • Cachelagra ljud för återkommande texter för att spara API-anrop
  • För-generera ljud för innehåll du känner till i förväg

Testa din förståelse

xAI:s talgenerering: från det första anropet till strömningspipelinen.

1. Hur fungerar det grundläggande TTS-anropet?

Svar: En POST till /v1/tts med texten, den valda rösten (som du kan lista via API:et) och parametrarna. Svaret är ljudet, som debiteras baserat på den syntetiserade volymen.

2. Vad låter uttrycksfulla taggar dig göra?

Svar: Styra talet inifrån texten: inline- och omslutande taggar för intonation, pauser och betoning, som du kan kombinera för naturliga, styrda uppläsningar.

3. När bör du byta till TTS WebSocket?

Svar: För realtid: texten skickas som en ström och ljudet kommer tillbaka kontinuerligt. Det är grunden för LLM → TTS-pipeliner, där rösten startar innan genereringen är klar.

4. Hur säkrar du en integration i webbläsaren?

Svar: Lägg aldrig API-nyckeln i klienten: webbläsaren går via din server eller använder kortlivade autentiseringsuppgifter, och du hanterar HTTP-fel korrekt.

5. Hur ser den kompletta produktionspipelinen ut?

Svar: En strömmande LLM → textsegment → TTS WebSocket → ljuduppspelning. Varje länk strömmar, så den upplevda latensen kollapsar, och bästa praxis från denna kurs sluter loopen.

Taggar för uttrycksfullhet, WebSocket för realtid, din server för hemligheter: dina appar är redo att tala.