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 :

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 (É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.

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

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.

  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

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.

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.

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

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

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