Gemini-TTS

Essayer Gemini-TTS dans Vertex AI 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 au son naturel et offre un contrôle précis de l'audio généré à l'aide de requêtes textuelles. Avec Gemini-TTS, vous pouvez synthétiser la parole d'un ou plusieurs locuteurs, qu'il s'agisse de courts extraits ou de longs récits. Vous pouvez dicter précisément le style, l'accent, le rythme, le ton et même l'expression émotionnelle, le tout en utilisant des prompts en langage naturel.

Modèles disponibles

Gemini-TTS inclut les modèles disponibles suivants :

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, pour un ou plusieurs haut-parleurs, pour les applications quotidiennes économiques
Modalités d'entrée et de sortie	Entrée : texte Sortie : audio
Compatibilité avec les numéros de haut-parleur	Locuteur unique, plusieurs locuteurs
Formats audio de sortie acceptés	Unaire : LINEAR16 (par défaut), ALAW, MULAW, MP3, OGG_OPUS, PCM Streaming : PCM (par défaut), ALAW, MULAW, OGG_OPUS
Régions prises en charge	global
Options vocales	Consultez Options vocales.
Langues disponibles	Consultez la section 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 à une seule voix pour les applications quotidiennes économiques. Notez que ce modèle est disponible en version preview.
Modalités d'entrée et de sortie	Entrée : texte Sortie : audio
Compatibilité avec les numéros de haut-parleur	Unique
Formats audio de sortie acceptés	Unaire : LINEAR16 (par défaut), ALAW, MULAW, MP3, OGG_OPUS, PCM Streaming : PCM (par défaut), ALAW, MULAW, OGG_OPUS
Régions prises en charge	global
Options vocales	Consultez Options vocales.
Langues disponibles	Consultez la section 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.
Modalités d'entrée et de sortie	Entrée : texte Sortie : audio
Compatibilité avec les numéros de haut-parleur	Locuteur unique, plusieurs locuteurs
Formats audio de sortie acceptés	Unaire : LINEAR16 (par défaut), ALAW, MULAW, MP3, OGG_OPUS, PCM Streaming : PCM (par défaut), ALAW, MULAW, OGG_OPUS
Régions prises en charge	global
Options vocales	Consultez Options vocales.
Langues disponibles	Consultez la section 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 contrôles et fonctionnalités :

1. Conversation naturelle : les interactions vocales sont d'une qualité remarquable, avec une expressivité plus appropriée et des rythmes de parole très fluides grâce à une latence très faible.

2. Contrôle du style : à l'aide d'instructions en langage naturel, vous pouvez adapter la façon dont le modèle s'exprime dans la conversation en lui demandant d'adopter des accents spécifiques et de produire une gamme de tons et d'expressions, y compris un murmure.

3. Performances dynamiques : ces modèles peuvent donner vie au texte pour des lectures expressives de poèmes, de journaux télévisés et de récits captivants. Ils peuvent également jouer la comédie avec des émotions spécifiques et produire des accents sur demande.

4. Contrôle amélioré du rythme et de la prononciation : le contrôle de la vitesse de lecture permet d'améliorer la précision de la prononciation, y compris pour certains mots.

Pour savoir comment utiliser ces voix dans votre application, consultez Utiliser Gemini-TTS.

Options vocales

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

Sélectionner un type de voix Femme Homme

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 :

