Génération de synthèse vocale

L'API Gemini peut transformer une entrée de texte en contenu audio à une ou plusieurs voix à l'aide de fonctionnalités de génération de synthèse vocale (TTS) natives. La génération de synthèse vocale (TTS) est contrôlable, ce qui signifie que vous pouvez utiliser le langage naturel pour structurer les interactions et guider le style, l'accent, le rythme et le ton de l'audio.

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

Ce guide vous explique comment générer de l'audio à un ou plusieurs locuteurs à partir de texte.

Avant de commencer

Assurez-vous d'utiliser une variante du modèle Gemini 2.5 avec des fonctionnalités de synthèse vocale (TTS) natives, comme indiqué dans la section Modèles compatibles. Pour obtenir des résultats optimaux, réfléchissez au modèle qui correspond le mieux à votre cas d'utilisation spécifique.

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

Synthèse vocale à un seul locuteur

Pour convertir du texte en contenu audio à une seule voix, définissez la modalité de réponse sur "audio" et transmettez un objet SpeechConfig avec VoiceConfig défini. Vous devez choisir un nom de voix parmi les voix de sortie prédéfinies.

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

Python

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

# 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()

response = client.models.generate_content(
   model="gemini-2.5-flash-preview-tts",
   contents="Say cheerfully: Have a wonderful day!",
   config=types.GenerateContentConfig(
      response_modalities=["AUDIO"],
      speech_config=types.SpeechConfig(
         voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(
               voice_name='Kore',
            )
         )
      ),
   )
)

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

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

JavaScript

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

async function saveWaveFile(
   filename,
   pcmData,
   channels = 1,
   rate = 24000,
   sampleWidth = 2,
) {
   return new Promise((resolve, reject) => {
      const writer = new wav.FileWriter(filename, {
            channels,
            sampleRate: rate,
            bitDepth: sampleWidth * 8,
      });

      writer.on('finish', resolve);
      writer.on('error', reject);

      writer.write(pcmData);
      writer.end();
   });
}

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

   const response = await ai.models.generateContent({
      model: "gemini-2.5-flash-preview-tts",
      contents: [{ parts: [{ text: 'Say cheerfully: Have a wonderful day!' }] }],
      config: {
            responseModalities: ['AUDIO'],
            speechConfig: {
               voiceConfig: {
                  prebuiltVoiceConfig: { voiceName: 'Kore' },
               },
            },
      },
   });

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

   const fileName = 'out.wav';
   await saveWaveFile(fileName, audioBuffer);
}
await main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "parts":[{
            "text": "Say cheerfully: Have a wonderful day!"
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "prebuiltVoiceConfig": {
                "voiceName": "Kore"
              }
            }
          }
        },
        "model": "gemini-2.5-flash-preview-tts",
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode >out.pcm
# You may need to install ffmpeg.
ffmpeg -f s16le -ar 24000 -ac 1 -i out.pcm out.wav

Synthèse vocale multi-locuteurs

