Générer de la parole avec Gemini TTS

Les modèles de synthèse vocale (TTS) Gemini convertissent du texte en audio à un ou plusieurs locuteurs. Vous pouvez contrôler le style, l'accent, le rythme et le ton de l'audio à l'aide de métadonnées de tour de parole structurées (speech_metadata) et de balises vocales intégrées.

Cette page vous explique comment générer de la parole avec les modèles suivants à l'aide des méthodes generateContent et streamGenerateContent de l'API Gemini Enterprise :

Les modèles TTS sont adaptés à la récitation exacte de texte, avec un contrôle précis du style et du son, comme la narration, les livres audio et les réponses des agents vocaux. Pour des conversations interactives en temps réel avec entrée et sortie audio, utilisez plutôt l'API Gemini Live.

Si vous utilisez un modèle Gemini TTS antérieur, tel que gemini-3.1-flash-tts-preview, consultez le guide de migration.

Pour essayer la génération de voix à locuteur unique sans écrire de code, ouvrez Gemini 3.8 Flash TTS dans Agent Studio :

Essayer Gemini 3.8 TTS dans Agent Studio

Modèles compatibles

Modèle Locuteur unique Multi-speaker Streaming Conception vocale (preview) Réplication vocale (preview)
Gemini 3.8 Flash TTS (gemini-3.8-flash-tts)
Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts)
Gemini 3.1 Flash TTS Preview (gemini-3.1-flash-tts-preview)
Gemini 2.5 Pro TTS (gemini-2.5-pro-tts)
Gemini 2.5 Flash TTS (gemini-2.5-flash-tts)

Les exemples et les fonctionnalités de cette page s'appliquent aux modèles TTS Gemini 3.8. Pour les modèles antérieurs, consultez Gemini-TTS dans la documentationGoogle Cloud Text-to-Speech.

Quand utiliser quel modèle

Les deux modèles Gemini 3.8 TTS partagent le même schéma de requête et le même format de prompt. Vous pouvez donc passer de l'un à l'autre en modifiant l'ID du modèle :

  • Utilisez Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) lorsque la fidélité acoustique, le jeu d'acteur nuancé et le contrôle expressif sont la priorité absolue. Il convient aux travaux de création de qualité studio, aux dialogues complexes impliquant plusieurs locuteurs, aux balises d'éclats vocaux fréquentes, aux prononciations difficiles, aux dialectes régionaux ou minoritaires, et aux narrations longues qui nécessitent une voix et un ton stables.
  • Utilisez Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) pour des charges de travail de production rapides et économiques. Il s'agit du remplacement recommandé pour gemini-3.1-flash-tts-preview. Il convient à la production par lot de volumes élevés, aux cascades d'agents vocaux conversationnels, aux fonctionnalités de lecture à voix haute, à la réplication vocale et à la synthèse vocale quotidienne d'un seul locuteur dans les principales langues.

Avant de commencer

  1. Configurez un projet et activez l'API Gemini Enterprise.
  2. Configurez les identifiants par défaut de l'application pour votre environnement de développement.

  3. Pour utiliser les exemples Python, installez la version 2.33.0 ou ultérieure du SDK Google Gen AI :

    pip install --upgrade "google-genai>=2.33.0"

Emplacements et points de terminaison régionaux disponibles

Les modèles TTS Gemini 3.8 sont disponibles dans l'emplacement global et dans les emplacements multirégionaux us et eu :

Emplacement Paramètre d'emplacement Point de terminaison
Monde global https://aiplatform.googleapis.com
États-Unis (multirégional) us https://aiplatform.us.rep.googleapis.com
Union européenne (multirégional) eu https://aiplatform.eu.rep.googleapis.com

Pour réduire le délai avant le premier audio (TTFA) sur les requêtes de streaming, utilisez le point de terminaison multirégional us ou eu au lieu du point de terminaison global. Le point de terminaison global achemine les requêtes entre les régions du monde entier, ce qui peut augmenter la latence du réseau avant l'arrivée du premier fragment audio.

