Génération de synthèse vocale

L'API Gemini peut transformer une entrée de texte en contenu audio à un ou plusieurs intervenants à l'aide des fonctionnalités de génération de synthèse vocale (TTS) de Gemini. La génération de synthèse vocale est contrôlable, ce qui signifie que vous pouvez combiner des métadonnées de tour de parole structurées (speech_metadata) et des balises vocales intégrées pour guider le style, l'accent, le rythme et le ton de l'audio.

La fonctionnalité TTS diffère de la génération de voix fournie par l'API Live, qui est conçue pour les entrées et sorties audio et multimodales interactives et non structurées. Alors que l'API Live excelle dans les contextes conversationnels dynamiques, la synthèse vocale via l'API Gemini est conçue pour les scénarios qui nécessitent une récitation exacte du texte avec un contrôle précis du style et du son, comme la génération de podcasts ou de livres audio.

Ce guide vous explique comment générer des contenus audio à un ou plusieurs locuteurs à partir de texte à l'aide de Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) et de Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts).

Avant de commencer

Assurez-vous d'utiliser un modèle Gemini TTS listé dans la section Modèles compatibles. Pour obtenir des résultats optimaux, consultez Quand utiliser quel modèle afin de sélectionner le modèle le mieux adapté à votre charge de travail.

Il peut être utile de tester les modèles TTS Gemini dans AI Studio avant de commencer à créer.

TTS à locuteur unique

Pour convertir du texte en audio à un seul locuteur avec les modèles Gemini 3.8 TTS, transmettez la transcription textuelle dans parts[].text, associez un style au niveau du tour de parole dans parts[].speech_metadata et configurez votre voix dans speechConfig.voiceConfig. Vous pouvez transmettre un nom de voix prédéfini, un ID de bibliothèque de voix étendue, un ID de conception de voix personnalisé (voice_...) ou un ID de réplication vocale (voice_... ou voicekey_... sans état facultatif).

Cet exemple enregistre la sortie audio du modèle dans un fichier WAV :

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "voice_config": {"voice": "Kore"}
        },
    },
)

data = response.candidates[0].content.parts[0].inline_data.data
with open("out.wav", "wb") as f:
    f.write(data)

import {GoogleGenAI} from '@google/genai';
import * as fs from 'node:fs';

async function main() {
   const ai = new GoogleGenAI({});

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.wav', audioBuffer);
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode > out.wav

TTS multi-locuteur

Pour un dialogue entre plusieurs locuteurs, configurez deux locuteurs dans multiSpeakerVoiceConfig.speakerVoiceConfigs à l'aide de prebuiltVoiceConfig et transmettez chaque tour de dialogue en tant que part distinct avec speech_metadata spécifiant à la fois speaker et style facultatif au niveau du tour :

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [
            {
                "text": "How's it going today Jane?",
                "speech_metadata": {
                    "speaker": "Joe",
                    "style": "cheerful and friendly",
                },
            },
            {
                "text": "Not too bad, how about you? Ready to test these new voices?",
                "speech_metadata": {
                    "speaker": "Jane",
                    "style": "calm and relaxed",
                },
            },
        ],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "multi_speaker_voice_config": {
                "speaker_voice_configs": [
                    {
                        "speaker": "Joe",
                        "voice_config": {
                            "prebuilt_voice_config": {"voice_name": "Puck"}
                        },
                    },
                    {
                        "speaker": "Jane",
                        "voice_config": {
                            "prebuilt_voice_config": {"voice_name": "Kore"}
                        },
                    },
                ]
            }
        },
    },
)

data = response.candidates[0].content.parts[0].inline_data.data
with open("out.wav", "wb") as f:
    f.write(data)

import {GoogleGenAI} from '@google/genai';
import * as fs from 'node:fs';

async function main() {
   const ai = new GoogleGenAI({});

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [
            {
               text: "How's it going today Jane?",
               speechMetadata: {
                  speaker: 'Joe',
                  style: 'cheerful and friendly',
               },
            },
            {
               text: 'Not too bad, how about you? Ready to test these new voices?',
               speechMetadata: {
                  speaker: 'Jane',
                  style: 'calm and relaxed',
               },
            },
         ],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            multiSpeakerVoiceConfig: {
               speakerVoiceConfigs: [
                  {
                     speaker: 'Joe',
                     voiceConfig: {
                        prebuiltVoiceConfig: { voiceName: 'Puck' },
                     },
                  },
                  {
                     speaker: 'Jane',
                     voiceConfig: {
                        prebuiltVoiceConfig: { voiceName: 'Kore' },
                     },
                  },
               ],
            },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.wav', audioBuffer);
}

