Integrering i webbläsare och bästa praxis
På denna sida
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:
| Codec | Chrome | Firefox | Safari | Edge | Rekommenderas |
|---|---|---|---|---|---|
| MP3 | Ja | Ja | Ja | Ja | Ja |
| WAV | Ja | Ja | Ja | Ja | Ja |
| Raw PCM | Nej | Nej | Nej | Nej | Nej |
| mulaw/alaw | Nej | Nej | Nej | Nej | Nej |
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.