Pour diriger les requêtes vers un point de terminaison régional, définissez location="us" (ou location="eu") lors de l'initialisation du client dans le SDK, ou envoyez des requêtes au nom d'hôte multirégional correspondant (https://aiplatform.us.rep.googleapis.com ou https://aiplatform.eu.rep.googleapis.com) avec le chemin d'accès à l'emplacement correspondant dans l'URL REST :

Python

from google import genai

# Set location to 'us' or 'eu' for multi-region routing (or 'global' for global)
client = genai.Client(
    enterprise=True,
    project="PROJECT_ID",
    location="us",
)

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"}},
    },
)

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

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.us.rep.googleapis.com/v1/projects/PROJECT_ID/locations/us/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Have a wonderful day!",
        "speechMetadata": {"style": "cheerful and friendly"}
      }]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > out.wav

Synthèse vocale à locuteur unique

Pour convertir du texte en contenu audio à un seul locuteur, transmettez la transcription textuelle dans parts[].text, ajoutez un style facultatif au niveau du tour de parole dans parts[].speech_metadata et définissez la voix dans speechConfig.voiceConfig.voice. Le champ voice accepte un nom de voix prédéfinie, un ID de voix de la bibliothèque de voix étendue ou l'ID (voice_...) d'une voix conçue ou répliquée (ou une clé voicekey_... sans état facultative).

Par défaut, les requêtes unaires renvoient un fichier WAV complet (PCM 16 bits, 24 kHz, mono). Vous pouvez donc écrire les octets audio directement dans un fichier .wav. Les requêtes de streaming renvoient des fragments PCM bruts. Pour en savoir plus et découvrir d'autres encodages, consultez Formats de sortie audio.

Console

  1. Ouvrez Gemini 3.8 Flash TTS ou Gemini 3.8 Flash-Lite TTS dans Agent Studio.
  2. Dans le panneau des paramètres, choisissez une voix prédéfinie, une langue (ou conservez Détection automatique) et une description de style facultative (par exemple, cheerful and friendly).
  3. Saisissez la transcription à prononcer dans le champ du prompt, puis envoyez-la pour générer, lire ou télécharger l'audio WAV. Cliquez sur Obtenir le code pour exporter la requête en Python, JavaScript ou curl.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

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"}},
    },
)

# The SDK has already decoded the base64 audio, so inline_data.data is a
# complete WAV file by default.
with open("out.wav", "wb") as f:
    f.write(response.candidates[0].content.parts[0].inline_data.data)

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Have a wonderful day!",
        "speechMetadata": {"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 en streaming avec un seul locuteur

Pour recevoir l'audio pendant que le modèle le synthétise, utilisez la méthode streamGenerateContent. Les réponses en streaming renvoient des fragments PCM bruts de 16 bits sans en-tête (24 kHz, mono). Vous pouvez ainsi transmettre chaque fragment à un lecteur, un socket ou un autre pipeline audio dès qu'il arrive. Dans l'exemple Python suivant, la fonction emit_audio représente cette destination.

Pour réduire le TTFA, envoyez des requêtes de streaming au point de terminaison multirégional us ou eu au lieu du point de terminaison global (sauf si votre requête utilise une voix personnalisée, qui nécessite global).

Python

from google import genai

# Use 'us' or 'eu' for lower TTFA on streaming requests (or 'global' for custom voices)
client = genai.Client(enterprise=True, project="PROJECT_ID", location="us")

def emit_audio(pcm: bytes) -> None:
    """Sends a chunk of raw 16-bit PCM audio (24 kHz, mono) downstream."""
    # Replace with your audio destination, such as a player, a WebSocket,
    # or a telephony stream.
    print(f"Received {len(pcm)} bytes of audio")

response_stream = client.models.generate_content_stream(
    model="gemini-3.8-flash-lite-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:
    if not chunk.candidates or not chunk.candidates[0].content:
        continue
    for part in chunk.candidates[0].content.parts or []:
        if part.inline_data and part.inline_data.data:
            emit_audio(part.inline_data.data)

REST

curl -N -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.us.rep.googleapis.com/v1/projects/PROJECT_ID/locations/us/publishers/google/models/gemini-3.8-flash-lite-tts:streamGenerateContent?alt=sse" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Have a wonderful day!",
        "speechMetadata": {"style": "cheerful and friendly"}
      }]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | sed -n 's/^data: //p' \
    | jq -r '.candidates[0].content.parts[0].inlineData.data // empty' \
    | while read -r chunk; do echo "$chunk" | base64 --decode; done > streamed.pcm

