Intégration navigateur et bonnes pratiques
Šiame puslapyje
Mis à jour le 3 novembre 2026, sur la base de la page Text to Speech de xAI : la validation côté serveur utilise la limite actuelle de 60 000 caractères par requête. Source : Text to Speech.
Déployer la synthèse vocale dans une application web
Intégrer la synthèse vocale (TTS) dans un navigateur présente des défis spécifiques : prise en charge des codecs, gestion de la mémoire, particularités de Safari et performances. Cette dernière leçon te donne tout ce dont tu as besoin pour une intégration de production robuste.
Prise en charge des codecs par le navigateur
Tous les navigateurs ne prennent pas en charge tous les formats audio. Choisis le codec adapté à ton audience :
| Codec | Chrome | Firefox | Safari | Edge | Recommandé |
|---|---|---|---|---|---|
| MP3 | Oui | Oui | Oui | Oui | Oui |
| WAV | Oui | Oui | Oui | Oui | Oui |
| PCM brut | Non | Non | Non | Non | Non |
| mulaw/alaw | Non | Non | Non | Non | Non |
La règle simple : utilise MP3 ou WAV dans le navigateur. PCM, mulaw et alaw sont conçus pour les applications serveur et la téléphonie, pas pour la lecture web.
// Demander du MP3 via l'API (via ton 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"
// Inutile de définir output_format : MP3 est la valeur par défaut
})
});
Le problème AudioContext sur Safari
Safari impose une restriction de sécurité : un AudioContext ne peut être créé que dans un gestionnaire d’événement utilisateur (clic, touche, tapotement). Si tu tentes de créer un AudioContext au chargement de la page, Safari le bloque silencieusement.
La mauvaise approche
// Ne fonctionne PAS sur Safari
const audioContext = new AudioContext(); // Bloqué !
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext est suspendu sur Safari...
}
La bonne approche
let audioContext = null;
// Créer l'AudioContext au premier clic de l'utilisateur
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Reprendre si suspendu
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);
});
Cette approche fonctionne sur tous les navigateurs, pas seulement Safari. C’est une bonne pratique universelle.
URLs Blob et fuites de mémoire
Lorsque tu crées des URLs Blob pour lire de l’audio, chaque URL consomme de la mémoire jusqu’à ce que tu la libères explicitement. Sans nettoyage, ton application fuira de la mémoire.
Le problème
// Chaque appel crée une URL Blob qui n'est jamais libérée
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Fuite de mémoire !
const audio = new Audio(url);
audio.play();
}
La solution
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);
// Libérer la mémoire lorsque la lecture se termine
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// La libérer aussi en cas d'erreur
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
Pour les applications qui génèrent beaucoup d’audio, conserve une liste des URLs actives et nettoie-les périodiquement :
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() {
// Libérer chaque URL active
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Bonnes pratiques de production
Limitation du débit (Rate limiting) côté backend
Protège ton backend contre les abus en limitant le nombre de requêtes par utilisateur :
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minute
max: 10, // 10 requêtes par minute par IP
message: { error: "Too many TTS requests" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy vers l'API xAI
});
Validation du texte
Valide et assainis le texte avant de l’envoyer à l’API :
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)");
}
// Supprimer les caractères de contrôle
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Mise en cache de l’audio
Pour les textes répétés (salutations, instructions standard), mets en cache l’audio généré :
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;
}
Pré-génération
Pour le contenu que tu connais à l’avance (e-learning, SVI), pré-génère les fichiers audio au moment de la construction plutôt qu’à la volée.
Svarbiausi punktai
- Utilise MP3 ou WAV dans le navigateur, jamais PCM/mulaw/alaw
- Sur Safari, crée l’AudioContext dans un gestionnaire d’événement utilisateur
- Libère toujours les URLs Blob avec
URL.revokeObjectURL()après utilisation - Ajoute une limitation du débit à ton proxy backend
- Valide et assainis le texte avant de l’envoyer à l’API
- Mets en cache l’audio pour les textes répétés afin d’économiser des appels API
- Pré-génère l’audio pour le contenu connu à l’avance
Vérifie ta compréhension
Synthèse vocale xAI : du premier appel au pipeline de streaming.
1. Comment fonctionne l'appel TTS de base ?
Réponse : Un POST vers /v1/tts avec le texte, la voix choisie (que tu peux lister via l’API) et les paramètres. La réponse est l’audio, facturé selon le volume synthétisé.
2. Que permettent de faire les balises expressives ?
Réponse : Contrôler la parole depuis le texte : balises inline et englobantes pour l’intonation, les pauses et l’emphase, que tu peux combiner pour des lectures naturelles et dirigées.
3. Quand dois-tu passer au WebSocket TTS ?
Réponse : Pour le temps réel : le texte part en flux et l’audio revient en continu. C’est la fondation des pipelines LLM → TTS, où la voix commence avant la fin de la génération.
4. Comment sécuriser une intégration navigateur ?
Réponse : Ne mets jamais la clé API dans le client : le navigateur passe par ton serveur ou utilise des identifiants à courte durée de vie, et tu gères correctement les erreurs HTTP.
5. À quoi ressemble le pipeline de production complet ?
Réponse : Un streaming LLM → segments de texte → WebSocket TTS → lecture audio. Chaque lien est en flux, donc la latence perçue s’effondre, et les bonnes pratiques de ce cours bouclent la boucle.
Des balises pour l’expressivité, WebSocket pour le temps réel, ton serveur pour les secrets : tes applications sont prêtes à parler.