Pour l'audio multi-locuteurs, vous aurez besoin d'un objet MultiSpeakerVoiceConfig avec chaque locuteur (jusqu'à deux) configuré en tant que SpeakerVoiceConfig. Vous devez définir chaque speaker avec les mêmes noms que ceux utilisés dans l'invite :

Python

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

# 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()

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

response = client.models.generate_content(
   model="gemini-2.5-flash-preview-tts",
   contents=prompt,
   config=types.GenerateContentConfig(
      response_modalities=["AUDIO"],
      speech_config=types.SpeechConfig(
         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='out.wav'
wave_file(file_name, data) # Saves the file to current directory

JavaScript

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

async function saveWaveFile(
   filename,
   pcmData,
   channels = 1,
   rate = 24000,
   sampleWidth = 2,
) {
   return new Promise((resolve, reject) => {
      const writer = new wav.FileWriter(filename, {
            channels,
            sampleRate: rate,
            bitDepth: sampleWidth * 8,
      });

      writer.on('finish', resolve);
      writer.on('error', reject);

      writer.write(pcmData);
      writer.end();
   });
}

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

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

   const response = await ai.models.generateContent({
      model: "gemini-2.5-flash-preview-tts",
      contents: [{ parts: [{ text: prompt }] }],
      config: {
            responseModalities: ['AUDIO'],
            speechConfig: {
               multiSpeakerVoiceConfig: {
                  speakerVoiceConfigs: [
                        {
                           speaker: 'Joe',
                           voiceConfig: {
                              prebuiltVoiceConfig: { voiceName: 'Kore' }
                           }
                        },
                        {
                           speaker: 'Jane',
                           voiceConfig: {
                              prebuiltVoiceConfig: { voiceName: 'Puck' }
                           }
                        }
                  ]
               }
            }
      }
   });

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

   const fileName = 'out.wav';
   await saveWaveFile(fileName, audioBuffer);
}

await main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
  "contents": [{
    "parts":[{
      "text": "TTS the following conversation between Joe and Jane:
                Joe: Hows it going today Jane?
                Jane: Not too bad, how about you?"
    }]
  }],
  "generationConfig": {
    "responseModalities": ["AUDIO"],
    "speechConfig": {
      "multiSpeakerVoiceConfig": {
        "speakerVoiceConfigs": [{
            "speaker": "Joe",
            "voiceConfig": {
              "prebuiltVoiceConfig": {
                "voiceName": "Kore"
              }
            }
          }, {
            "speaker": "Jane",
            "voiceConfig": {
              "prebuiltVoiceConfig": {
                "voiceName": "Puck"
              }
            }
          }]
      }
    }
  },
  "model": "gemini-2.5-flash-preview-tts",
}' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
    base64 --decode > out.pcm
# You may need to install ffmpeg.
ffmpeg -f s16le -ar 24000 -ac 1 -i out.pcm out.wav

Contrôler le style de parole avec des requêtes

Vous pouvez contrôler le style, le ton, l'accent et le rythme à l'aide de requêtes en langage naturel pour la synthèse vocale à une ou plusieurs voix. Par exemple, dans une requête à un seul locuteur, vous pouvez dire :

Say in an spooky whisper:
"By the pricking of my thumbs...
Something wicked this way comes"

Dans une requête à plusieurs locuteurs, fournissez au modèle le nom de chaque locuteur et la transcription correspondante. Vous pouvez également fournir des conseils pour chaque enceinte individuellement :

Make Speaker1 sound tired and bored, and Speaker2 sound excited and happy:

Speaker1: So... what's on the agenda today?
Speaker2: You're never going to guess!

Essayez d'utiliser une option vocale qui correspond au style ou à l'émotion que vous souhaitez transmettre, pour l'accentuer encore plus. Dans la requête précédente, par exemple, le souffle de Encelade peut mettre l'accent sur les mots "fatigué" et "ennuyé", tandis que le ton enjoué de Puck peut compléter les mots "enthousiaste" et "heureux".

Générer une requête pour convertir un texte en audio

Les modèles de synthèse vocale ne génèrent que de l'audio, mais vous pouvez utiliser d'autres modèles pour générer d'abord une transcription, puis la transmettre au modèle de synthèse vocale pour qu'il la lise à voix haute.

Python

from google import genai
from google.genai import types

client = genai.Client()

transcript = client.models.generate_content(
   model="gemini-2.0-flash",
   contents="""Generate a short transcript around 100 words that reads
            like it was clipped from a podcast by excited herpetologists.
            The hosts names are Dr. Anya and Liam.""").text

response = client.models.generate_content(
   model="gemini-2.5-flash-preview-tts",
   contents=transcript,
   config=types.GenerateContentConfig(
      response_modalities=["AUDIO"],
      speech_config=types.SpeechConfig(
         multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
               types.SpeakerVoiceConfig(
                  speaker='Dr. Anya',
                  voice_config=types.VoiceConfig(
                     prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                     )
                  )
               ),
               types.SpeakerVoiceConfig(
                  speaker='Liam',
                  voice_config=types.VoiceConfig(
                     prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                     )
                  )
               ),
            ]
         )
      )
   )
)