Le fichier streamed.pcm contient un fichier audio PCM 16 bits brut à 24 kHz, mono.

Synthèse vocale multilocuteur

Pour un dialogue entre deux locuteurs, configurez les deux locuteurs dans speechConfig.multiSpeakerVoiceConfig.speakerVoiceConfigs. Ensuite, transmettez chaque tour en tant que part distinct, définissez speech_metadata.speaker sur l'un des noms d'intervenants configurés à chaque tour, puis ajoutez un style facultatif au niveau du tour.

Les requêtes multi-locuteurs nécessitent exactement deux locuteurs.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

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": {"voice": "Puck"}},
                    {"speaker": "Jane", "voice_config": {"voice": "Kore"}},
                ]
            }
        },
    },
)

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

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "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"}
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {"speaker": "Joe", "voiceConfig": {"voice": "Puck"}},
            {"speaker": "Jane", "voiceConfig": {"voice": "Kore"}}
          ]
        }
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > dialogue.wav

TTS en streaming avec plusieurs locuteurs

Les requêtes avec plusieurs locuteurs sont également compatibles avec le streaming. Utilisez la même requête que dans Synthèse vocale pour plusieurs locuteurs avec la méthode streamGenerateContent, et utilisez le point de terminaison multirégional us ou eu pour réduire le TTFA.

Python

from google import genai

# Use 'us' or 'eu' for lower TTFA on streaming requests
client = genai.Client(enterprise=True, project="PROJECT_ID", location="us")

def emit_audio(pcm: bytes) -> None:
    """Sends a chunk of raw 16-bit PCM audio (24 kHz, mono) downstream."""
    # Replace with your audio destination, such as a player, a WebSocket,
    # or a telephony stream.
    print(f"Received {len(pcm)} bytes of audio")

response_stream = client.models.generate_content_stream(
    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": {"voice": "Puck"}},
                    {"speaker": "Jane", "voice_config": {"voice": "Kore"}},
                ]
            }
        },
    },
)

for chunk in response_stream:
    if not chunk.candidates or not chunk.candidates[0].content:
        continue
    for part in chunk.candidates[0].content.parts or []:
        if part.inline_data and part.inline_data.data:
            emit_audio(part.inline_data.data)

REST

curl -N -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.us.rep.googleapis.com/v1/projects/PROJECT_ID/locations/us/publishers/google/models/gemini-3.8-flash-tts:streamGenerateContent?alt=sse" \
  -d '{
    "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"}
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {"speaker": "Joe", "voiceConfig": {"voice": "Puck"}},
            {"speaker": "Jane", "voiceConfig": {"voice": "Kore"}}
          ]
        }
      }
    }
  }' | sed -n 's/^data: //p' \
    | jq -r '.candidates[0].content.parts[0].inlineData.data // empty' \
    | while read -r chunk; do echo "$chunk" | base64 --decode; done > dialogue_streamed.pcm

Le fichier dialogue_streamed.pcm contient un fichier audio PCM 16 bits brut à 24 kHz, mono.

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

