Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Gemini-TTS

Essayer Gemini-TTS dans Agent Studio Essayer dans Colab Afficher le notebook sur GitHub

Gemini-TTS est la dernière évolution de notre technologie Cloud TTS. Elle va au-delà de la synthèse vocale naturelle et permet de contrôler de manière précise l'audio généré à l'aide de prompts textuels. Avec Gemini-TTS, vous pouvez synthétiser des discours à un ou plusieurs intervenants, qu'il s'agisse de courts extraits ou de longs récits, en dictant précisément le style, l'accent, le rythme, le ton et même les émotions exprimées, le tout à l'aide de prompts en langage naturel.

Modèles disponibles

Gemini-TTS inclut les modèles disponibles suivants :

Gemini 3.1 Flash TTS (preview)

ID du modèle	`gemini-3.1-flash-tts-preview`
Optimisé pour	Génération audio Cloud TTS à faible latence, contrôlable, à un ou plusieurs intervenants, pour les applications quotidiennes économiques
Modes d'entrée et de sortie	Entrée : texte Sortie : audio
Limites de jetons	Entrée : 8 192 Résultat : 16 384
Prise en charge du nombre d'intervenants	Locuteur unique, plusieurs locuteurs (dialogue)
Formats audio de sortie compatibles	Unaire : `LINEAR16` (par défaut), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` Streaming : `PCM` (par défaut), `ALAW`, `MULAW`, `OGG_OPUS`
Compatibilité avec les régions	Consultez Régions disponibles.
Options vocales	Consultez Options de voix.
Options vocales	Consultez Options de voix. Notez que toutes les voix de Gemini 3.1 Flash TTS sont en preview.
Options de consommation	Consultez Standard Paygo.
Exemple	model: "gemini-3.1-flash-tts-preview" prompt: "You are having a casual conversation with a friend. Say the following in a friendly and amused way." text: "[laughs] I did NOT expect that. [sigh] Can you believe it!" speaker: "Callirrhoe"

Gemini 2.5 Flash TTS

ID du modèle	`gemini-2.5-flash-tts`
Optimisé pour	Génération audio Cloud TTS à faible latence, contrôlable, à un ou plusieurs intervenants, pour les applications quotidiennes économiques
Modes d'entrée et de sortie	Entrée : texte Sortie : audio
Limites de jetons	Entrée : 8 192 Résultat : 16 384
Prise en charge du nombre d'intervenants	Un seul, plusieurs locuteurs
Formats audio de sortie compatibles	Unaire : `LINEAR16` (par défaut), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` Streaming : `PCM` (par défaut), `ALAW`, `MULAW`, `OGG_OPUS`
Compatibilité avec les régions	Consultez Régions disponibles.
Options vocales	Consultez Options de voix.
Langues disponibles	Consultez Langues disponibles.
Exemple	model: "gemini-2.5-flash-tts" prompt: "Say the following." text: "[extremely fast] Availability and terms may vary. Check our website or your local store for complete details and restrictions." speaker: "Kore"

Gemini 2.5 Flash-Lite TTS (preview)

ID du modèle	`gemini-2.5-flash-lite-preview-tts`
Optimisé pour	Génération audio Cloud TTS à faible latence, contrôlable et à un seul locuteur pour les applications quotidiennes économiques. Notez que ce modèle est en version preview.
Modes d'entrée et de sortie	Entrée : texte Sortie : audio
Limites de jetons	Entrée : 8 192 Résultat : 16 384
Prise en charge du nombre d'intervenants	Unique
Formats audio de sortie compatibles	Unaire : `LINEAR16` (par défaut), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` Streaming : `PCM` (par défaut), `ALAW`, `MULAW`, `OGG_OPUS`
Compatibilité avec les régions	Consultez Régions disponibles.
Options vocales	Consultez Options de voix.
Langues disponibles	Consultez Langues disponibles.
Exemple	model: "gemini-2.5-flash-lite-preview-tts" prompt: "Say the following in an elated way." text: "Congratulations on the recent achievements!" speaker: "Aoede"

Gemini 2.5 Pro TTS

ID du modèle	`gemini-2.5-pro-tts`
Optimisé pour	Contrôle élevé pour les workflows structurés tels que la génération de podcasts, les livres audio, le service client, etc.
Modes d'entrée et de sortie	Entrée : texte Sortie : audio
Limites de jetons	Entrée : 8 192 Résultat : 16 384
Prise en charge du nombre d'intervenants	Un seul, plusieurs locuteurs
Formats audio de sortie compatibles	Unaire : `LINEAR16` (par défaut), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` Streaming : `PCM` (par défaut), `ALAW`, `MULAW`, `OGG_OPUS`
Compatibilité avec les régions	Consultez Régions disponibles.
Options vocales	Consultez Options de voix.
Langues disponibles	Consultez Langues disponibles.
Exemple	model: "gemini-2.5-pro-tts" prompt: "You are having a casual conversation with a friend. Say the following in a friendly and amused way." text: "hahah I did NOT expect that. Can you believe it!" speaker: "Callirrhoe"

Paramètres supplémentaires

Voici d'autres commandes et fonctionnalités :

Conversation naturelle : les interactions vocales d'une qualité remarquable, l'expressivité plus appropriée et les modèles de rythme sont fournis avec une latence très faible pour vous permettre de converser de manière fluide.
Contrôle du style : à l'aide de prompts en langage naturel, vous pouvez adapter la diffusion au sein de la conversation en l'orientant pour qu'elle adopte des accents spécifiques et produise une gamme de tons et d'expressions, y compris un chuchotement.
Performances dynamiques : ces modèles peuvent donner vie au texte pour des lectures expressives de poésie, des bulletins d'information et des récits captivants. Elles peuvent également exprimer des émotions spécifiques et produire des accents sur demande.
Contrôle amélioré du rythme et de la prononciation : contrôler la vitesse de diffusion permet d'améliorer la précision de la prononciation, y compris pour des mots spécifiques.