await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        {
          "text": "How'\''s it going today Jane?",
          "speech_metadata": {
            "speaker": "Joe",
            "style": "cheerful and friendly"
          }
        },
        {
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "speech_metadata": {
            "speaker": "Jane",
            "style": "calm and relaxed"
          }
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {
              "speaker": "Joe",
              "voiceConfig": {
                "prebuiltVoiceConfig": { "voiceName": "Puck" }
              }
            },
            {
              "speaker": "Jane",
              "voiceConfig": {
                "prebuiltVoiceConfig": { "voiceName": "Kore" }
              }
            }
          ]
        }
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
      base64 --decode > out.wav

Contrôler le style de parole avec des métadonnées et des tags

Gemini 3.8 TTS traite le champ text strictement comme une transcription mot à mot. Pour contrôler la diffusion sans que les indications scéniques soient lues à voix haute, séparez vos instructions par portée :

• Diffusion soutenue au niveau du tour de parole (speech_metadata.style) : placez les émotions, le style de diffusion, la prosodie, le rythme et le volume qui s'appliquent à l'ensemble d'un tour de parole dans speech_metadata.style (par exemple, "style": "whispered urgently", "style": "out of breath" ou "style": "warm and enthusiastic").
• Événements ponctuels (balises intégrées) : placez des pauses ou des sons vocaux non verbaux momentanés directement dans la transcription à l'aide de crochets (par exemple, "Wait... <short pause> did you hear that? <sigh>" ou "Excuse me <cough> as I was saying...").

Pour connaître toutes les bonnes pratiques, consultez le guide sur les prompts.

Options vocales

Gemini 3.8 TTS permet de sélectionner ou de créer des voix de quatre manières :

1. Voix Studio prédéfinies : 30 voix sélectionnées sont listées dans le tableau suivant.
2. Bibliothèque de voix étendue : des centaines de voix supplémentaires dans différentes langues, accents et archétypes de personnages, accessibles via client.voices.list() (GET /v1beta/voices).
3. Conception de voix : générez une personnalité vocale personnalisée à partir d'une description en langage naturel dans Google AI Studio ou à l'aide de POST /v1beta/voices (type="prompted", qui renvoie un ID voice_... persistant et un aperçu WAV sample_audio dans CreateVoice et GetVoice).
4. Réplication de voix : répliquez la voix d'un locuteur à partir d'un contenu audio de référence et de consentement dans Google AI Studio ou à l'aide de POST /v1beta/voices (type="replicated", store=True persistant par défaut ou store=False sans état facultatif).

Limites et TTL de la voix personnalisée

* Extension de la durée de vie : la période de conservation d'un an est réinitialisée chaque fois que la voix est utilisée activement (soit pour synthétiser la parole, soit comme voix de base pour un remix). Les voix sans activité pendant un an sont automatiquement supprimées.

Voix prédéfinies

Bibliothèque de voix étendue et filtrage

En plus des 30 voix de studio présentées dans le tableau précédent, la bibliothèque vocale étendue propose des centaines de voix supplémentaires dans différentes langues, avec des accents régionaux, des personnages et des domaines variés. Vous pouvez parcourir, filtrer et écouter l'intégralité de la bibliothèque de voix de manière interactive dans Google AI Studio, ou l'interroger de manière programmatique à l'aide de client.voices.list() (GET /v1beta/voices, à l'aide de google-genai 2.25.0+ / @google/genai 2.24.0+).

ListVoices renvoie vos voix stockées personnalisées (de la plus récente à la plus ancienne), suivies des voix du catalogue prédéfini correspondant à vos critères de filtrage. Lorsque plusieurs valeurs sont transmises pour un filtre de liste, les voix correspondant à n'importe quelle valeur de ce filtre sont renvoyées (OR), tandis que les paramètres de filtre distincts sont combinés avec AND :

from google import genai

client = genai.Client()