Les modèles Gemini 3.8 TTS traitent le champ text comme une transcription textuelle. Les instructions écrites dans le texte, telles que "Say cheerfully: Hello!" ou "Speaker 1: Hello!", peuvent être lues à voix haute. Pour contrôler la diffusion, divisez vos instructions par champ d'application :

  • Diffusion soutenue au niveau du tour (speech_metadata.style) : placez l'émotion, le style de diffusion, la prosodie, le rythme et le volume qui s'appliquent à un tour entier 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 les sons vocaux non verbaux momentanés et les pauses dans la transcription entre crochets. Par exemple, "Wait... <short pause> did you hear that? <sigh>" ou "Excuse me <cough> as I was saying...".

Pour en savoir plus, consultez le guide des prompts.

Options vocales

Les modèles Gemini 3.8 TTS proposent quatre façons de sélectionner ou de créer des voix :

  1. Voix prédéfinies : 30 voix sélectionnées.
  2. Bibliothèque de voix étendue : plus de 2 000 voix prédéfinies sélectionnées dans différentes langues, accents régionaux et personas de personnages.
  3. Conception vocale (preview) : créez une voix personnalisée à partir d'une description en langage naturel avec la méthode create de l'API Voices (client.voices.create() dans le SDK Google Gen AI ou POST https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/voices). Définissez type sur VOICE_TYPE_PROMPTED et store sur true. La réponse renvoie un ID voice_... stocké et un échantillon de la voix.
  4. Réplication vocale (preview) : répliquez la voix d'un locuteur à partir d'un fichier audio de référence et de consentement avec la même méthode create. Définissez type sur VOICE_TYPE_REPLICATED. Avec store: true, la réponse renvoie un ID voice_... stocké. Avec store: false, il renvoie une clé voicekey_... sans état.

Limites et TTL des voix personnalisées

Type de voix Mode de stockage Gestion Expiration
Voix stockées (voice_..., conçues ou répliquées) store: true Méthodes list, get et delete de l'API Voices 1 an après la dernière utilisation
Clés de réplication vocale (voicekey_...) store: false Géré par votre application. Google ne conserve pas la clé. 7 jours après la création

La génération de voix avec une voix stockée redémarre sa période de conservation d'un an. Ainsi, une voix que vous utilisez régulièrement n'expire pas. Les requêtes de création de voix sont soumises à un quota par projet et par minute. Si vous le dépassez, la méthode create renvoie une erreur RESOURCE_EXHAUSTED. Pour en savoir plus, consultez Quotas et limites du système.

Stockage et conservation des données

Google stocke les entrées que vous fournissez lorsque vous créez une voix stockée, ainsi que les artefacts vocaux qui en découlent, en association avec le projetGoogle Cloud qui a créé la voix.

Lorsque vous créez une voix répliquée à partir de l'enregistrement d'un locuteur, les éléments suivants sont stockés :

  • Audio de référence : échantillon du locuteur dont la voix est répliquée.
  • Audio d'autorisation : l'intervenant lisant la déclaration d'autorisation requise.

Lorsque vous créez une voix conçue à l'aide d'une description textuelle d'une voix dans un prompt, les éléments suivants sont stockés :

  • Le prompt textuel que vous avez écrit pour décrire la voix.
  • L'audio vocal généré à partir de cette requête, que le modèle utilise comme référence pour la voix.

Une voix conçue ne dispose pas d'un fichier audio de consentement, car elle est générée à partir d'une description plutôt que d'un enregistrement d'une personne.

Les entrées vocales sont stockées pour que votre voix continue de fonctionner lors des mises à jour du modèle. Les artefacts vocaux sont régénérés à partir des entrées stockées lorsque le modèle sous-jacent est mis à jour. Si aucune entrée stockée n'est trouvée pour une voix, ses artefacts ne peuvent pas être régénérés et la voix cesse de fonctionner après une mise à jour du modèle. Vous devez ensuite recréer la voix.