Pour savoir comment choisir l'API appropriée pour utiliser ces voix dans votre application, consultez Choisir l'API appropriée.

Options vocales

Gemini-TTS propose un large éventail d'options vocales semblables à nos voix Chirp 3 HD existantes, chacune avec des caractéristiques distinctes :

Nom	Sexe	Démonstration
Achernar	Femme
Achird	Homme
Algenib	Homme
Algieba	Homme
Alnilam	Homme
Aoede	Femme
Autonoe	Femme
Callirrhoe	Femme
Charon	Homme
Despina	Femme
Encelade	Homme
Erinome	Femme
Fenrir	Homme
Gacrux	Femme
Iapetus	Homme
Kore	Femme
Laomedeia	Femme
Léda	Femme
Orus	Homme
Pulcherrima	Femme
Puck	Homme
Rasalgethi	Homme
Sadachbia	Homme
Sadaltager	Homme
Schedar	Homme
Sulafat	Femme
Umbriel	Homme
Vindemiatrix	Femme
Zephyr	Femme
Zubenelgenubi	Homme

Langues disponibles

Gemini-TTS est compatible avec les langues suivantes :

Langue	Code BCP-47	Disponibilité pour le lancement
Arabe (Égypte)	ar-EG	DG
Bengali (Bangladesh)	bn-BD	DG
Néerlandais (Pays-Bas)	nl-NL	DG
Anglais (Inde)	en-IN	DG
Anglais (États-Unis)	en-US	DG
Français (France)	fr-FR	DG
Allemand (Allemagne)	de-DE	DG
Hindi (Inde)	hi-IN	DG
Indonésien (Indonésie)	id-ID	DG
Italien (Italie)	it-IT	DG
Japonais (Japon)	ja-JP	DG
Coréen (Corée du Sud)	ko-KR	DG
Marathi (Inde)	mr-IN	DG
Polonais (Pologne)	pl-PL	DG
Portugais (Brésil)	pt-BR	DG
Roumain (Roumanie)	ro-RO	DG
Russe (Russie)	ru-RU	DG
Espagnol (Espagne)	es-ES	DG
Tamoul (Inde)	ta-IN	DG
Télougou (Inde)	te-IN	DG
Thaï (Thaïlande)	th-TH	DG
Turc (Turquie)	tr-TR	DG
Ukrainien (Ukraine)	uk-UA	DG
Vietnamien (Viêt Nam)	vi-VN	DG
Afrikaans (Afrique du Sud)	af-ZA	Aperçu
Albanais (Albanie)	sq-AL	Aperçu
Amharique (Éthiopie)	am-ET	Aperçu
Arabe (monde)	ar-001	Aperçu
Arménien (Arménie)	hy-AM	Aperçu
Azéri (Azerbaïdjan)	az-AZ	Aperçu
Basque (Espagne)	eu-ES	Aperçu
Biélorusse (Biélorussie)	be-BY	Aperçu
Bulgare (Bulgarie)	bg-BG	Aperçu
Birman (Myanmar)	my-MM	Aperçu
Catalan (Espagne)	ca-ES	Aperçu
Cebuano (Philippines)	ceb-PH	Aperçu
Chinois mandarin (Chine)	cmn-CN	Aperçu
Chinois, mandarin (Taïwan)	cmn-tw	Aperçu
Croate (Croatie)	hr-HR	Aperçu
Tchèque (République tchèque)	cs-CZ	Aperçu
Danois (Danemark)	da-DK	Aperçu
Anglais (Australie)	en-AU	Aperçu
Anglais (Royaume-Uni)	en-GB	Aperçu
Estonien (Estonie)	et-EE	Aperçu
Philippin (Philippines)	fil-PH	Aperçu
Finnois (Finlande)	fi-FI	Aperçu
Français (Canada)	fr-CA	Aperçu
Galicien (Espagne)	gl-ES	Aperçu
Géorgien (Géorgie)	ka-GE	Aperçu
Grec (Grèce)	el-GR	Aperçu
Gujarati (Inde)	gu-IN	Aperçu
Créole haïtien (Haïti)	ht-HT	Aperçu
Hébreu (Israël)	he-IL	Aperçu
Hongrois (Hongrie)	hu-HU	Aperçu
Islandais (Islande)	is-IS	Aperçu
Javanais (Java)	jv-JV	Aperçu
Kannada (Inde)	kn-IN	Aperçu
Konkani (Inde)	kok-IN	Aperçu
Laotien (Laos)	lo-LA	Aperçu
Latin (Vatican)	la-VA	Aperçu
Letton (Lettonie)	lv-LV	Aperçu
Lituanien (Lituanie)	lt-LT	Aperçu
Luxembourgeois (Luxembourg)	lb-LU	Aperçu
Macédonien (Macédoine du Nord)	mk-MK	Aperçu
Maïthili (Inde)	mai-IN	Aperçu
Malgache (Madagascar)	mg-MG	Aperçu
Malais (Malaisie)	ms-MY	Aperçu
Malayalam (Inde)	ml-IN	Aperçu
Mongol (Mongolie)	mn-MN	Aperçu
Népalais (Népal)	ne-NP	Aperçu
Norvégien, bokmål (Norvège)	nb-NO	Aperçu
Norvégien, nynorsk (Norvège)	nn-NO	Aperçu
Odia (Inde)	or-IN	Aperçu
Pachto (Afghanistan)	ps-AF	Aperçu
Persan (Iran)	fa-IR	Aperçu
Portugais (Portugal)	pt-PT	Aperçu
Panjabi (Inde)	pa-IN	Aperçu
Serbe (Serbie)	sr-RS	Aperçu
Sindhî (Inde)	sd-IN	Aperçu
Cingalais (Sri Lanka)	si-LK	Aperçu
Slovaque (Slovaquie)	sk-SK	Aperçu
Slovène (Slovénie)	sl-SI	Aperçu
Espagnol (Amérique latine)	es-419	Aperçu
Espagnol (Mexique)	es-MX	Aperçu
Swahili (Kenya)	sw-KE	Aperçu
Suédois (Suède)	sv-SE	Aperçu
Ourdou (Pakistan)	ur-PK	Aperçu