# Filter the Voice Library by language, gender, pitch, domain context, and keyword
response = client.voices.list(
    language_code=["en-US", "en-GB"],
    gender=["female"],
    pitch=["medium", "low"],
    contexts=["Audiobook", "Conversational"],
    type_=["prebuilt"],
    search="warm",
    page_size=50,
)

for voice in response.voices or []:
    print(
        f"{voice.id} | {voice.display_name} ({voice.language_code},"
        f" {voice.accent}, {voice.gender}, pitch={voice.pitch}):"
        f" {voice.description}"
    )

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI();

// Filter the Voice Library by language, gender, pitch, domain context, and keyword
const response = await ai.voices.list({
  language_code: ["en-US", "en-GB"],
  gender: ["female"],
  pitch: ["medium", "low"],
  contexts: ["Audiobook", "Conversational"],
  type: ["prebuilt"],
  search: "warm",
  page_size: 50,
});

for (const voice of response.voices ?? []) {
  console.log(
    `${voice.id} | ${voice.display_name} (${voice.language_code}, ${voice.accent}, ${voice.gender}, pitch=${voice.pitch}): ${voice.description}`
  );
}

curl -G "https://generativelanguage.googleapis.com/v1beta/voices" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  --data-urlencode "language_code=en-US" \
  --data-urlencode "language_code=en-GB" \
  --data-urlencode "gender=female" \
  --data-urlencode "pitch=medium" \
  --data-urlencode "context=Audiobook" \
  --data-urlencode "type=prebuilt" \
  --data-urlencode "search=warm" \
  --data-urlencode "page_size=50"

Langues disponibles

Les modèles TTS détectent automatiquement la langue de saisie. Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) est compatible avec plus de 130 langues, et Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) est compatible avec plus de 100 langues :

Modèles compatibles

Quand utiliser quel modèle

Les deux modèles Gemini 3.8 TTS partagent exactement le même schéma de l'API et le même format de requête, ce qui vous permet de passer de l'un à l'autre en modifiant un seul paramètre :

• Utilisez Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) lorsque la fidélité acoustique maximale, le jeu d'acteur nuancé et le contrôle expressif sont des priorités absolues. Il est idéal pour les travaux créatifs de qualité studio, les dialogues complexes entre plusieurs locuteurs, les tags d'éclats vocaux lourds, les prononciations difficiles, les dialectes régionaux ou minoritaires, et les narrations longues nécessitant une stabilité vocale et une tonalité de pièce solides.
• Utilisez Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) comme solution de remplacement rapide et économique pour gemini-3.1-flash-tts-preview. Il est optimisé pour la production en masse à grand volume, les cascades d'agents vocaux conversationnels, les fonctionnalités de lecture à voix haute, la réplication vocale fiable et la parole quotidienne à un seul locuteur dans les principales langues.

Guide de migration

Lorsque vous passez d'anciens modèles en version preview (gemini-3.1-flash-tts-preview ou gemini-2.5-pro-preview-tts) à Gemini 3.8 TTS (gemini-3.8-flash-tts ou gemini-3.8-flash-lite-tts), tenez compte de ces cinq changements clés :