Les entrées stockées ne sont utilisées que pour régénérer la voix lorsque les modèles sont mis à jour. Elles sont chiffrées au repos et isolées dans le projet qui a créé la voix.

Durée de conservation

Les voix et toutes les données stockées associées sont conservées pendant un an (365 jours) maximum à compter de la dernière fois que vous avez utilisé la voix pour synthétiser la voix. La période commence lorsque vous créez la voix et se réinitialise chaque fois que vous envoyez une requête de synthèse qui utilise la voix. Si une voix n'est pas utilisée pendant 365 jours, la voix, ses entrées stockées et ses artefacts dérivés sont supprimés.

Suppression par le client

Vous pouvez supprimer une voix à tout moment à l'aide de la méthode delete de l'API Voices. La suppression d'une voix entraîne la suppression de ses entrées stockées et de ses artefacts dérivés. La suppression du projet Google Cloud propriétaire d'une voix entraîne également la suppression de cette voix, conformément au processus standard de suppression de projet.

Voix prédéfinies

La liste suivante présente chaque nom de voix prédéfinie et sa caractéristique :

  • Achernar : Doux
  • Achird : amicale
  • Algenib : Gravelly
  • Algieba : fluide
  • Alnilam : affirmée
  • Aoede : joviale
  • Autonoé : joyeuse
  • Callirrhoe : facile à vivre
  • Charon : informative
  • Despina : douce
  • Encelade : voix chuchotée
  • Erinome : clair
  • Fenrir : nerveuse
  • Gacrux : mature
  • Japet : claire
  • Kore : ferme
  • Laomedeia : enjouée
  • Leda : jeune
  • Orus : ferme
  • Puck : Upbeat
  • Pulcherrima : franche
  • Rasalgethi : informative
  • Sadachbia : dynamique
  • Sadaltager : éclairée
  • Schedar : pair
  • Sulafat : chaud
  • Umbriel : décontractée
  • Vindemiatrix : agréable
  • Zephyr : joyeuse
  • Zubenelgenubi : décontractée

Bibliothèque de voix étendue

En plus des 30 voix prédéfinies, la bibliothèque de voix étendue propose plus de 2 000 voix prédéfinies sélectionnées dans différentes langues, accents régionaux, personnages et cas d'utilisation tels que les livres audio, les agents conversationnels et les actualités. Pour utiliser une voix de la bibliothèque, transmettez son ID dans speechConfig.voiceConfig.voice, de la même manière que vous transmettez un nom de voix prédéfinie.

Pour parcourir la bibliothèque, appelez la méthode list de l'API Voices (ListVoices). Elle renvoie les voix personnalisées stockées dans votre projet, suivies des voix prédéfinies et de la bibliothèque de voix étendue. Chaque voix de la bibliothèque inclut son id et ses métadonnées, telles que language_code, accent, gender, pitch, persona et description. Pour affiner les résultats, utilisez les filtres suivants :

  • type : source de la voix : prebuilt pour les voix prédéfinies et de la bibliothèque, prompted pour les voix conçues ou replicated pour les voix répliquées. Si vous transmettez plusieurs valeurs, la méthode renvoie les voix qui correspondent à l'une d'entre elles.
  • search : texte à mettre en correspondance, non sensible à la casse, avec le nom à afficher et la description de chaque voix.

L'exemple suivant recherche des voix de narrateur dans la bibliothèque :

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.voices.list(type_=["prebuilt"], search="narrator", page_size=50)
for voice in response.voices or []:
    print(voice.id, voice.language_code, voice.gender, voice.description)

REST

curl -G \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/voices \
  --data-urlencode "type=prebuilt" \
  --data-urlencode "search=narrator" \
  --data-urlencode "pageSize=50"

La méthode list renvoie jusqu'à 50 voix par page. Pour obtenir la page suivante, transmettez la valeur next_page_token de la réponse en tant que paramètre page_token.

Formats de sortie audio