Régions disponibles

Gemini-TTS est disponible dans plusieurs régions, via l'API Cloud Text-to-Speech ou l'API Vertex AI.

Le traitement ML de ces modèles a lieu dans la région ou la zone multirégionale spécifique où la requête est effectuée. Pour en savoir plus , consultez Résidence des données.

Pour l'API Cloud Text-to-Speech, les régions suivantes sont compatibles :

Région	Pays ou juridiction	Modèles disponibles
`global`	Monde (hors DRZ)	`gemini-3.1-flash-tts-preview` `gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us`	États-Unis	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`eu`	Union européenne	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`northamerica-northeast1`	Canada	`gemini-2.5-flash-tts` `gemini-2.5-flash-lite-preview-tts`

Ces régions sont accessibles à l'aide des points de terminaison d'API suivants : <REGION>-texttospeech.googleapis.com. Notez que la région global n'a pas de préfixe : texttospeech.googleapis.com.

Pour l'API Vertex AI, les régions suivantes sont compatibles :

Région	Pays ou juridiction	Modèles disponibles
`global`	Monde (hors DRZ)	`gemini-3.1-flash-tts-preview` `gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-central2`	Union européenne	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-north1`	Union européenne	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-southwest1`	Union européenne	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west1`	Union européenne	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west4`	Union européenne	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`northamerica-northeast1`	Canada	`gemini-2.5-flash-tts` `gemini-2.5-flash-lite-preview-tts`
`us-central1`	United States	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east1`	United States	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east4`	United States	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east5`	United States	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-south1`	United States	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-west1`	United States	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-west4`	États-Unis	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`

Ces régions sont accessibles via les points de terminaison d'API suivants : <REGION>-aiplatform.googleapis.com. Notez que la région global n'a pas de préfixe : aiplatform.googleapis.com.

Choisir l'API appropriée

Découvrez comment utiliser les modèles Gemini-TTS pour synthétiser des voix à un ou plusieurs locuteurs à l'aide de l'API Cloud Text-to-Speech ou de l'API Vertex AI.

Gemini-TTS est disponible via deux API pour simplifier le processus d'intégration pour les clients. API Cloud Text-to-Speech et API Vertex AI, avec des points de terminaison REST et des SDK dans plusieurs langages de programmation.

Voici quelques consignes pour vous aider à choisir l'API appropriée.

Si les conditions suivantes s'appliquent, choisissez l'API Cloud Text-to-Speech :

Si vous utilisez Chirp 3 HD ou d'autres voix, vous pouvez continuer à utiliser la même API Cloud Text-to-Speech avec des mises à jour incrémentielles minimales.
Si vous avez besoin de types d'encodage de sortie spécifiques, l'API Cloud Text-to-Speech peut spécifier l'encodage audio. Dans l'API Vertex AI, la sortie correspond à des données audio PCM 16 bits 24 k et ne comporte pas d'en-têtes WAV. Si vous souhaitez effectuer une conversion vers un autre format audio, celle-ci doit être gérée côté client.
Si vous devez diffuser du texte en plusieurs fragments, l'API Cloud Text-to-Speech accepte les interactions impliquant plusieurs requêtes et plusieurs réponses. En revanche, l'API Vertex AI accepte une seule requête et plusieurs réponses.
Si vous souhaitez appliquer la normalisation du texte par défaut. Cette fonctionnalité est particulièrement utile pour les transcriptions qui incluent des dates et des valeurs monétaires.

Si les conditions suivantes s'appliquent, choisissez l'API Vertex AI :

Si vous utilisez déjà Gemini-TTS depuis AI Studio, vous pouvez passer à Vertex AI de manière fluide pour profiter de l'évolutivité et de la conformité de Google Cloud.
Si vous utilisez l'API Vertex AI pour d'autres modèles, la structure d'API unifiée facilite l'utilisation de Gemini-TTS en spécifiant le nom du modèle et les options de sélection de la voix.

Utiliser l'API Cloud Text-to-Speech

Si vous avez besoin d'options autres que celles par défaut, vous pouvez spécifier des formats audio et des taux d'échantillonnage dans le champ "audioConfig".

Description	Limite	Type
Champ de texte	Inférieur ou égal à 4 000 octets.	Entrée
Champ de prompt	Inférieur ou égal à 4 000 octets.	Entrée
Champs de texte et de requête	Inférieur ou égal à 8 000 octets.	Entrée
Durée de l'audio de sortie	Environ 655 secondes. Si le texte d'entrée génère un fichier audio de plus de 655 secondes, le fichier audio est tronqué.	Sortie

Avant de commencer

Avant de pouvoir utiliser Cloud Text-to-Speech, vous devez activer l'API dans la consoleGoogle Cloud en procédant comme suit :

Activez Cloud Text-to-Speech sur un projet.
Assurez-vous que la facturation est activée pour Cloud Text-to-Speech.
Configurez l'authentification pour votre environnement de développement.
Attribuez l'autorisation aiplatform.endpoints.predict à l'utilisateur authentifié. Cette autorisation peut être accordée avec le rôle roles/aiplatform.user.
Sélectionnez le point de terminaison de l'API approprié en fonction des régions disponibles.

Configurer votre projet Google Cloud

Connectez-vous à la console Google Cloud .
Accédez à la page de sélection du projet.

Vous pouvez sélectionner un projet existant ou en créer un. Pour en savoir plus sur la création d'un projet, consultez la documentation deGoogle Cloud .
Si vous créez un projet, un message s'affiche pour vous inviter à associer un compte de facturation. Si vous utilisez un projet préexistant, assurez-vous d'activer la facturation.

Découvrez comment vérifier que la facturation est activée pour votre projet.

Remarque : Vous devez activer la facturation pour utiliser l'API Cloud Text-to-Speech. Toutefois, aucuns frais ne vous seront facturés, sauf si vous dépassez le quota sans frais. Pour en savoir plus sur les tarifs, consultez la page des tarifs.
Une fois que vous avez sélectionné un projet et que vous l'avez associé à un compte de facturation, vous pouvez activer l'API Cloud Text-to-Speech. Accédez à la barre Rechercher des produits et des ressources en haut de la page et saisissez "speech". Sélectionnez l'API Cloud Text-to-Speech dans la liste des résultats.
Pour essayer Cloud Text-to-Speech sans l'associer à votre projet, sélectionnez l'option Essayer cette API. Pour activer l'API Cloud Text-to-Speech afin de l'utiliser avec votre projet, cliquez sur Activer.
Configurez l'authentification pour votre environnement de développement. Pour obtenir des instructions, consultez la page Configurer l'authentification auprès de Cloud Text-to-Speech.

Définition du point de terminaison de l'API pour la région préférée

Vous pouvez choisir un point de terminaison en fonction des régions disponibles.

Python

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
TTS_LOCATION = os.getenv("GOOGLE_CLOUD_REGION")

API_ENDPOINT = (
    f"{TTS_LOCATION}-texttospeech.googleapis.com"
    if TTS_LOCATION != "global"
    else "texttospeech.googleapis.com"
)
client = texttospeech.TextToSpeechClient(
    client_options=ClientOptions(api_endpoint=API_ENDPOINT)
)

CURL

GLOBAL_API_ENDPOINT=https://texttospeech.googleapis.com
REGIONAL_API_ENDPOINT=https://YOUR_REGION-texttospeech.googleapis.com

Effectuer une synthèse synchrone à locuteur unique

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text: str, output_filepath: str = "output.mp3"):
    """Synthesizes speech from the input text and saves it to an MP3 file.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text: The text to synthesize.
        output_filepath: The path to save the generated audio file.
          Defaults to "output.mp3".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    # Select the voice you want to use.
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        name="Charon",  # Example voice, adjust as needed
        model_name="gemini-3.1-flash-tts-preview"
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Perform the text-to-speech request on the text input with the selected
    # voice parameters and audio file type.
    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    # The response's audio_content is binary.
    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way.",
    "text": "OK, so... tell me about this [uhm] AI thing."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "model_name": "gemini-3.1-flash-tts-preview"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Effectuer une synthèse en flux continu pour un seul locuteur

La synthèse en streaming est adaptée aux applications en temps réel où une réponse rapide est essentielle pour l'expérience utilisateur. Dans une connexion en streaming, l'API renvoie l'audio sous forme de petits fragments dès qu'ils sont disponibles.

En tant qu'appelant de l'API, veillez à consommer les fragments audio en les transmettant à vos clients à mesure qu'ils arrivent (par exemple, en utilisant socketio pour les applications Web).

L'API Cloud Text-to-Speech est compatible avec le streaming de type multiple request multiple response. Bien qu'il soit possible d'envoyer les fragments d'entrée à l'API de manière asynchrone, comme indiqué dans request_generator, l'API ne commence la synthèse que lorsque le client envoie Half-Close pour signaler qu'il n'enverra plus de données à l'API.

Le champ prompt doit être défini dans le premier fragment d'entrée, car il est ignoré dans les fragments consécutifs.

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import datetime
import os
import numpy as np
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text_chunks: list[str], model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text_chunks: Text chunks to synthesize. Note that The synthesis will 
          start when the client initiates half-close. 
        model: gemini tts model name. gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales. 
    """
    client = texttospeech.TextToSpeechClient()

    config_request = texttospeech.StreamingSynthesizeRequest(
        streaming_config=texttospeech.StreamingSynthesizeConfig(
            voice=texttospeech.VoiceSelectionParams(
                name=voice,
                language_code=locale,
                model_name=model
            )
        )
    )

    # Example request generator. A function like this can be linked to an LLM
    # text generator and the text can be passed to the TTS API asynchronously.
    def request_generator():
      yield config_request

      for i, text in enumerate(text_chunks):
        yield texttospeech.StreamingSynthesizeRequest(
            input=texttospeech.StreamingSynthesisInput(
              text=text, 
              # Prompt is only supported in the first input chunk.
              prompt=prompt if i == 0 else None,
            )
        )

    request_start_time = datetime.datetime.now()
    streaming_responses = client.streaming_synthesize(request_generator())

    is_first_chunk_received = False
    final_audio_data = np.array([])
    num_chunks_received = 0
    for response in streaming_responses:
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")

        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        # accumulating audio. In a web-server scenario, you would want to 
        # "emit" audio to the frontend as soon as it arrives.
        #
        # For example using flask socketio, you could do the following
        # from flask_socketio import SocketIO, emit
        # emit("audio", response.audio_content)
        # socketio.sleep(0)
        audio_data = np.frombuffer(response.audio_content, dtype=np.int16)
        final_audio_data = np.concatenate((final_audio_data, audio_data))

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time
    audio_duration = len(final_audio_data) / 24_000  # default sampling rate.

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")
    print(f"Audio duration: {audio_duration} seconds")

    return final_audio_data

Effectuer une synthèse synchrone de plusieurs locuteurs avec une saisie de texte libre

Description	Contraintes et limites	Type
Champ de texte	Inférieur ou égal à 4 000 octets	Entrée
Champ de prompt	Inférieur ou égal à 4 000 octets	Entrée
Champs de texte et de requête	Inférieur ou égal à 8 000 octets	Entrée
Alias des locuteurs	Caractères alphanumériques et aucun espace blanc	Entrée
Durée de l'audio de sortie	Environ 655 secondes. Si le texte d'entrée génère un fichier audio de plus de 655 secondes, le fichier audio est tronqué.	Sortie

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_freeform(
    prompt: str,
    text: str,
    output_filepath: str = "output_non_turn_based.wav",
):
    """Synthesizes speech from non-turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        text: The text to synthesize, containing speaker aliases to indicate
          different speakers. Example: "Sam: Hi Bob!\nBob: Hi Sam!"
        output_filepath: The path to save the generated audio file. Defaults to
          "output_non_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-3.1-flash-tts-preview",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts and gemini-2.5-pro-tts
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "text": "Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?"
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-3.1-flash-tts-preview",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Effectuer une synthèse synchrone avec plusieurs locuteurs à l'aide d'une entrée de texte structurée

La fonctionnalité Multi-speaker avec saisie de texte structuré permet une verbalisation intelligente du texte, semblable à celle d'un humain. Par exemple, ce type d'entrée est utile pour les adresses et les dates. La saisie de texte libre énonce le texte exactement tel qu'il est écrit.

Description	Contraintes et limites	Type
Champ MultiSpeakerMarkUp	Inférieur ou égal à 4 000 octets	Entrée
Champ de prompt	Inférieur ou égal à 4 000 octets	Entrée
Champs MultiSpeakerMarkUp et de requête	Inférieur ou égal à 8 000 octets	Entrée
Alias des locuteurs	Caractères alphanumériques et aucun espace blanc	Entrée
Durée de l'audio de sortie	Environ 655 secondes. Si le texte d'entrée génère un fichier audio de plus de 655 secondes, le fichier audio est tronqué.	Sortie

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_structured(
    prompt: str,
    turns: list[texttospeech.MultiSpeakerMarkup.Turn],
    output_filepath: str = "output_turn_based.wav",
):
    """Synthesizes speech from turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        turns: A list of texttospeech.MultiSpeakerMarkup.Turn objects representing
          the dialogue turns.
        output_filepath: The path to save the generated audio file. Defaults to
          "output_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(
        multi_speaker_markup=texttospeech.MultiSpeakerMarkup(turns=turns),
        prompt=prompt,
    )

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-3.1-flash-tts-preview",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "multiSpeakerMarkup": {
      "turns": [
        {
          "speaker": "Sam",
          "text": "Hi Bob, how are you?"
        },
        {
          "speaker": "Bob",
          "text": "I am doing well, and you?"
        }
      ]
    }
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-3.1-flash-tts-preview",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Utiliser l'API Vertex AI

Découvrez comment utiliser les modèles Gemini-TTS pour synthétiser des voix à un ou plusieurs locuteurs à l'aide de l'API Vertex AI.

Dans l'API Cloud Text-to-Speech, l'utilisateur peut fournir des champs de texte et de requête séparément. Dans l'API Vertex AI, il s'agit d'un seul champ contents, qui spécifie l'entrée sous la forme "{prompt}: {text}", par exemple. "Dis la phrase suivante d'un ton curieux : OK, alors... parle-moi de cette histoire d'IA."

Description	Limite	Type
Champ "Contenu"	Inférieur ou égal à 8 000 octets.	Entrée
Durée de l'audio de sortie	Environ 655 secondes. Si le texte d'entrée génère un fichier audio de plus de 655 secondes, le fichier audio est tronqué.	Sortie

Avant de commencer

Avant de commencer, suivez la procédure d'installation de l'API Vertex AI. Pour profiter des options de résidence des données, veillez à définir LOCATION en fonction des régions disponibles.

Effectuer une synthèse synchrone à locuteur unique

Ces exemples de code montrent comment effectuer une synthèse synchrone avec un seul locuteur.

Python

from google import genai
from google.genai import types
import wave
import os

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
  model="gemini-3.1-flash-tts-preview",
  contents="Say the following in a curious way: OK, so... tell me about this [uhm] AI thing.",
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(
              voice_name='Kore',
            )
        )
      ),
  )
)

data = response.candidates[0].content.parts[0].inline_data.data

file_name='output_speech.wav'
wave_file(file_name, data) # Saves the file to current directory

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following in a curious way: OK, so... tell me about this [uhm] AI thing." }
  },
  "generation_config": {
    "speech_config": {
        "language_code": "en-in",
        "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "kore"
            }
        }
    }
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-3.1-flash-tts-preview:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

Effectuer une synthèse en flux continu pour un seul locuteur

L'API Vertex AI accepte le streaming unidirectionnel, c'est-à-dire que le client envoie une seule requête et reçoit un flux de réponses.

Cet exemple de code montre comment effectuer une synthèse en streaming avec un seul locuteur.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize.
        model: gemini tts model name. Available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales.
    """
    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
          language_code=locale,
          voice_config=types.VoiceConfig(
              prebuilt_voice_config=types.PrebuiltVoiceConfig(
                voice_name=voice,
              )
          )
        ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")
        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # accumulating audio. In a web-server scenario, you would want to
          # "emit" audio to the frontend as soon as it arrives.
          #
          # For example using flask socketio, you could do the following
          # from flask_socketio import SocketIO, emit
          # emit("audio", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")

    return final_audio_data

audio_data = synthesize(
    "Say the following in a curious way: Radio Bakery is a New York City gem, celebrated for its exceptional and creative baked goods. The pistachio croissant is often described as a delight with perfect sweetness. The rhubarb custard croissant is a lauded masterpiece of flaky pastry and tart filling. The brown butter corn cake stands out with its crisp edges and rich flavor. Despite the bustle, the staff consistently receives praise for being friendly and helpful.",
    "gemini-3.1-flash-tts-preview",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

Effectuer une synthèse synchrone avec plusieurs locuteurs

Cet exemple de code montre comment effectuer une synthèse multi-locuteurs synchrone.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad, how about you?"""

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
  model="gemini-3.1-flash-tts-preview",
  contents=prompt,
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      ),
  )
)

data = response.candidates[0].content.parts[0].inline_data.data

file_name='output_speech.wav'
wave_file(file_name, data) # Saves the file to current directory

Audio("output_speech.wav")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following as a conversation between friends: Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?" }
  },
  "generation_config": {
    "speech_config": {
      "language_code": "en-in",
      "multi_speaker_voice_config": {
        "speaker_voice_configs": [{
          "speaker": "Sam",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Aoede"
            }
          }
        },{
          "speaker": "Bob",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Algieba"
            }
          }
        }]
      }
    },
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-3.1-flash-tts-preview:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

Effectuer une synthèse en flux continu avec plusieurs locuteurs

L'API Vertex AI accepte le streaming unidirectionnel, c'est-à-dire que le client envoie une seule requête et reçoit un flux de réponses.

Cet exemple de code montre comment effectuer une synthèse multi-locuteurs en streaming.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad! Honestly, I'm just blown away by this new Gemini Text-to-Speech model.
        Joe: Right?! This is a total game changer! And do you know what I just discovered?
        Jane: What?
        Joe: You can use the multi-speaker configuration to create a conversation, just like us!
        Jane: Just like us!"""

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize. Note that The synthesis will start when the
          client initiates half-close.
        model: gemini tts model name. Available models are: gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales.
    """
    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")
        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # accumulating audio. In a web-server scenario, you would want to
          # "emit" audio to the frontend as soon as it arrives.
          #
          # For example using flask socketio, you could do the following
          # from flask_socketio import SocketIO, emit
          # emit("audio", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")

    return final_audio_data

audio_data = synthesize(
    prompt,
    "gemini-3.1-flash-tts-preview",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

Effectuer une synthèse vocale dans Media Studio

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

serviceusage.services.use

Vous pouvez utiliser Media Studio dans la console Google Google Cloud pour tester des modèles de synthèse vocale. Il fournit une interface utilisateur permettant de générer et d'écouter rapidement des contenus audio synthétisés, et de tester différentes instructions et paramètres de style.

Dans la console Google Google Cloud , accédez à la page Agent Studio>Media Studio.

Media Studio
Sélectionnez Speech dans le menu déroulant des médias.
Dans le champ de texte, saisissez le texte que vous souhaitez synthétiser en voix.
Dans le volet Paramètres, configurez les paramètres suivants :
1. Modèle : sélectionnez le modèle Cloud TTS (TTS) que vous souhaitez utiliser, par exemple Gemini 2.5 Pro TTS. Pour en savoir plus sur les modèles disponibles, consultez Modèles Cloud TTS.
2. Instructions de style : (facultatif) saisissez un prompt textuel décrivant le style de parole, le ton et l'émotion sélectionnés. Cela vous permet d'orienter les performances du modèle au-delà de la narration par défaut. Par exemple : "Raconte l'histoire sur un ton calme et professionnel pour un documentaire.".
3. Langue : sélectionnez la langue et la région du texte d'entrée. Le modèle génère un discours dans la langue et l'accent sélectionnés. Par exemple, English (United States).
4. Voix : choisissez une voix prédéfinie pour la narration. La liste contient les voix disponibles pour le modèle et la langue sélectionnés, par exemple Acherner (Female).
Facultatif : développez la section "Options avancées" pour configurer les paramètres audio techniques :
1. Encodage audio : sélectionnez l'encodage du fichier audio de sortie. LINEAR16 est un format non compressé sans perte, adapté au traitement audio de haute qualité. MULAW est également disponible pour la sortie audio compressée.
2. Taux d'échantillonnage audio : sélectionnez le taux d'échantillonnage en hertz (Hz). Ce paramètre détermine la qualité audio. Les valeurs plus élevées, comme 44 100 Hz, représentent un son de haute fidélité, équivalent à la qualité CD.
3. Vitesse : ajustez le débit d'élocution en déplaçant le curseur ou en saisissant une valeur. Les valeurs inférieures à 1 ralentissent la parole, tandis que celles supérieures à 1 l'accélèrent. La valeur par défaut est 1.
4. Gain de volume (dB) : ajustez le volume de la sortie audio en décibels (dB). Les valeurs positives augmentent le volume, tandis que les valeurs négatives le diminuent. La valeur par défaut est de 0.
Cliquez sur l'icône Envoyer à droite de la zone de texte pour générer l'audio.
L'audio généré s'affiche dans le lecteur multimédia. Cliquez sur le bouton de lecture pour écouter le résultat. Vous pouvez continuer à ajuster les paramètres et à générer de nouvelles versions si nécessaire.

Conseils pour écrire des prompts

Pour créer des contenus audio attrayants et naturels à partir de texte, il faut comprendre les nuances du langage parlé et les traduire sous forme de script. Les conseils suivants vous aideront à créer des scripts qui sonnent authentiques et qui reflètent le ton choisi.

Les trois leviers du contrôle de la parole

Pour obtenir les résultats les plus prévisibles et les plus nuancés, assurez-vous que les trois composants suivants sont cohérents avec le résultat souhaité.

Prompt de style Le principal moteur du ton émotionnel global et de la diffusion. La requête définit le contexte de l'ensemble du segment de discours.

Exemple : You are an AI assistant speaking in a friendly and helpful tone.
Exemple : Narrate this in the calm, authoritative tone of a nature documentary narrator.

Contenu textuel : signification sémantique des mots que vous synthétisez. Une phrase évocatrice qui correspond émotionnellement au style de la requête produira des résultats beaucoup plus fiables qu'un texte neutre.

Bonne pratique : un prompt pour un ton effrayé fonctionne mieux avec un texte comme I think someone is in the house.
Moins efficace : un prompt pour un ton effrayé avec un texte comme The meeting is at 4 PM. produira des résultats ambigus.

Balises de balisage (preview) Les balises entre crochets comme [sigh] sont plus adaptées pour injecter une action ou une modification de style spécifique et localisée, et non pour définir le ton général. Ils fonctionnent de concert avec la requête de style et le contenu textuel.

Guide des balises de balisage

Nos recherches montrent que les balises de balisage entre crochets fonctionnent selon l'un des trois modes distincts. Pour utiliser efficacement un tag, il est essentiel de comprendre son mode.

Mode 1 : Sons non vocaux

Le balisage est remplacé par une vocalisation audible non vocale (par exemple, un soupir ou un rire). La balise elle-même n'est pas lue. Ils sont parfaits pour ajouter des hésitations et des réactions réalistes, semblables à celles d'un humain.

Tag	Comportement	Fiabilité	Conseils
`[sigh]`	Insère un son de soupir.	Élevée	La qualité émotionnelle du soupir est influencée par le prompt.
`[laughing]`	Insère un rire.	Élevée	Pour de meilleurs résultats, utilisez un prompt spécifique. Par exemple, un prompt générique peut générer un rire de surprise, tandis que "réagis avec un rire amusé" crée un rire d'amusement.
`[uhm]`	Insère un son d'hésitation.	Élevée	Utile pour créer une impression plus naturelle et conversationnelle.

Mode 2 : Modificateurs de style

Le balisage n'est pas prononcé, mais il modifie la diffusion du discours suivant. La portée et la durée de la modification peuvent varier.

Tag	Comportement	Fiabilité	Conseils
`[sarcasm]`	Donne un ton sarcastique à la phrase suivante.	Élevée	Cette balise est un modificateur puissant. Cela démontre que des concepts abstraits peuvent orienter efficacement la réponse du modèle.
`[robotic]`	Le discours suivant semble robotique.	Élevée	L'effet peut s'étendre à une phrase entière. Pour obtenir de meilleurs résultats, nous vous recommandons d'utiliser un prompt de style (par exemple, "Dis-le d'une voix robotique").
`[shouting]`	Augmente le volume de la voix.	Élevée	Cette option est plus efficace lorsqu'elle est associée à un prompt de style correspondant (par exemple, "Crie la partie suivante") et à un texte qui implique de crier.
`[whispering]`	Diminue le volume de la voix suivante.	Élevée	Pour obtenir les meilleurs résultats, la requête de style doit également être explicite (par exemple, "maintenant, chuchote cette partie aussi doucement que possible").
`[extremely fast]`	Augmente la vitesse de la synthèse vocale suivante.	Élevée	Idéal pour les clauses de non-responsabilité ou les dialogues rapides. Besoin d'une assistance minimale pour les prompts.

Mode 3 : balisage vocalisé (adjectifs)

La balise de balisage elle-même est prononcée comme un mot, tout en influençant le ton de la phrase entière. Ce comportement s'applique généralement aux adjectifs émotionnels.

Avertissement : Étant donné que la balise elle-même est lue, ce mode est probablement un effet secondaire indésirable pour la plupart des cas d'utilisation. Utilisez plutôt le prompt de style pour définir ces tons émotionnels.

Tag	Comportement	Fiabilité	Conseils
`[scared]`	Le mot "scared" (effrayé) est prononcé, et la phrase adopte un ton effrayé.	Élevée	Les performances dépendent fortement du contenu textuel. La phrase "Je viens d'entendre une fenêtre se briser" produit un résultat véritablement effrayé. Une phrase neutre produit un résultat "effrayant", mais moins authentique.
`[curious]`	Le mot "curieux" est prononcé, et la phrase adopte un ton curieux.	Élevée	Utilisez une phrase interrogative pour appuyer l'intention du tag.
`[bored]`	Le mot "bored" (ennuyé) est prononcé, et la phrase adopte un ton ennuyé et monotone.	Élevée	Pour un effet optimal, utilisez-le avec du texte banal ou répétitif.

Mode 4 : Rythme et pauses

Ces balises insèrent des silences dans l'audio généré, ce qui vous permet de contrôler précisément le rythme, le timing et la cadence. La ponctuation standard (virgules, points, points-virgules) crée également des pauses naturelles, mais ces balises offrent un contrôle plus explicite.

Tag	Comportement	Fiabilité	Conseils
`[short pause]`	Insère une brève pause, semblable à une virgule (~250 ms).	Élevée	Utilisez-les pour séparer des clauses ou des éléments de liste pour plus de clarté.
`[medium pause]`	Insère une pause standard, semblable à une pause de phrase (~500 ms).	Élevée	Efficace pour séparer des phrases ou des pensées distinctes.
`[long pause]`	Insère une pause significative pour un effet dramatique (~1 000 ms+).	Élevée	Utilisez-le pour créer un effet dramatique. Par exemple : "La réponse est… `[long pause]` ...non." Évitez d'en abuser, car cela peut sembler artificiel.

Stratégies clés pour des résultats fiables

Alignez les trois leviers : pour une prévisibilité maximale, assurez-vous que votre prompt de style, votre contenu textuel et vos balises sont tous sémantiquement cohérents et visent le même objectif.
Utilisez un texte riche en émotions : ne vous fiez pas uniquement aux requêtes et aux tags. Fournissez au modèle un texte riche et descriptif sur lequel travailler. C'est particulièrement important pour les émotions nuancées comme le sarcasme, la peur ou l'excitation.
Rédigez des prompts spécifiques et détaillés : plus votre prompt de style est précis, plus le résultat est fiable. "Réagir avec un rire amusé" est mieux que simplement [laughing]. "Parle comme un présentateur radio des années 1940" est plus efficace que "Parle comme autrefois".
Tester et valider les nouvelles balises : Le comportement d'une balise nouvelle ou non testée n'est pas toujours prévisible. Une balise que vous pensez être un modificateur de style peut être vocalisée. Testez toujours une nouvelle combinaison de balises ou de requêtes pour confirmer son comportement avant de la déployer en production.

Paramètres du contrôle de situation

Bien que certains contrôles de sécurité ne puissent pas être désactivés, vous pouvez ajuster les seuils de certaines catégories de préjudice pour renforcer la sécurité et limiter les cas d'utilisation abusive. Vous pouvez l'activer en définissant des filtres de sécurité sous AdvancedVoiceOptions.

Il existe quatre catégories de préjudice qui peuvent être configurées à différents niveaux de seuil. Vous pouvez définir une ou plusieurs catégories pour bloquer les contenus dangereux.

L'ancien champ relax_safety_filters est obsolète.

Selon les filtres de sécurité que vous configurez, la sortie peut contenir un code de sécurité semblable à celui-ci : "Cloud Text-to-Speech n'a pas pu générer d'audio, car le texte ou la requête d'entrée ne respectent pas les consignes d'utilisation de Vertex AI. Si vous pensez qu'il s'agit d'une erreur, envoyez des commentaires. Codes d'assistance : 62263041"

Le code indiqué dans le résultat correspond à une catégorie de contenu nuisible spécifique.

Le tableau suivant présente les correspondances entre les codes d'assistance et les catégories de sécurité :

Code d'assistance	Catégorie de sécurité	Description
`54702341`	Non spécifié	Catégorie non spécifiée.
`62263041`	Contenu dangereux	Contenu potentiellement dangereux.
`57734940`	Harcèlement	Contenus relevant du harcèlement :
`90789179`	Caractère sexuel explicite	Contenu à caractère sexuel ou suggestif.
`78610348`	Incitation à la haine	Contenu incitant à la haine.

Ces exemples de code montrent comment personnaliser les configurations de sécurité dans l'API Cloud Text-to-Speech. Pour en savoir plus sur l'utilisation de l'API Vertex AI, consultez Exemples d'API Vertex AI.

Python

# google-cloud-texttospeech minimum version 2.32.0 is required.
request = texttospeech.SynthesizeSpeechRequest(
    input=synthesis_input,
    voice=voice,
    audio_config=audio_config,
    advanced_voice_options=texttospeech.AdvancedVoiceOptions(
      safety_settings=texttospeech.AdvancedVoiceOptions.SafetySettings(
          settings=[texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_HARASSMENT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          )]
      )
    ),
)
# Perform the text-to-speech request on the text input with the selected
# voice parameters and audio file type.
response = client.synthesize_speech(request=request)

CURL

PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way.",
    "text": "I am saying something that would otherwise be blocked by Gemini TTS."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "modelName": "gemini-3.1-flash-tts-preview"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  },
  "advancedVoiceOptions": {
    "safetySettings": {
      "settings": {
        "category": "HARM_CATEGORY_HATE_SPEECH",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_HARASSMENT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
    }
  },
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Gemini-TTS Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Modèles disponibles

Gemini 3.1 Flash TTS (preview)

Gemini 2.5 Flash TTS

Gemini 2.5 Flash-Lite TTS (preview)

Gemini 2.5 Pro TTS

Paramètres supplémentaires

Options vocales

Langues disponibles

Régions disponibles

Choisir l'API appropriée

Utiliser l'API Cloud Text-to-Speech

Avant de commencer

Configurer votre projet Google Cloud

Définition du point de terminaison de l'API pour la région préférée

Python

CURL

Effectuer une synthèse synchrone à locuteur unique

Python

CURL

Effectuer une synthèse en flux continu pour un seul locuteur

Python

Effectuer une synthèse synchrone de plusieurs locuteurs avec une saisie de texte libre

Python

CURL

Effectuer une synthèse synchrone avec plusieurs locuteurs à l'aide d'une entrée de texte structurée

Python

CURL

Utiliser l'API Vertex AI

Avant de commencer

Effectuer une synthèse synchrone à locuteur unique

Python

CURL

Effectuer une synthèse en flux continu pour un seul locuteur

Python

Effectuer une synthèse synchrone avec plusieurs locuteurs

Python

CURL

Effectuer une synthèse en flux continu avec plusieurs locuteurs

Python

Effectuer une synthèse vocale dans Media Studio

Autorisations requises pour cette tâche

Conseils pour écrire des prompts

Les trois leviers du contrôle de la parole

Guide des balises de balisage

Mode 1 : Sons non vocaux

Mode 2 : Modificateurs de style

Mode 3 : balisage vocalisé (adjectifs)

Mode 4 : Rythme et pauses

Stratégies clés pour des résultats fiables

Paramètres du contrôle de situation

Python

CURL

Gemini-TTS