Sélectionner une étape de lancement DG Aperçu

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 (État de la Cité du 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

Utiliser Gemini-TTS

Découvrez comment utiliser les modèles Gemini-TTS pour synthétiser la parole d'une ou plusieurs personnes.

Remarque : La taille du champ de texte et du champ d'invite ne peut pas dépasser 4 000 octets chacun. La taille totale des champs d'invite et de texte peut atteindre 8 000 octets, mais chaque champ ne doit pas dépasser 4 000 octets. La durée de l'audio généré ne peut pas dépasser environ 655 secondes. Si le texte d'entrée correspond à un contenu audio plus long que cette limite, il sera tronqué.

Si vous avez besoin d'options non définies par défaut, vous pouvez spécifier des formats audio et des fréquences d'échantillonnage dans le champ "audioConfig".

Description	Limite	Type
Champ de texte	Inférieur ou égal à 4 000 octets.	Entrée
Champ de requête	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 la sortie audio	Environ 655 secondes. Si le texte saisi génère un contenu audio de plus de 655 secondes, il est tronqué.	Sortie

Remarque : Pour pouvoir utiliser Gemini-TTS, l'autorisation aiplatform.endpoints.predict est requise pour le point de terminaison du modèle. Cette autorisation peut être accordée avec le rôle roles/aiplatform.user.

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 :

1. Activez Cloud Text-to-Speech sur un projet.
2. Assurez-vous que la facturation est activée pour Cloud Text-to-Speech.
3. Configurez l'authentification pour votre environnement de développement.

Configurer votre projet Google Cloud

1. Connectez-vous à la console Google Cloud .

2. 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 documentationGoogle Cloud .

3. 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 pouvoir utiliser l'API Cloud Text-to-Speech, mais vous ne serez facturé que si vous dépassez le quota gratuit. Pour en savoir plus sur la tarification, consultez la page Tarifs.

4. 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, puis saisissez "speech". Sélectionnez l'API Cloud Text-to-Speech dans la liste des résultats.

5. 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.

6. Configurez l'authentification pour votre environnement de développement. Pour obtenir des instructions, consultez Configurer l'authentification pour Cloud Text-to-Speech.

Effectuer une synthèse synchrone à une seule voix

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-2.5-pro-tts"
    )

    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-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-2.5-flash-tts"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Effectuer une synthèse en flux continu à une seule voix

La synthèse en streaming convient aux applications en temps réel où une réponse rapide est essentielle pour l'expérience utilisateur. Dans une connexion de streaming, l'API renvoie l'audio au fur et à mesure qu'il est disponible, par petits blocs.

En tant qu'appelant de l'API, assurez-vous de consommer les blocs audio et de les transmettre à vos clients à mesure qu'ils arrivent (par exemple, en utilisant socketio pour les applications Web).

Bien qu'il soit possible d'envoyer les blocs d'entrée à l'API de manière asynchrone, comme indiqué dans request_generator, l'API ne commencera la synthèse que lorsque le client enverra une fermeture partielle pour signaler qu'il n'enverra plus de données à l'API.

Le champ prompt doit être défini dans le premier bloc d'entrée, car il est ignoré dans les blocs 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-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 multilocuteur avec une saisie de texte libre

Remarque : La taille combinée de toutes les lignes de dialogue ne peut pas dépasser 4 000 octets. La taille totale de la requête et du dialogue peut atteindre 4 000 octets, mais chaque champ de requête et de dialogue ne doit pas dépasser 4 000 octets. Les alias de locuteurs ne doivent contenir que des caractères alphanumériques, sans espaces.

Description	Contraintes et limites	Type
Champ de texte	Inférieur ou égal à 4 000 octets	Entrée
Champ de requête	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 haut-parleurs	Caractères alphanumériques sans espace	Entrée
Durée de la sortie audio	Environ 655 secondes. Si le texte saisi génère un contenu audio de plus de 655 secondes, il 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-2.5-pro-tts",
        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-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-2.5-flash-tts",
    "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 multilocuteur avec une entrée de texte structurée

La fonctionnalité de synthèse vocale multilocuteur avec saisie de texte structuré permet de verbaliser intelligemment du texte de manière naturelle. Par exemple, ce type d'entrée est utile pour les adresses et les dates. L'entrée de texte libre est lue exactement telle qu'elle est écrite.

Remarque : Les alias de locuteurs ne doivent contenir que des caractères alphanumériques, sans espaces. La taille combinée de toutes les lignes de dialogue ne peut pas dépasser 4 000 octets. Bien que la taille totale de la requête et du dialogue puisse atteindre 4 000 octets, chaque champ de requête et de dialogue ne doit pas dépasser 4 000 octets.

Description	Contraintes et limites	Type
Champ MultiSpeakerMarkUp	4 000 octets ou moins	Entrée
Champ de requête	Inférieur ou égal à 4 000 octets	Entrée
Champs MultiSpeakerMarkUp et "prompt"	8 000 octets ou moins	Entrée
Alias des haut-parleurs	Caractères alphanumériques sans espace	Entrée
Durée de la sortie audio	Environ 655 secondes. Si le texte saisi génère un contenu audio de plus de 655 secondes, il 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-2.5-pro-tts",
        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-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-2.5-flash-tts",
    "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 Gemini-TTS dans l'API d'IA générative Google