L'encodage audio par défaut dépend de la méthode :

  • Les requêtes unaires (generateContent) renvoient un fichier WAV complet (audio/wav) avec un en-tête RIFF : PCM 16 bits, 24 kHz, mono.
  • Les requêtes de streaming (streamGenerateContent) renvoient des fragments PCM bruts signés 16 bits little-endian sans en-tête (audio/l16) à 24 kHz, mono.

Pour demander un autre encodage, définissez generationConfig.responseFormat sur un format audio. Les modèles TTS Gemini 3.8 sont compatibles avec les valeurs mimeType suivantes :

Valeur mimeType Format Description
AUDIO_WAV (valeur par défaut unaire) WAV (audio/wav) Fichier WAV complet avec un en-tête RIFF (PCM 16 bits, 24 kHz, mono).
AUDIO_L16 (par défaut pour le streaming) PCM linéaire (audio/l16) PCM 16 bits signé little-endian brut sans en-tête. Utilisez-le pour le streaming, les pipelines audio personnalisés ou la concaténation de clips multitours.
AUDIO_MULAW Loi μ (audio/mulaw) Audio compressé G.711 μ-law (8 kHz, mono), couramment utilisé dans la téléphonie nord-américaine et japonaise.
AUDIO_ALAW Loi A (audio/alaw) Audio compressé G.711 loi A (8 kHz, mono), couramment utilisé dans la téléphonie européenne et internationale.

Les modèles ignorent le champ sampleRate. La sortie PCM linéaire et WAV est de 24 kHz, et la sortie μ-law et A-law est de 8 kHz, quel que soit le taux dans la réponse mimeType. Rééchantillonnez la sortie sur le client si votre pipeline nécessite un taux d'échantillonnage différent.

L'exemple suivant demande une sortie μ-law pour un pipeline de téléphonie. Le SDK Google Gen AI pour Python n'expose pas responseFormat dans GenerateContentConfig. L'exemple Python le transmet donc dans le corps de la requête avec http_options.extra_body.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{"role": "user", "parts": [{"text": "Have a wonderful day!"}]}],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {"voice_config": {"voice": "Kore"}},
        "http_options": {
            "extra_body": {
                "generationConfig": {
                    "responseFormat": [{"audio": {"mimeType": "AUDIO_MULAW"}}]
                }
            }
        },
    },
)

# The response is headerless μ-law audio at 8 kHz, mono.
with open("out.mulaw", "wb") as f:
    f.write(response.candidates[0].content.parts[0].inline_data.data)

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "Have a wonderful day!"}]}],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "responseFormat": [{"audio": {"mimeType": "AUDIO_MULAW"}}],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > out.mulaw

Langues disponibles

Les modèles TTS Gemini 3.8 détectent automatiquement la langue d'entrée. Gemini 3.8 Flash TTS est compatible avec 132 langues, et Gemini 3.8 Flash-Lite TTS avec 103 langues :

Limites

  • Les modèles TTS n'acceptent que les entrées textuelles et ne renvoient que des sorties audio.
  • Les requêtes multi-locuteurs nécessitent exactement deux locuteurs. Pour combiner des voix conçues (voice_...) ou répliquées (voice_... ou voicekey_...) dans un dialogue à plusieurs personnages, ou pour utiliser plus de deux locuteurs, synthétisez le tour de chaque locuteur individuellement et concaténez l'audio. Demandez une sortie AUDIO_L16 pour chaque tour ou supprimez l'en-tête WAV de chaque extrait avant de les concaténer.
  • Les modèles sont disponibles dans les emplacements global, us et eu.
  • Les voix personnalisées appartenant à l'utilisateur (voix créées avec la conception vocale ou la réplication vocale) ne sont disponibles que dans l'emplacement global.
  • Les instructions système ne sont pas acceptées.
  • Vous ne pouvez pas définir le taux d'échantillonnage de sortie. Les sorties MP3 et Ogg Opus ne sont pas acceptées.

Étapes suivantes