# ...Code to stream or save the output

JavaScript

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

const ai = new GoogleGenAI({});

async function main() {

const transcript = await ai.models.generateContent({
   model: "gemini-2.0-flash",
   contents: "Generate a short transcript around 100 words that reads like it was clipped from a podcast by excited herpetologists. The hosts names are Dr. Anya and Liam.",
   })

const response = await ai.models.generateContent({
   model: "gemini-2.5-flash-preview-tts",
   contents: transcript,
   config: {
      responseModalities: ['AUDIO'],
      speechConfig: {
         multiSpeakerVoiceConfig: {
            speakerVoiceConfigs: [
                   {
                     speaker: "Dr. Anya",
                     voiceConfig: {
                        prebuiltVoiceConfig: {voiceName: "Kore"},
                     }
                  },
                  {
                     speaker: "Liam",
                     voiceConfig: {
                        prebuiltVoiceConfig: {voiceName: "Puck"},
                    }
                  }
                ]
              }
            }
      }
  });
}
// ..JavaScript code for exporting .wav file for output audio

await main();

Options vocales

Les modèles TTS sont compatibles avec les 30 options vocales suivantes dans le champ voice_name :

Zephyr : Lumineux Puck : Upbeat Charon : Contenu informatif
Kore : Ferme Fenrir : excitabilité Leda : Jeune
Orus : entreprise Aoede : Breezy Callirrhoe : facile à vivre
Autonoe : Lumineux Enceladus : Souffle Iapetus : Effacer
Umbriel : décontracté Algieba : Smooth Despina : Lisse
Erinome : dégagé Algenib : graveleux Rasalgethi : informatif
Laomedeia : Upbeat Achernar : Soft Alnilam : Ferme
Schedar : Even Gacrux : Contenu réservé aux adultes Pulcherrima : Transférer
Achird : amical Zubenelgenubi : Décontracté Vindemiatrix : Doux
Sadachbia : Lively Sadaltager : connaissances Sulafat : chaude

Vous pouvez écouter toutes les options vocales dans AI Studio.

Langues disponibles

Les modèles TTS détectent automatiquement la langue d'entrée. Ils sont disponibles dans les 24 langues suivantes :

Langue Code BCP-47 Langue Code BCP-47
Arabe (Égypte) ar-EG Allemand (Allemagne) de-DE
Anglais (États-Unis) en-US Espagnol (États-Unis) es-US
Français (France) fr-FR Hindi (Inde) hi-IN
Indonésien (Indonésie) id-ID Italien (Italie) it-IT
Japonais (Japon) ja-JP Coréen (Corée) ko-KR
Portugais (Brésil) pt-BR Russe (Russie) ru-RU
Néerlandais (Pays-Bas) nl-NL Polonais (Pologne) pl-PL
Thaï (Thaïlande) th-TH Turc (Turquie) tr-TR
Vietnamien (Viêt Nam) vi-VN Roumain (Roumanie) ro-RO
Ukrainien (Ukraine) uk-UA Bengali (Bangladesh) bn-BD
Anglais (Inde) Pack en-IN et hi-IN Marathi (Inde) mr-IN
Tamoul (Inde) ta-IN Télougou (Inde) te-IN

Modèles compatibles

Modèle Locuteur unique Multihaut-parleur
TTS Gemini 2.5 Flash (preview) ✔️ ✔️
TTS Gemini 2.5 Pro (version preview) ✔️ ✔️

Limites

  • Les modèles TTS ne peuvent recevoir que des entrées de texte et générer des sorties audio.
  • Une session TTS est limitée à une fenêtre de contexte de 32 000 jetons.
  • Consultez la section Langues pour connaître les langues disponibles.

Étape suivante