Browserintegration og bedste praksis
På denne side
Opdateret 3. november 2026 baseret på xAI-siden Text to Speech: Validering på serversiden bruger den aktuelle grænse på 60.000 tegn pr. anmodning. Kilde: Text to Speech.
Implementér TTS i en webapp
Integrering af TTS i en browser indebærer specifikke udfordringer: codec-understøttelse, hukommelseshåndtering, Safari-egenskaber og ydeevne. Denne sidste lektion giver dig det, du skal bruge til en robust produktionsintegration.
Browser-understøttelse af codecs
Ikke alle browsere understøtter alle audio-formater. Vælg den rigtige codec til dit publikum:
| Codec | Chrome | Firefox | Safari | Edge | Anbefalet |
|---|---|---|---|---|---|
| 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 enkle regel: Brug MP3 eller WAV i browseren. PCM, mulaw og alaw er beregnet til serverapplikationer og telefoni, ikke til afspilning på webbet.
// Anmod om MP3 fra API'et (gennem din 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"
// Ingen grund til at sætte output_format: MP3 er standard
})
});
Safari AudioContext-problemet
Safari pålægger en sikkerhedsbegrænsning: En AudioContext kan kun oprettes inde i en brugerhændelseshandler (klik, tastetryk, tap). Hvis du forsøger at oprette en AudioContext, når siden indlæses, blokerer Safari det stille.
Den forkerte tilgang
// Virker IKKE i Safari
const audioContext = new AudioContext(); // Blokeret!
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext er suspenderet i Safari...
}
Den rigtige tilgang
let audioContext = null;
// Opret AudioContext ved brugerens første klik
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Genoptag hvis suspenderet
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);
});
Denne tilgang virker i alle browsere, ikke kun Safari. Det er en god universel praksis.
Blob-URL’er og hukommelseslækager
Når du opretter Blob-URL’er for at afspille lyd, bruger hver URL hukommelse, indtil du eksplicit frigiver den. Uden oprydning vil din app lække hukommelse.
Problemet
// Hvert kald opretter en Blob-URL, der aldrig frigives
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Hukommelseslækage!
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: "en" })
});
const blob = await response.blob();
const url = URL.createObjectURL(blob);
const audio = new Audio(url);
// Frigiv hukommelsen, når afspilningen slutter
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// Frigiv også ved fejl
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
For apps, der genererer meget lyd, skal du holde en liste over aktive URL’er og rydde dem op med jævne mellemrum:
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() {
// Frigiv hver aktiv URL
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Bedste praksis til produktion
Rate-begrænsning i backend
Beskyt din backend mod misbrug ved at begrænse antallet af anmodninger pr. bruger:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minut
max: 10, // 10 anmodninger pr. minut pr. IP
message: { error: "Too many TTS requests" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy til xAI API'et
});
Tekstvalidering
Valider og sanitér teksten, før du sender den til API’et:
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)");
}
// Fjern kontroltegn
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Audio-caching
For gentagne tekster (hilsener, standardinstruktioner) skal du cache det genererede lyd:
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;
}
Forudgenerering
For indhold, du kender på forhånd (f.eks. e-læring, IVR), skal du forudgenerere lydfilerne på byggetidspunktet i stedet for løbende.
Vigtige pointer
- Brug MP3 eller WAV i browseren, aldrig PCM/mulaw/alaw
- Opret AudioContext inde i en brugerhændelseshandler i Safari
- Frigiv altid Blob-URL’er med
URL.revokeObjectURL()efter brug - Tilføj rate-begrænsning til din backend-proxy
- Valider og sanitér tekst, før du sender den til API’et
- Cache lyden for gentagne tekster for at spare API-kald
- Forudgenerér lyd for indhold, du kender på forhånd
Tjek din forståelse
xAI talesyntese: fra det første kald til streaming-pipelinen.
1. Hvordan fungerer det grundlæggende TTS-kald?
Svar: En POST til /v1/tts med teksten, den valgte stemme (som du kan liste via API’et) og parametrene. Svaret er lyden, der faktureres efter det syntetiserede volumen.
2. Hvad giver udtryksfulde tags dig mulighed for at gøre?
Svar: Styr tale fra inden i teksten: inline- og wrapping-tags for intonation, pauser og betoning, som du kan kombinere til naturlig, styret oplæsning.
3. Hvornår skal du skifte til TTS WebSocket?
Svar: Til realtid: teksten sendes ud som en stream, og lyden kommer tilbage løbende. Det er fundamentet for LLM → TTS-pipeliner, hvor stemmen starter, før genereringen er afsluttet.
4. Hvordan sikrer du en browserintegration?
Svar: Sæt aldrig API-nøglen i klienten: browseren går gennem din server eller bruger kortlivede legitimationer, og du håndterer HTTP-fejl korrekt.
5. Hvordan ser den komplette produktionspipeline ud?
Svar: En streaming LLM → tekstsegmenter → TTS WebSocket → lydafspilning. Hvert led streamer, så den oplevede ventetid kollapser, og bedste praksis fra dette kursus lukker sløjfen.
Tags til udtryksfuldhed, WebSocket til realtid, din server til hemmeligheder: dine apps er klar til at tale.