1. Séparer le style de la transcription : déplacez les instructions de jeu, de ton, de prosodie et de rythme (comme "whispering", "out of breath" ou "speaking slowly") du texte brut vers speech_metadata.style. Conservez text strictement comme transcription mot à mot, en ajoutant des tags vocaux intégrés.
2. Concevez des personas en amont avec Voice Design : remplacez les blocs "Audio Profile" ou "Director's Notes" de plusieurs paragraphes par une voix personnalisée créée dans Voice Design, puis transmettez cet ID voice_... via vos requêtes TTS avec des chaînes style minimales ou vides.
3. Utilisez des tours de dialogue structurés : pour les dialogues à plusieurs locuteurs, transmettez un part par tour de locuteur avec speech_metadata.speaker au lieu d'intégrer des préfixes Speaker: ... dans un seul bloc de texte.
4. Utilisez des crochets pour les tags vocaux intégrés : utilisez des crochets (<laugh>, <sigh>, <cough>, <breath>, <short pause>) pour les vocalisations humaines et les pauses ponctuelles. Évitez les tags d'effets sonores non vocaux (comme les applaudissements ou les bruits sourds).
5. Prendre en compte la sortie WAV (AUDIO_WAV) par défaut sur les requêtes unaires : contrairement à gemini-3.1-flash-tts-preview (qui renvoyait par défaut un PCM brut sans en-tête AUDIO_L16), les modèles Gemini 3.8 TTS renvoient un fichier audio WAV (AUDIO_WAV) complet avec un en-tête RIFF (24 kHz, mono, PCM 16 bits) sur les requêtes unaires :
   • Si votre code encapsulait auparavant des octets PCM bruts dans un en-tête WAV (par exemple, à l'aide du module wave de Python ou du package wav de Node), supprimez l'encapsuleur d'en-tête manuel et écrivez les octets audio décodés directement dans un fichier .wav.
   • Si votre pipeline existant nécessite des données audio PCM brutes, mu-law ou A-law sans en-tête, définissez explicitement generationConfig.responseFormat.audio.mimeType sur "AUDIO_L16", "AUDIO_MULAW" ou "AUDIO_ALAW" à l'aide de l'API REST (par exemple, {"responseFormat": {"audio": {"mimeType": "AUDIO_L16"}}} dans generateContent ; les remplacements responseFormat personnalisés sur generateContent sont compatibles avec l'API REST, tandis que la compatibilité des SDK Python et SDK JavaScript pour response_format sur GenerateContentConfig est en attente, ou utilisez {"response_format": {"type": "audio", "mime_type": "audio/l16"}} dans l'API Interactions). Consultez Formats de sortie audio.

Guide sur les prompts

Les modèles Gemini 3.8 TTS traitent le texte d'entrée strictement comme une transcription textuelle. Contrairement aux modèles d'aperçu précédents où les indications scéniques étaient intégrées en texte brut, Gemini 3.8 TTS sépare les indications de niveau tour soutenues (speech_metadata) des tags vocaux intégrés ponctuels.

Champ de style et balises intégrées

Répartissez vos instructions de performances par portée :

• Élocution au niveau du tour de parole (speech_metadata.style) : placez les attributs d'élocution soutenue (comme l'émotion, la prosodie, le rythme général ou le style d'élocution, par exemple "whispering", "out of breath", "muttering" ou "sarcastic") dans le champ style de speech_metadata. Pour créer un personnage et une performance stables d'un tour à l'autre, concevez le personnage en amont dans Conception de la voix et n'utilisez style que pour les ajustements facultatifs au niveau du tour.
• Événements ponctuels (balises intégrées) : insérez des bruits vocaux momentanés non parlés, des respirations ou des pauses dans la transcription à l'aide de crochets (<cough>, <breath>, <sigh>, <short pause>). Utilisez des crochets (<...>) pour une qualité audio optimale et tenez-vous-en aux vocalisations humaines plutôt qu'aux effets sonores non vocaux.

Rythme et pauses

Vous pouvez contrôler le rythme et le silence à trois niveaux de précision :

• Ponctuation et points de suspension : utilisez des virgules, des tirets (--) et des points de suspension (...) pour imiter les hésitations naturelles d'une conversation.
• Balises de pause intégrées : insérez <short pause> ou <long pause> aux endroits précis du script où l'orateur doit faire une pause : text Hold on, let me think... <short pause> Alright, I've got it.
• Rythme au niveau du tour de parole : définissez "style": "speaking rapidly" ou "style": "speaking slowly" dans speech_metadata pour contrôler le débit de parole pour l'ensemble du tour de parole.

Prosodie et ton

Utilisez speech_metadata.style pour contrôler la prosodie, la hauteur et l'inflexion de la voix tout au long d'un tour de parole (par exemple, "style": "high pitch, cheerful and excited inflection" ou "style": "monotone and flat"). Si l'émotion ou la prosodie changent au milieu du dialogue, divisez le script en tours de parole distincts avec des valeurs style différentes pour chacun d'eux.

Mise en valeur

Mettez en majuscules certains mots de la transcription, en les combinant avec la ponctuation et les balises vocales intégrées, pour mettre l'accent sur les mots clés :

This is a VERY important point!
It was a VERY long day <sigh> ... nobody listens anymore.

Exclamations et sons non verbaux

Placez les vocalisations humaines non vocales entre crochets (<...>) à l'endroit exact où le son doit se produire. Voici quelques exemples de tags vocaux recommandés :

Réponses minimales et chevauchement des voix

Dans un dialogue à plusieurs locuteurs, placez les réactions des auditeurs entre des barres verticales (|reaction|) au cours du tour de parole d'un locuteur pour créer des réactions naturelles ou des chevauchements de parole sans avoir à créer un tour de parole distinct pour chaque réaction.

• Échanges brefs dans le canal de communication secondaire : insérez de brèves réactions de l'auditeur (|oh hmm|, |oh really?|, |absolutely|) dans le tour de parole de l'interlocuteur actif :
  • Tour 1 (Locuteur A) : "So the launch is Thursday |oh hmm| Are we actually ready?"
  • Tour 2 (Locuteur B) : "Ready enough |oh really?| The last blocker cleared this morning."
  • Tour 3 (Intervenant A) : "Then let's ship it |absolutely| and watch the dashboards."
• Chevauchement et entrelacement de la parole : utilisez plusieurs segments de barre verticale pour simuler la parole simultanée ou entrelacée entre deux locuteurs (fonctionne mieux avec gemini-3.8-flash-tts) :
  • Compte à rebours/refrain simultanés : "Let's surprise him on three |ok| ready?" suivi de "one. two. three. |happy| happy |birthday| birthday!"
  • Chevauchement complet des intervenants : "Hello |oh| there |my| it |goodness| must |gracious| be |would| almost |you| time |look| for |at that| dinner"

Cohérence entre les générations et erreurs à éviter

Suivez ces consignes pour que l'identité vocale reste stable d'un tour de parole à l'autre :

• Concevez des personas en amont dans la conception vocale au lieu d'utiliser de longs blocs de style : Les longs paragraphes "Audio Profile" et les listes à puces "Director's Notes" hérités des modèles précédents sont la cause la plus fréquente de dérive vocale. Utilisez cette même intuition créative en amont dans la conception de la voix pour générer un persona voice_... personnalisé persistant, puis transmettez cet ID de voix via vos appels TTS.
• S'appuyer sur la référence vocale pour la stabilité (omettre les méta-instructions) : les modèles TTS Gemini 3.8 sont entraînés pour s'ancrer d'abord sur la référence audio. N'incluez pas d'instructions demandant au modèle de maintenir la voix stable (comme "do not switch speaker identity" ou "maintain identical timbre"), car un texte de prompt supplémentaire augmente la dérive. Supprimez les instructions de style inutiles et laissez le modèle varier naturellement autour du point stable fourni par la référence vocale.
• N'essayez pas de modifier les caractéristiques immuables du locuteur dans style : évitez d'indiquer l'âge, le genre, les noms ou les changements d'accent permanents dans speech_metadata.style. Choisissez plutôt une voix régionale dans la bibliothèque de voix étendue ou créez-en une avec la conception de voix.

Workflow recommandé

1. Créez le personnage une seule fois : créez votre personnage dans Conception de voix ou sélectionnez une voix régionale dans la bibliothèque vocale étendue qui correspond à votre langue cible et à votre persona.
2. Rédigez des transcriptions vocales naturelles avec des disfluences : pour un maximum de naturel, rédigez le text comme une transcription vocale réelle, y compris les disfluences et les hésitations naturelles de la conversation (par exemple, "Oh uh yeah I think... hm, so that's interesting").
3. Testez d'abord la synthèse vocale simple : synthétisez d'abord votre transcription avec un champ style vide. La plupart des requêtes ne nécessitent aucune instruction style.
4. N'ajoutez des requêtes style courtes que pour les ajustements : n'ajoutez une chaîne style concise (telle que "casual, friendly" ou "muttering, then reassuring") que pour les tours qui nécessitent un ajustement de diffusion spécifique, et réutilisez cette chaîne courte exacte pour les tours lorsque vous souhaitez une base de référence cohérente.

Dialogue multitours et agents vocaux

Lorsque vous créez des agents vocaux conversationnels en temps réel ou des applications multitours :

• Effectuez un appel TTS par tour à mesure que les fragments de texte du LLM arrivent.
• Laissez le voice configuré (voice_... prédéfini, conçu ou répliqué voice_... / voicekey_...) porter l'identité de l'interlocuteur à travers les tours de parole. N'envoyez jamais de persona de personnage long à chaque tour de parole.
• Laissez le champ style par tour vide ou envoyez une chaîne constante courte (telle que "casual, friendly") pour l'ensemble de la conversation.
• Divisez les longues réponses des agents en tours plus courts au lieu d'utiliser des invites de style plus fortes.

Génération de voix en streaming

Vous pouvez diffuser l'audio généré au fur et à mesure de sa synthèse par le modèle. Contrairement aux requêtes unaires (qui renvoient un fichier WAV complet avec un en-tête RIFF), les requêtes de streaming renvoient par défaut des blocs bruts de PCM linéaire little-endian signé 16 bits sans en-tête (AUDIO_L16 / audio/L16;codec=pcm;rate=24000, 24 kHz, mono). Les blocs audio peuvent ainsi être lus ou concaténés en continu sans en-têtes de conteneur :

from google import genai

client = genai.Client()

response_stream = client.models.generate_content_stream(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "voice_config": {"voice": "Kore"}
        },
    },
)