Découvrez comment utiliser les modèles Gemini-TTS pour synthétiser la parole d'un ou plusieurs locuteurs à l'aide de l'API d'IA générative Google .

Dans l'API Cloud Text-to-Speech, l'utilisateur peut fournir des champs de texte et d'invite séparément. Dans l'API d'IA générative Google , il s'agit d'un champ contents unique, où l'entrée est spécifié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."

Dans l'API d'IA générative Google , la sortie est constituée de données audio PCM 16 bits 24k et ne comporte pas d'en-têtes WAV. Le client doit effectuer des étapes supplémentaires s'il souhaite convertir le fichier audio dans un autre format.

Remarque : La taille totale des champs de requête et de texte ne peut pas dépasser 8 000 octets. La durée de l'audio généré ne peut pas dépasser environ 655 secondes. Si le texte d'entrée correspond à un contenu audio plus long que cette limite, il est tronqué.

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

Avant de commencer

Avant de commencer, suivez les étapes d'installation de l'API d'IA générative.Google

Effectuer une synthèse synchrone à une seule voix

Ces exemples de code montrent comment effectuer une synthèse synchrone à une seule voix.

Python

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

PROJECT_ID = "[your-project-id]"  # @param {type: "string", placeholder: "[your-project-id]", isTemplate: true}
if not PROJECT_ID or PROJECT_ID == "[your-project-id]":
    PROJECT_ID = str(os.environ.get("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-2.5-flash-tts",
  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-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-2.5-flash-tts: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 synchrone multi-locuteurs

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

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-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-2.5-flash-tts: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 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 les modèles de synthèse vocale. Il fournit une interface utilisateur permettant de générer rapidement de l'audio synthétisé, de l'écouter et de tester différents paramètres et instructions de style.

1. Dans la console Google Google Cloud , accédez à la page Vertex AI Studio>Media Studio.

   Media Studio

2. Sélectionnez Discours dans le menu déroulant "Média".

3. Dans le champ de texte, saisissez le texte que vous souhaitez synthétiser en voix.

4. 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 une requête textuelle décrivant le style de parole, le ton et l'émotion choisis. Cela vous permet de guider les performances du modèle au-delà de la narration par défaut. Par exemple : "Fais la narration d'un documentaire sur un ton calme et professionnel."
   3. Langue : sélectionnez la langue et la région du texte saisi. Le modèle génère la voix dans la langue et avec l'accent sélectionnés. Par exemple, Anglais (États-Unis).
   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, comme Acherner (Femme).

5. 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 sans perte et non compressé, 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). Cela détermine la qualité audio. Les valeurs plus élevées, comme 44 100 Hz, représentent un son haute fidélité, équivalent à la qualité CD.
   3. Vitesse : ajustez le débit vocal 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 l'audio de sortie 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.

6. Cliquez sur l'icône Envoyer à droite de la zone de texte pour générer l'audio.

7. L'élément 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 rédiger des requêtes

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 vocal

Pour obtenir les résultats les plus prévisibles et nuancés, assurez-vous que les trois composants suivants correspondent au résultat souhaité.

Style de la requête Principal moteur du ton émotionnel et de la diffusion globale. La requête définit le contexte pour l'ensemble du segment de parole.

• 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 expression évocatrice qui correspond émotionnellement à la requête de style produira des résultats beaucoup plus fiables qu'un texte neutre.

• Bien : un ton effrayé fonctionne mieux avec un texte comme I think someone is in the house.

• Moins efficace : un prompt demandant un ton effrayé avec un texte tel que The meeting is at 4 PM. produira des résultats ambigus.

Balises de mise en forme (aperçu) Les balises entre crochets, comme [sigh], sont idéales pour insérer 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

Preview

Ce produit ou cette fonctionnalité sont soumis aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités de pré-DG sont proposés "en l'état" et peuvent avoir une compatibilité limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

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

Mode 1 : Sons autres que la parole

Le balisage est remplacé par une vocalisation audible et non verbale (par exemple, un soupir ou un rire). La balise elle-même n'est pas lue. Elles sont idéales pour ajouter des hésitations et des réactions réalistes et humaines.

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

Mode 2 : Modificateurs de style

Le balisage n'est pas lu, mais il modifie la façon dont le texte suivant est lu. L'étendue 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 montre que des concepts abstraits peuvent orienter efficacement la réponse du modèle.
[robotic]	Rend la voix robotique.	Élevée	L'effet peut s'étendre à une phrase entière. Une requête de style encourageante (par exemple, "Dis ça de manière robotique") est toujours recommandé pour obtenir les meilleurs résultats.
[shouting]	Augmente le volume de la voix qui suit.	Élevée	Elle est plus efficace lorsqu'elle est associée à une requête de style correspondante (par exemple, "Crie la prochaine partie") et du texte qui implique de crier.
[whispering]	Diminue le volume de la voix qui suit.	Élevée	Les meilleurs résultats sont obtenus lorsque la requête de style est également explicite (par exemple, "now whisper this part as quietly as you can").
[extremely fast]	Augmente la vitesse de la parole suivante.	Élevée	Idéal pour les clauses de non-responsabilité ou les dialogues rapides. Vous avez besoin d'une assistance minimale pour les requêtes.

Mode 3 : Balisage vocal (adjectifs)

La balise de balisage elle-même est énoncé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 le tag lui-même est énoncé, ce mode est susceptible d'être un effet secondaire indésirable pour la plupart des cas d'utilisation. Il est préférable d'utiliser le style de prompt pour définir ces tons émotionnels.

Tag	Comportement	Fiabilité	Conseils
[scared]	Le mot "peur" 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 vitre se briser" produit un résultat réellement 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 expression interrogative pour appuyer l'intention de la balise.
[bored]	Le mot "ennuyé" est prononcé, et la phrase est dite d'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 du silence dans l'audio généré, ce qui vous permet de contrôler précisément le rythme, le timing et le tempo. 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 (environ 250 ms).	Élevée	Utilisez-les pour séparer des clauses ou des éléments de liste afin d'améliorer la clarté.
[medium pause]	Insère une pause standard, semblable à une fin de phrase (environ 500 ms).	Élevée	Efficace pour séparer des phrases ou des idées distinctes.
[long pause]	Insère une pause importante pour un effet dramatique (environ 1 000 ms ou plus).	Élevée	À utiliser pour un timing spectaculaire. Par exemple : "La réponse est… [long pause] … non." Évitez d'en abuser, car cela peut sembler artificiel.

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

• Alignez les trois leviers : pour une prévisibilité maximale, assurez-vous que votre style de prompt, votre contenu textuel et vos balises de mise en forme sont tous cohérents sur le plan sémantique 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. C'est particulièrement important pour les émotions nuancées comme le sarcasme, la peur ou l'enthousiasme.

• Rédigez des requêtes précises et détaillées : plus votre requête de style est précise, plus le résultat est fiable. "Réagis avec un rire amusé" est mieux que simplement [laughing]. "Parle comme un présentateur de radio des années 1940" est préférable à "Parle de manière démodée".

• Testez et validez les nouvelles balises : le comportement d'une balise nouvelle ou non testée n'est pas toujours prévisible. Il est possible qu'un tag que vous considérez comme un modificateur de style soit vocalisé. Testez toujours une nouvelle combinaison de balises ou d'invites pour confirmer son comportement avant de la déployer en production.

Désactiver les filtres de sécurité

Les comptes avec facturation mensuelle peuvent configurer des requêtes pour assouplir les filtres de sécurité à l'aide du champ relax_safety_filters sous AdvancedVoiceOptions. Le champ relax_safety_filters n'est activé que pour les comptes utilisant la facturation avec paiement sur facture mensuelle mensuelle.

Si vous assouplissez les filtres de sécurité, le seuil de blocage des contenus dangereux qui sont synthétisés sera abaissé.

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(
        relax_safety_filters=True,
    ),
)
# 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-2.5-flash-tts"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  },
  "advancedVoiceOptions": {
    "relaxSafetyFilters": true
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit