Gemini-TTS

Testar o Gemini-TTS no Vertex AI Studio Testar no Colab Ver o notebook no GitHub

O Gemini-TTS é a mais recente evolução da nossa tecnologia Cloud TTS que vai além da fala com som natural e oferece controle granular sobre o áudio gerado usando comandos baseados em texto. Com o Gemini-TTS, você pode sintetizar falas de um ou vários locutores, de pequenos trechos a longas narrativas, ditando com precisão o estilo, o sotaque, o ritmo, o tom e até a expressão emocional usando comandos em linguagem natural.

Modelos disponíveis

O Gemini TTS inclui os seguintes modelos disponíveis:

Gemini 2.5 Flash TTS

ID do modelo gemini-2.5-flash-tts
Otimizado para Geração de áudio da Cloud TTS controlável e de baixa latência com um ou vários locutores para aplicativos econômicos do dia a dia.
Modalidades de entrada e saída
  • Entrada: texto
  • Saída: áudio
Número de locutores suportado Um ou vários locutores
Formatos de áudio de saída compatíveis
  • Unário: LINEAR16 (padrão), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • Streaming: PCM (padrão), ALAW, MULAW, OGG_OPUS
Regiões compatíveis global
Opções de voz Consulte Opções de voz
Idiomas disponíveis Veja os idiomas disponíveis
Exemplo 
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 (pré-lançamento)

ID do modelo gemini-2.5-flash-lite-preview-tts
Otimizado para Geração de áudio da Cloud TTS controlável e de baixa latência com um único locutor para aplicativos econômicos do dia a dia. Esse modelo está em pré-lançamento.
Modalidades de entrada e saída
  • Entrada: texto
  • Saída: áudio
Número de locutores suportado Um locutor
Formatos de áudio de saída compatíveis
  • Unário: LINEAR16 (padrão), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • Streaming: PCM (padrão), ALAW, MULAW, OGG_OPUS
Regiões compatíveis global
Opções de voz Consulte Opções de voz
Idiomas disponíveis Veja os idiomas disponíveis
Exemplo 
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 do modelo gemini-2.5-pro-tts
Otimizado para Alto controle para fluxos de trabalho estruturados, como geração de podcasts, audiolivros, suporte ao cliente e muito mais.
Modalidades de entrada e saída
  • Entrada: texto
  • Saída: áudio
Número de locutores suportado Um ou vários locutores
Formatos de áudio de saída compatíveis
  • Unário: LINEAR16 (padrão), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • Streaming: PCM (padrão), ALAW, MULAW, OGG_OPUS
Regiões compatíveis global
Opções de voz Consulte Opções de voz
Idiomas disponíveis Veja os idiomas disponíveis
Exemplo 
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"

Outros controles

Outros controles e recursos incluem:

  1. Conversa natural: interações por voz de qualidade notável, com expressividade e padrões de ritmo mais adequadas, além de latência muito baixa para conversar com fluidez.

  2. Controle de estilo: com comandos de linguagem natural, você pode adaptar a maneira como a conversa ocorre, direcionando-a para adotar sotaques específicos e produzir diversos tons e expressões, incluindo sussurros.

  3. Desempenho dinâmico: esses modelos dão vida ao texto com leituras expressivas de poesias, noticiários e narrativas envolventes. Eles também podem produzir emoções específicas e sotaques, quando solicitado.

  4. Controle aprimorado de ritmo e pronúncia: controlar a velocidade da fala ajuda a garantir mais precisão na pronúncia, incluindo palavras específicas.

Para saber como usar essas vozes no seu aplicativo, consulte Usar o Gemini-TTS.

Opções de voz

O Gemini-TTS oferece diversas opções de vozes semelhantes ao Chirp 3: vozes em alta definição, cada uma com características distintas:

Nome Gênero Demonstração
Achernar Feminino
Achird Masculino
Algenib Masculino
Algieba Masculino
Alnilam Masculino
Aoede Feminino
Autonoe Feminino
Callirrhoe Feminino
Charon Masculino
Despina Feminino
Enceladus Masculino
Erinome Feminino
Fenrir Masculino
Gacrux Feminino
Iapetus Masculino
Kore Feminino
Laomedeia Feminino
Leda Feminino
Orus Masculino
Pulcherrima Feminino
Puck Masculino
Rasalgethi Masculino
Sadachbia Masculino
Sadaltager Masculino
Schedar Masculino
Sulafat Feminino
Umbriel Masculino
Vindemiatrix Feminino
Zephyr Feminino
Zubenelgenubi Masculino

Idiomas disponíveis

O Gemini-TTS aceita os seguintes idiomas:

Idioma Código BCP-47 Prontidão para o lançamento
Árabe (Egito) ar-EG Disponibilidade geral
Bengali (Bangladesh) bn-BD Disponibilidade geral
Holandês (Holanda) nl-NL Disponibilidade geral
Inglês (Índia) en-IN Disponibilidade geral
Inglês (Estados Unidos) en-US Disponibilidade geral
Francês (França) fr-FR Disponibilidade geral
Alemão (Alemanha) de-DE Disponibilidade geral
Hindi (Índia) hi-IN Disponibilidade geral
Indonésio (Indonésia) id-ID Disponibilidade geral
Italiano (Itália) it-IT Disponibilidade geral
Japonês (Japão) ja-JP Disponibilidade geral
Coreano (Coreia do Sul) ko-KR Disponibilidade geral
Marathi (Índia) mr-IN Disponibilidade geral
Polonês (Polônia) pl-PL Disponibilidade geral
Português (Brasil) pt-BR Disponibilidade geral
Romeno (Romênia) ro-RO Disponibilidade geral
Russo (Rússia) ru-RU Disponibilidade geral
Espanhol (Espanha) es-ES Disponibilidade geral
Tamil (Índia) ta-IN Disponibilidade geral
Telugu (Índia) te-IN Disponibilidade geral
Tailandês (Tailândia) th-TH Disponibilidade geral
Turco (Turquia) tr-TR Disponibilidade geral
Ucraniano (Ucrânia) uk-UA Disponibilidade geral
Vietnamita (Vietnã) vi-VN Disponibilidade geral
Afrikaans (África do Sul) af-ZA Pré-lançamento
Albanês (Albânia) sq-AL Pré-lançamento
Amárico (Etiópia) am-ET Pré-lançamento
Árabe (mundo) ar-001 Pré-lançamento
Armênio (Armênia) hy-AM Pré-lançamento
Azerbaijano (Azerbaijão) az-AZ Pré-lançamento
Basco (Espanha) eu-ES Pré-lançamento
Bielorrusso (Bielorrússia) be-BY Pré-lançamento
Búlgaro (Bulgária) bg-BG Pré-lançamento
Birmanês (Mianmar) my-MM Pré-lançamento
Catalão (Espanha) ca-ES Pré-lançamento
Cebuano (Filipinas) ceb-PH Pré-lançamento
Chinês, mandarim (China) cmn-CN Pré-lançamento
Chinês, mandarim (Taiwan) cmn-tw Pré-lançamento
Croata (Croácia) hr-HR Pré-lançamento
Checo (República Tcheca) cs-CZ Pré-lançamento
Dinamarquês (Dinamarca) da-DK Pré-lançamento
Inglês (Austrália) en-AU Pré-lançamento
Inglês (Reino Unido) en-GB Pré-lançamento
Estoniano (Estônia) et-EE Pré-lançamento
Filipino (Filipinas) fil-PH Pré-lançamento
Finlandês (Finlândia) fi-FI Pré-lançamento
Francês (Canadá) fr-CA Pré-lançamento
Galego (Espanha) gl-ES Pré-lançamento
Georgiano (Geórgia) ka-GE Pré-lançamento
Grego (Grécia) el-GR Pré-lançamento
Gujarati (Índia) gu-IN Pré-lançamento
Crioulo haitiano (Haiti) ht-HT Pré-lançamento
Hebraico (Israel) he-IL Pré-lançamento
Húngaro (Hungria) hu-HU Pré-lançamento
Islandês (Islândia) is-IS Pré-lançamento
Javanês (Java) jv-JV Pré-lançamento
Canarês (Índia) kn-IN Pré-lançamento
Concani (Índia) kok-IN Pré-lançamento
Lao (Laos) lo-LA Pré-lançamento
Latim (Cidade do Vaticano) la-VA Pré-lançamento
Letão (Letônia) lv-LV Pré-lançamento
Lituano (Lituânia) lt-LT Pré-lançamento
Luxemburguês (Luxemburgo) lb-LU Pré-lançamento
Macedônio (Macedônia do Norte) mk-MK Pré-lançamento
Maithili (Índia) mai-IN Pré-lançamento
Malgaxe (Madagascar) mg-MG Pré-lançamento
Malaio (Malásia) ms-MY Pré-lançamento
Malaiala (Índia) ml-IN Pré-lançamento
Mongol (Mongólia) mn-MN Pré-lançamento
Nepalês (Nepal) ne-NP Pré-lançamento
Bokmål norueguês (Noruega) nb-NO Pré-lançamento
Nynorsk norueguês (Noruega) nn-NO Pré-lançamento
Oriá (Índia) or-IN Pré-lançamento
Pashto (Afeganistão) ps-AF Pré-lançamento
Persa (Irã) fa-IR Pré-lançamento
Português (Portugal) pt-PT Pré-lançamento
Punjabi (Índia) pa-IN Pré-lançamento
Sérvio (Sérvia) sr-RS Pré-lançamento
Sindi (Índia) sd-IN Pré-lançamento
Cingalês (Sri Lanka) si-LK Pré-lançamento
Eslovaco (Eslováquia) sk-SK Pré-lançamento
Esloveno (Eslovênia) sl-SI Pré-lançamento
Espanhol (América Latina) es-419 Pré-lançamento
Espanhol (México) es-MX Pré-lançamento
Swahili (Quênia) sw-KE Pré-lançamento
Sueco (Suécia) sv-SE Pré-lançamento
Urdu (Paquistão) ur-PK Pré-lançamento

Usar o Gemini-TTS

Saiba como usar os modelos Gemini-TTS para sintetizar falas de uma ou várias pessoas.

Se quiser, especifique formatos de áudio e taxas de amostragem no campo "audioConfig" se precisar de opções diferentes das padrão.

Descrição Limite Tipo
Campo de texto Menor ou igual a 4.000 bytes. Entrada
Campo de comando Menor ou igual a 4.000 bytes. Entrada
Campos de texto e comando Menor ou igual a 8.000 bytes. Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada resultar em um áudio com mais de 655 segundos, ele ficará truncado. Saída

Antes de começar

Antes de começar a usar a Cloud Text-to-Speech, siga estas etapas para ativar a API no console doGoogle Cloud :

  1. Ative a Cloud Text-to-Speech em um projeto.
  2. Verifique se o faturamento está ativado para a Cloud Text-to-Speech.
  3. Configure a autenticação para o ambiente de desenvolvimento.

Configurar o projeto do Google Cloud

  1. Fazer login no console do Google Cloud

  2. Acessar a página do seletor de projetos.

    É possível escolher um projeto existente ou criar um novo. Para saber mais sobre a criação de um projeto, consulte a documentação doGoogle Cloud .

  3. Quando você cria um projeto, recebe uma mensagem que informa que é necessário vincular uma conta de faturamento. Ao usar um projeto atual, você precisa ativar o faturamento.

    Aprenda a confirmar se o faturamento está ativado para o projeto

  4. Depois de selecionar um projeto e vincular uma conta de faturamento a ele, é possível ativar a API Cloud Text-to-Speech. Acesse a barra Pesquisar produtos e recursos na parte de cima da página e digite "speech". Selecione a API Cloud Text-to-Speech na lista de resultados.

  5. Para testar a Cloud Text-to-Speech sem vinculação ao projeto, escolha a opção Testar esta API. Para ativar a API Cloud Text-to-Speech para uso no projeto, clique em Ativar.

  6. Configure a autenticação para o ambiente de desenvolvimento. Para instruções, consulte Configurar a autenticação para a Cloud Text-to-Speech.

Realizar a síntese síncrona de locutor único

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

Realizar a síntese de streaming de locutor único

A síntese de streaming é adequada para aplicativos em tempo real em que respostas rápidas são essenciais para a experiência do usuário. Em uma conexão de streaming, a API retorna o áudio em pequenos blocos à medida que ele fica disponível.

Como autor da chamada da API, certifique-se de consumir os trechos de áudio, transmitindo-os para os clientes à medida que chegam (por exemplo, usando socketio para apps da web).

Embora seja possível enviar os blocos de entrada para a API de forma assíncrona, conforme mostrado em request_generator, a API só vai começar a sintetizar quando o cliente enviar Half-Close como um sinal de que não enviará mais dados para a API.

O campo prompt precisa ser definido no primeiro bloco de entrada, porque é ignorado nos blocos consecutivos.

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

Realizar a síntese síncrona de vários locutores com entradas de texto livre

Descrição Restrições e limites Tipo
Campo de texto Menor ou igual a 4.000 bytes Entrada
Campo de comando Menor ou igual a 4.000 bytes Entrada
Campos de texto e comando Menor ou igual a 8.000 bytes Entrada
Aliases de falantes Caracteres alfanuméricos e sem espaços em branco Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada resultar em um áudio com mais de 655 segundos, ele ficará truncado. Saída

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

Realizar a síntese síncrona de vários falantes com entradas de texto estruturadas

A entrada de texto estruturada com vários falantes permite a verbalização inteligente de textos de maneira semelhante à humana. Por exemplo, esse tipo de entrada é útil para endereços e datas. A entrada de texto livre fala o texto exatamente como ele foi escrito.

Descrição Restrições e limites Tipo
Campo MultiSpeakerMarkUp Menor ou igual a 4.000 bytes Entrada
Campo de comando Menor ou igual a 4.000 bytes Entrada
MultiSpeakerMarkUp e campos de solicitação Menor ou igual a 8.000 bytes Entrada
Aliases de falantes Caracteres alfanuméricos e sem espaços em branco Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada resultar em um áudio com mais de 655 segundos, ele ficará truncado. Saída

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

Usar o Gemini-TTS na API de IA generativa do Google

Saiba como usar os modelos do Gemini-TTS para sintetizar falas de um ou vários locutores usando a API de IA generativa do Google .

Na API Cloud Text-to-Speech, o usuário pode fornecer campos de texto e comando separadamente. A API de IA generativa do Google usa um único campo contents, em que especifica a entrada na forma de "{comando}: {texto}", por exemplo, "Diga o seguinte de um jeito curioso: OK, então... fale mais sobre essa tal de IA."

Na API generativa do Google , a saída são dados de áudio PCM de 16 bits e 24k, sem cabeçalhos WAV. O cliente precisa realizar etapas extras se quiser converter para outro formato de áudio.

Descrição Limite Tipo
Campo de conteúdo Menor ou igual a 8.000 bytes. Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada resultar em um áudio com mais de 655 segundos, ele ficará truncado. Saída

Antes de começar

Antes de começar, siga as etapas de instalação da API de IA generativa doGoogle .

Realizar a síntese síncrona de locutor único

Esses exemplos de código mostram como realizar a síntese síncrona de um único locutor.

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

Realizar a síntese síncrona de vários locutores

Este exemplo de código demonstra como realizar a síntese síncrona de vários locutores.

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

Realizar a síntese de voz no Media Studio

Use o Media Studio no console do Google Google Cloud para testar modelos de conversão de texto em voz. Nele, você acessa uma interface do usuário para gerar, ouvir áudios sintetizados e testar diferentes parâmetros e instruções de estilo com rapidez.

  1. No console do Google Google Cloud , acesse a página Vertex AI Studio > Media Studio.

    Media Studio

  2. Selecione Fala no menu suspenso de mídia.

  3. No campo de texto, digite o texto que você quer sintetizar em fala.

  4. No painel Configurações, defina o seguinte:

    1. Modelo: selecione o modelo da Cloud TTS (TTS) que você quer usar, como Gemini 2.5 Pro TTS. Para mais informações sobre os modelos disponíveis, consulte Modelos da Cloud TTS.
    2. Instruções de estilo (opcional): insira um comando de texto que descreva o estilo de fala, o tom e a emoção selecionados. Com isso, é possível orientar o desempenho do modelo além da narração padrão. Por exemplo: Narração em um tom calmo e profissional para um documentário.
    3. Idioma: selecione o idioma e a região do texto de entrada. O modelo gera a fala no idioma e no sotaque selecionados. Por exemplo, Inglês (Estados Unidos).
    4. Voz: escolha uma voz predefinida para a narração. A lista contém as vozes disponíveis para o modelo e o idioma selecionados, como Acherner (feminino).

  5. Opcional: expanda a seção Opções avançadas para configurar as opções técnicas de áudio:

    1. Codificação de áudio: selecione a codificação do arquivo de áudio de saída. LINEAR16 é um formato sem perdas e sem compressão adequado para processamento de áudio de alta qualidade. MULAW também está disponível para saídas de áudio com compressão.
    2. Taxa de amostragem de áudio: selecione a taxa de amostragem em hertz (Hz). Isso determina a qualidade do áudio. Valores mais altos, como 44.100 Hz, representam um áudio de maior fidelidade, equivalente à qualidade de um CD.
    3. Velocidade: ajuste a taxa de fala movendo o controle deslizante ou inserindo um valor. Valores menores que 1 diminuem a velocidade da fala e valores maiores que 1 aumentam. O padrão é 1.
    4. Ganho de volume (dB): ajuste o volume do áudio de saída em decibéis (dB). Valores positivos aumentam o volume e valores negativos diminuem. O padrão é 0.

  6. Clique no ícone Enviar à direita da caixa de texto para gerar o áudio.

  7. O áudio gerado aparece no player de mídia. Clique no botão de reprodução para ouvir a saída. Você pode continuar ajustando as configurações e gerando novas versões conforme necessário.

Dicas de comandos

Para criar áudios envolventes e com som natural a partir de textos, você precisa entender as nuances da linguagem falada e traduzi-las para um formato de script. As dicas a seguir vão ajudar você a criar scripts que forneçam um som autêntico e capturem o tom escolhido.

Os três fatores do controle de fala

Para ter resultados mais previsíveis e detalhados, verifique se os três componentes a seguir são consistentes com a saída pretendida.

Comando de estilo O principal fator do tom emocional geral e da maneira como a fala ocorre. Esse comando define o contexto para todo o segmento de fala.

  • Exemplo: You are an AI assistant speaking in a friendly and helpful tone.

  • Exemplo: Narrate this in the calm, authoritative tone of a nature documentary narrator.

Conteúdo do texto O significado semântico das palavras que você está sintetizando. Uma frase evocativa que seja emocionalmente consistente com o comando de estilo vai produzir resultados muito mais confiáveis do que um texto neutro.

  • Bom: um comando para um tom assustado funciona melhor com textos como I think someone is in the house.

  • Menos eficaz: um comando para um tom assustado vai gerar resultados ambíguos com um texto como The meeting is at 4 PM..

Tags de marcação (pré-lançamento): tags entre colchetes, como [sigh], são mais adequadas para inserir uma ação específica e localizada ou uma modificação de estilo, não para definir o tom geral. Elas funcionam com o comando de estilo e o conteúdo do texto.

Guia de tags de marcação

Nossa pesquisa mostra que as tags de marcação entre colchetes operam em um de três modos distintos. Entender o modo de uma tag é fundamental para usá-la de maneira eficaz.

Modo 1: sons que não são de fala

A marcação é substituída por uma vocalização audível e não verbal, como um suspiro ou uma risada. A tag em si não é falada. Elas são excelentes para adicionar hesitações e reações realistas e semelhantes às humanas.

Tag Comportamento Confiabilidade Orientação
[sigh] Insere um som de suspiro. Alta A qualidade emocional do suspiro é influenciada pelo comando.
[laughing] Insere uma risada. Alta Para ter os melhores resultados, use um comando específico. Por exemplo, um comando genérico pode gerar uma risada de choque, enquanto "reaja com uma risada divertida" cria uma risada de diversão.
[uhm] Insere um som de hesitação. Alta Útil para criar uma sensação mais natural e um clima de conversa.

Modo 2: modificadores de estilo

A marcação não é falada, mas modifica a maneira como a fala seguinte ocorre. O escopo e a duração da modificação podem variar.

Tag Comportamento Confiabilidade Orientação
[sarcasm] Dá um tom sarcástico à frase seguinte. Alta Essa tag é um modificador eficiente. Ela ajuda a demonstrar que conceitos abstratos podem direcionar a forma como o modelo produz a fala.
[robotic] Faz com que a fala seguinte soe robótica. Alta O efeito pode se estender por toda uma frase. Um comando de estilo de apoio (por exemplo, "Diga isso de maneira robótica") ainda é recomendado para ter resultados melhores.
[shouting] Aumenta o volume da fala seguinte. Alta Mais eficaz quando combinado com um comando de estilo correspondente (por exemplo, "Grite a próxima parte") e um texto que implica gritos.
[whispering] Diminui o volume da fala seguinte. Alta Os melhores resultados são alcançados quando o comando de estilo também é explícito (por exemplo, "agora sussurre esta parte o mais baixo possível").
[extremely fast] Aumenta a velocidade da fala seguinte. Alta Ideal para avisos legais ou diálogos rápidos. Não é necessário ter muitos comandos.

Modo 3: marcação vocalizada (adjetivos)

A tag de marcação é falada como uma palavra, além de influenciar o tom de toda a frase. Em geral, esse comportamento se aplica a adjetivos emocionais.

Aviso: como a tag é falada, esse modo provavelmente é um efeito colateral indesejado para a maioria dos casos de uso. Prefira usar o comando de estilo para definir esses tons emocionais.

Tag Comportamento Confiabilidade Orientação
[scared] A palavra "assustado" é falada e a frase adota um tom assustado. Alta O desempenho depende muito do conteúdo do texto. A frase "Acabei de ouvir uma janela quebrar" produz um resultado genuinamente assustado. Uma frase neutra produz um resultado "assustador", mas menos autêntico.
[curious] A palavra "curioso" é falada, e a frase adota um tom curioso. Alta Use uma frase inquisitiva para apoiar a intenção da tag.
[bored] A palavra "entediado" é falada e a frase adota uma entonação monótona e entediada. Alta Use com textos comuns ou repetitivos para ter o melhor efeito.

Modo 4: ritmo e pausas

Essas tags inserem silêncio no áudio gerado, oferecendo controle granular sobre ritmo, tempo e andamento. A pontuação padrão (vírgulas, pontos, ponto e vírgulas) também cria pausas naturais, mas essas tags oferecem um controle mais explícito.

Tag Comportamento Confiabilidade Orientação
[short pause] Insere uma breve pausa, semelhante a uma vírgula (~250 ms). Alta Use para separar cláusulas ou itens de uma lista de modo a melhorar a clareza.
[medium pause] Insere uma pausa padrão, semelhante a uma quebra de frase (~500 ms). Alta Eficaz para separar frases ou ideias distintas.
[long pause] Insere uma pausa significativa para efeito dramático (~1000 ms ou mais). Alta Use para um efeito dramático. Por exemplo: "A resposta é… [long pause]... não." Evite o uso excessivo para não soar artificial.

Principais estratégias para conseguir resultados confiáveis

  • Alinhar os três fatores: para ter previsibilidade máxima, garanta que o comando de estilo, o conteúdo do texto e as tags de marcação sejam semanticamente consistentes e trabalhem em alinhamento para atingir a mesma meta.

  • Usar textos emocionalmente ricos : não dependa apenas de comandos e tags. Forneça ao modelo um texto descritivo e rico. Isso é especialmente importante para emoções sutis, como sarcasmo, medo ou empolgação.

  • Escrever comandos específicos e detalhados: quanto mais específico for o comando de estilo, mais confiável será o resultado. "Reaja com uma risada divertida" é melhor do que apenas [laughing]. "Fale como um locutor de rádio dos anos 1940" é melhor do que "Fale de um jeito antigo".

  • Testar e verificar novas tags: o comportamento de uma tag nova ou não testada nem sempre é previsível. Uma tag que você acredita ser um modificador de estilo pode ser vocalizada. Sempre teste uma nova tag ou combinação de comandos para confirmar o comportamento antes de implantar na produção.

Flexibilizar os filtros de segurança

As contas com cobrança por fatura mensal podem configurar solicitações para flexibilizar os filtros de segurança usando o campo relax_safety_filters em AdvancedVoiceOptions. O campo relax_safety_filters só está ativado para contas com cobrança por fatura mensal.

Flexibilizar os filtros de segurança diminui o limite de bloqueio para a sintetização de conteúdo nocivo.

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