for chunk in response_stream:
    try:
        data = chunk.candidates[0].content.parts[0].inline_data.data
        # data contains raw PCM bytes (24kHz, 1-channel, 16-bit)
    except (IndexError, AttributeError):
        pass

import {GoogleGenAI} from '@google/genai';

async function main() {
   const ai = new GoogleGenAI({});

   const responseStream = await ai.models.generateContentStream({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   for await (const chunk of responseStream) {
      const data = chunk.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
      if (data) {
         const audioBuffer = Buffer.from(data, 'base64');
         // Process the audio buffer
      }
   }
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:streamGenerateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }'

Formats de sortie audio

Les modèles TTS Gemini 3.8 utilisent différents formats audio par défaut selon que la requête est unaire ou en streaming :

• Requêtes unaires (models.generate_content) : renvoient un fichier audio WAV (AUDIO_WAV) complet avec un en-tête RIFF (PCM 16 bits little-endian signé, mono, 24 kHz). Vous pouvez écrire les octets audio décodés directement dans un fichier .wav sans ajouter manuellement de conteneur WAV.
• Requêtes de streaming (models.generate_content_stream / streamGenerateContent) : renvoient par défaut des blocs PCM linéaire brut sans en-tête (AUDIO_L16) (PCM 24 kHz, mono, 16 bits signé little-endian). Les blocs peuvent ainsi être diffusés en streaming ou concaténés en continu sans en-tête de conteneur sur chaque bloc.

Vous pouvez remplacer l'encodage et le taux d'échantillonnage de l'audio de sortie à l'aide de generationConfig.responseFormat.audio :

Vous pouvez également spécifier sampleRate (par exemple, 24000, 16000 ou 8000 Hz ; la valeur par défaut est 24000 Hz).

L'exemple REST suivant demande un PCM 16 bits brut sans en-tête (AUDIO_L16) à 24 kHz :

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "responseFormat": {
            "audio": {
              "mimeType": "AUDIO_L16",
              "sampleRate": 24000
            }
          },
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode > out.pcm

Limites

• Les modèles TTS acceptent les entrées textuelles uniquement et génèrent des sorties audio uniquement.
• La génération multilocuteur à requête unique (multiSpeakerVoiceConfig) est compatible avec un maximum de deux locuteurs utilisant des voix prédéfinies. Pour combiner des voix personnalisées (voice_...) ou répliquées (voice_... / voicekey_...) dans un dialogue à plusieurs personnages, synthétisez le tour de parole de chaque locuteur individuellement. Étant donné que les requêtes unaires renvoient audio/wav avec un en-tête RIFF de 44 octets par défaut, demandez le PCM brut (AUDIO_L16) ou supprimez l'en-tête WAV de chaque tour avant de concaténer les trames audio PCM de 24 kHz.
• Limites de stockage et TTL des voix personnalisées :
  • Voix avec état (store=True, guidées ou répliquées) : maximum de 200 voix par projet avec une valeur TTL d'un an (Time To Live).
  • Clés vocales sans état (store=False, voicekey_...) : TTL de 7 jours (time-to-live).
• Consultez la section Langues acceptées pour connaître les langues disponibles.

Étape suivante

• Créez des personas vocaux personnalisés à partir du langage naturel avec Voice Design.
• Répliquez la voix d'un locuteur existant dans Réplication vocale.
• Comparez les spécifications des modèles sur les pages des modèles Gemini 3.8 Flash TTS et Gemini 3.8 Flash-Lite TTS.
• Découvrez l'audio bidirectionnel interactif avec l'API Live.