Gemini-TTS

Experimente o Gemini-TTS no Vertex AI Studio Experimentar no Colab Ver bloco de notas no GitHub

O Gemini-TTS é a mais recente evolução da nossa tecnologia Cloud TTS que vai além da voz com som natural e oferece um controlo detalhado sobre o áudio gerado através de comandos baseados em texto. Com o Gemini-TTS, pode sintetizar a fala de um ou vários oradores a partir de pequenos fragmentos até narrativas longas, ditando com precisão o estilo, o sotaque, o ritmo, o tom e até a expressão emocional, tudo controlável através de comandos de 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 de TTS na nuvem de baixa latência, controlável, com um ou vários altifalantes para aplicações diárias económicas
Modalidades de entrada e saída
  • Entrada: texto
  • Saída: áudio
Suporte de número de altifalante Único, com vários oradores
Formatos de áudio de saída suportados
  • Unário: LINEAR16 (predefinição), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • Streaming: PCM (predefinição), ALAW, MULAW e OGG_OPUS
Apoio técnico da região global
Opções de voz Consulte as opções de voz.
Idiomas disponíveis Consulte 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é-visualização)

ID do modelo gemini-2.5-flash-lite-preview-tts
Otimizado para Geração de áudio de TTS na nuvem de baixa latência, controlável e com um único orador para aplicações diárias rentáveis. Tenha em atenção que este modelo está em pré-visualização.
Modalidades de entrada e saída
  • Entrada: texto
  • Saída: áudio
Suporte de número de altifalante Único
Formatos de áudio de saída suportados
  • Unário: LINEAR16 (predefinição), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • Streaming: PCM (predefinição), ALAW, MULAW e OGG_OPUS
Apoio técnico da região global
Opções de voz Consulte as opções de voz.
Idiomas disponíveis Consulte 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 Controlo elevado para fluxos de trabalho estruturados, como geração de podcasts, livros áudio, apoio ao cliente e muito mais
Modalidades de entrada e saída
  • Entrada: texto
  • Saída: áudio
Suporte de número de altifalante Único, com vários oradores
Formatos de áudio de saída suportados
  • Unário: LINEAR16 (predefinição), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • Streaming: PCM (predefinição), ALAW, MULAW e OGG_OPUS
Apoio técnico da região global
Opções de voz Consulte as opções de voz.
Idiomas disponíveis Consulte 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"

Controlos adicionais

Os controlos e as capacidades adicionais incluem o seguinte:

  1. Conversa natural: as interações de voz de qualidade notável, a expressividade mais adequada e os padrões de ritmo são fornecidos com uma latência muito baixa para que possa conversar de forma fluida.

  2. Controlo de estilo: através de comandos de linguagem natural, pode adaptar a entrega na conversa, direcionando-a para adotar sotaques específicos e produzir uma variedade de tons e expressões, incluindo um sussurro.

  3. Desempenho dinâmico: estes modelos podem dar vida ao texto para leituras expressivas de poesia, noticiários e histórias cativantes. Também pode atuar com emoções específicas e produzir sotaques quando solicitado.

  4. Controlo melhorado do ritmo e da pronúncia: controlar a velocidade de entrega ajuda a garantir uma maior precisão na pronúncia, incluindo palavras específicas.

Para obter informações sobre como usar estas vozes na sua aplicação, consulte o artigo Use o Gemini-TTS.

Opções de voz

O Gemini-TTS oferece uma vasta gama de opções de voz semelhantes às nossas vozes HD do Chirp 3 existentes, cada uma com características distintas:

Nome Género Demonstrações
Achernar Feminino
Achird Masculino
Algenib Masculino
Algieba Masculino
Alnilam Masculino
Aoede Feminino
Autonoe Feminino
Callirrhoe Feminino
Caronte Masculino
Despina Feminino
Encélado Masculino
Erinome Feminino
Fenrir Masculino
Gacrux Feminino
Jápeto Masculino
Kore Feminino
Laomedeia Feminino
Leda Feminino
Orus Masculino
Pulcherrima Feminino
Disco 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 é compatível com os seguintes idiomas:

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

Use o Gemini-TTS

Descubra como usar os modelos Gemini-TTS para sintetizar a fala de um único orador e de vários oradores.

Opcionalmente, especifique os formatos de áudio e as taxas de amostragem no campo "audioConfig" se forem necessárias opções não predefinidas.

Descrição Limite Tipo
Campo de texto Inferior ou igual a 4000 bytes. Entrada
Campo de comando Inferior ou igual a 4000 bytes. Entrada
Campos de texto e de comando Inferior ou igual a 8000 bytes. Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada fizer com que o áudio exceda os 655 segundos, o áudio é truncado. Resultado

Antes de começar

Antes de poder começar a usar o Cloud Text-to-Speech, tem de ativar a API na Google Cloud consola seguindo os passos:

  1. Ative o Cloud Text-to-Speech num projeto.
  2. Certifique-se de que a faturação está ativada para o Cloud Text-to-Speech.
  3. Configure a autenticação para o seu ambiente de desenvolvimento.

Configure o seu Google Cloud projeto

  1. Inicie sessão na Google Cloud consola

  2. Aceda à página do seletor de projetos

    Pode escolher um projeto existente ou criar um novo. Para mais detalhes sobre como criar um projeto, consulte a Google Cloud documentação.

  3. Se criar um novo projeto, é apresentada uma mensagem a informar que tem de associar uma conta de faturação. Se estiver a usar um projeto pré-existente, certifique-se de que ativa a faturação

    Saiba como confirmar que a faturação está ativada para o seu projeto

  4. Depois de selecionar um projeto e associá-lo a uma conta de faturação, pode ativar a API Cloud Text-to-Speech. Aceda à barra Pesquisar produtos e recursos na parte superior da página e escreva "voz". Selecione a Cloud Text-to-Speech API na lista de resultados.

  5. Para experimentar o Cloud Text-to-Speech sem o associar ao seu projeto, escolha a opção Experimentar esta API. Para ativar a API Cloud Text-to-Speech para utilização com o seu projeto, clique em Ativar.

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

Realize a síntese síncrona de uma única pessoa

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

Realize a síntese de um único orador em streaming

A síntese de streaming é adequada para aplicações em tempo real em que a resposta rápida é fundamental para a experiência do utilizador. Na ligação de streaming, a API devolve áudio à medida que fica disponível em pequenos blocos.

Como autor da chamada da API, certifique-se de que consome os fragmentos de áudio, transmitindo-os aos seus clientes à medida que chegam (por exemplo, usando socketio para apps Web).

Embora seja possível enviar os fragmentos de entrada para a API de forma assíncrona, conforme mostrado no request_generator, a API só começa a fazer a síntese quando o cliente envia Half-Close como um sinal de que não vai enviar mais dados para a API.

O campo prompt tem de 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

Realize a síntese síncrona de vários oradores com entrada de texto de forma livre

Descrição Restrições e limites Tipo
Campo de texto Inferior ou igual a 4000 bytes Entrada
Campo de comando Inferior ou igual a 4000 bytes Entrada
Campos de texto e de comando Inferior ou igual a 8000 bytes Entrada
Aliases de altifalantes Carateres alfanuméricos e sem espaços em branco Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada fizer com que o áudio exceda os 655 segundos, o áudio é truncado. Resultado

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

Realize a síntese síncrona de vários oradores com entrada de texto estruturado

A funcionalidade de vários oradores com entrada de texto estruturado permite a verbalização inteligente de texto de uma forma semelhante à humana. Por exemplo, este tipo de entrada é útil para moradas e datas. A entrada de texto de forma livre pronuncia o texto exatamente como foi escrito.

cada campo de comando e caixa de diálogo tem de ter um máximo de 4000 bytes.
Descrição Restrições e limites Tipo
Campo MultiSpeakerMarkUp Inferior ou igual a 4000 bytes Entrada
Campo de comando Inferior ou igual a 4000 bytes Entrada
MultiSpeakerMarkUp e campos de comando Inferior ou igual a 8000 bytes Entrada
Aliases de altifalantes Carateres alfanuméricos e sem espaços em branco Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada fizer com que o áudio exceda os 655 segundos, o áudio é truncado. Resultado

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

Use o Gemini-TTS na Google API de IA generativa

Descubra como usar os modelos Gemini-TTS para sintetizar a fala de um único orador e de vários oradores através da Google API de IA generativa.

Na Cloud Text-to-Speech API, o utilizador pode fornecer campos de texto e comandos separadamente. Na API de IA generativa, este é um único campo contents, onde especifica a entrada sob a forma de "{comando}: {texto}", por exemplo: Google "Diz o seguinte de forma curiosa: OK, então… fala-me desta coisa da IA."

Na API de IA Google generativa, a saída são dados de áudio PCM de 16 bits a 24 k, e não tem cabeçalhos WAV. Se quiserem fazer a conversão para outro formato de áudio, os clientes têm de realizar passos adicionais.

Descrição Limite Tipo
Campo de conteúdos Inferior ou igual a 8000 bytes. Entrada
Duração do áudio de saída Aproximadamente 655 segundos. Se o texto de entrada fizer com que o áudio exceda os 655 segundos, o áudio é truncado. Resultado

Antes de começar

Antes de começar, siga os passos de instalação da Google API de IA generativa.

Realize a síntese síncrona de uma única pessoa

Estes exemplos de código demonstram como realizar a síntese síncrona de um único orador.

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 síntese síncrona de vários altifalantes

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

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

Realize a síntese de voz no Media Studio

Pode usar o Media Studio na consola Google Cloud Google para experimentar modelos de conversão de texto em voz. Isto fornece uma interface do utilizador para gerar rapidamente, ouvir áudio sintetizado e fazer experiências com diferentes instruções de estilo e parâmetros.

  1. Na consola Google Google Cloud , aceda à página Vertex AI Studio > Media Studio.

    Media Studio

  2. Selecione Voz no menu pendente de multimédia.

  3. No campo de texto, introduza o texto que quer sintetizar em voz.

  4. No painel Definições, configure as seguintes definições:

    1. Modelo: selecione o modelo de TTS (conversão de texto em voz) do Google Cloud que quer usar, como Gemini 2.5 Pro TTS. Para mais informações acerca dos modelos disponíveis, consulte o artigo Modelos de TTS do Google Cloud.
    2. Instruções de estilo: opcional: introduza um comando de texto que descreva o estilo de fala, o tom e a expressão emocional selecionados. Isto permite-lhe orientar o desempenho do modelo além da narração predefinida. Por exemplo: "Narração com um tom calmo e profissional para um documentário.".
    3. Idioma: selecione o idioma e a região do texto introduzido. O modelo gera voz no idioma e 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 secção Opções avançadas para configurar as definições técnicas de áudio:

    1. Codificação de áudio: selecione a codificação para o ficheiro de áudio de saída. O formato LINEAR16 é um formato sem perda de dados e não comprimido adequado para o processamento de áudio de alta qualidade. O MULAW também está disponível para a saída de áudio comprimido.
    2. Taxa de amostragem de áudio: selecione a taxa de amostragem em hertz (Hz). Isto determina a qualidade do áudio. Os valores mais elevados, como 44 100 Hz, representam áudio de maior fidelidade, equivalente à qualidade de CD.
    3. Velocidade: ajuste a velocidade de voz movendo o controlo de deslize ou introduzindo um valor. Os valores inferiores a 1 diminuem a velocidade da fala e os valores superiores a 1 aumentam a velocidade da fala. A predefinição é 1.
    4. Ganho de volume (db): ajuste o volume do áudio de saída em decibéis (dB). Os valores positivos aumentam o volume e os valores negativos diminuem-no. O valor predefinido é 0.

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

  7. O áudio gerado aparece no leitor de multimédia. Clique no botão de reprodução para ouvir o resultado. Pode continuar a ajustar as definições e gerar novas versões conforme necessário.

Sugestões de comandos

A criação de áudio apelativo e com um som natural a partir de texto requer a compreensão das nuances da linguagem falada e a sua tradução para um formato de guião. As seguintes dicas ajudam a criar guiões com um som autêntico e que captam o tom escolhido.

Os três elementos de controlo de voz

Para obter os resultados mais previsíveis e detalhados, certifique-se de que os três componentes seguintes são consistentes com o resultado pretendido.

Comando de estilo O principal fator da tonalidade emocional geral e da apresentação. O comando define o contexto para todo o segmento de voz.

  • 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 de texto O significado semântico das palavras que está a sintetizar. Uma expressão evocativa que seja emocionalmente consistente com o comando de estilo produz resultados muito mais fiáveis do que texto neutro.

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

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

Etiquetas de marcação (pré-visualização) As etiquetas entre parênteses, como [sigh], são mais adequadas para injetar uma ação específica e localizada ou uma modificação de estilo, e não para definir o tom geral. Funcionam em conjunto com o comando de estilo e o conteúdo de texto.

Guia de etiquetas de marcação

A nossa pesquisa mostra que as etiquetas de marcação entre parênteses funcionam num de três modos distintos. Compreender o modo de uma etiqueta é fundamental para a usar eficazmente.

Modo 1: sons que não são discurso

A marcação é substituída por uma vocalização audível que não é discurso (por exemplo, um suspiro ou uma gargalhada). A etiqueta em si não é falada. São excelentes para adicionar hesitações e reações realistas, semelhantes às humanas.

Etiqueta Comportamento Fiabilidade Orientação
[sigh] Insere um som de suspiro. Alto A qualidade emocional do suspiro é influenciada pelo comando.
[laughing] Insere um riso. Alto Para ter os melhores resultados, use um comando específico. Por exemplo, um comando genérico pode gerar uma gargalhada de choque, enquanto "reage com uma gargalhada divertida" cria uma gargalhada de diversão.
[uhm] Insere um som de hesitação. Alto Útil para criar um ambiente mais natural e conversacional.

Modo 2: modificadores de estilo

A marcação não é falada, mas modifica a transmissão da fala subsequente. O âmbito e a duração da modificação podem variar.

Etiqueta Comportamento Fiabilidade Orientação
[sarcasm] Transmite um tom sarcástico à expressão seguinte. Alto Esta etiqueta é um modificador poderoso. Demonstra que os conceitos abstratos podem orientar com êxito a publicação do modelo.
[robotic] Faz com que a voz seguinte soe robótica. Alto O efeito pode abranger toda uma expressão. Um comando de estilo de apoio (por exemplo, "Diz isto de forma robótica") continua a ser recomendado para obter os melhores resultados.
[shouting] Aumenta o volume da fala seguinte. Alto Mais eficaz quando usado com um comando de estilo correspondente (por exemplo, "Shout this next part") e texto que implica gritar.
[whispering] Diminui o volume da voz seguinte. Alto Os melhores resultados são alcançados quando o comando de estilo também é explícito (por exemplo, "agora, sussurra esta parte o mais silenciosamente possível").
[extremely fast] Aumenta a velocidade da fala subsequente. Alto Ideal para exclusões de responsabilidade ou diálogos rápidos. Apoio técnico mínimo de comandos necessário.

Modo 3: marcação vocalizada (adjetivos)

A etiqueta de marcação em si é falada como uma palavra, ao mesmo tempo que influencia o tom de toda a frase. Este comportamento aplica-se normalmente a adjetivos emocionais.

Aviso: uma vez que a etiqueta em si é falada, é provável que este modo seja um efeito secundário indesejável para a maioria dos exemplos de utilização. Em alternativa, prefira usar o comando de estilo para definir estes tons emocionais.

Etiqueta Comportamento Fiabilidade Orientação
[scared] A palavra "assustado" é dita e a frase adota um tom assustado. Alto O desempenho depende muito do conteúdo de texto. A expressão "Acabei de ouvir um vidro a partir-se" produz um resultado genuinamente assustado. Uma expressão neutra produz um resultado "assustador", mas menos autêntico.
[curious] A palavra "curioso" é falada e a frase adota um tom curioso. Alto Use uma expressão inquisitiva para apoiar a intenção da etiqueta.
[bored] A palavra "entediado" é dita e a frase adota uma entoação monótona e aborrecida. Alto Use com texto banal ou repetitivo para obter o melhor efeito.

Modo 4: ritmo e pausas

Estas etiquetas inserem silêncio no áudio gerado, o que lhe dá um controlo detalhado sobre o ritmo, o tempo e o andamento. A pontuação padrão (vírgulas, pontos, pontos e vírgulas) também cria pausas naturais, mas estas etiquetas oferecem um controlo mais explícito.

Etiqueta Comportamento Fiabilidade Orientação
[short pause] Insere uma breve pausa, semelhante a uma vírgula (~250 ms). Alto Use para separar cláusulas ou itens de listas para maior clareza.
[medium pause] Insere uma pausa padrão, semelhante a uma pausa entre frases (~500 ms). Alto Eficaz para separar frases ou pensamentos distintos.
[long pause] Insere uma pausa significativa para efeito dramático (~1000 ms ou mais). Alto Use para criar efeitos dramáticos. Por exemplo: "A resposta é… [long pause] …não." Evite a utilização excessiva, uma vez que pode soar artificial.

Estratégias importantes para resultados fiáveis

  • Alinhe os três elementos: Para uma previsibilidade máxima, certifique-se de que o comando de estilo, o conteúdo de texto e todas as etiquetas de marcação são semanticamente consistentes e estão a trabalhar em função do mesmo objetivo.

  • Use texto emocionalmente rico: não confie apenas em comandos e etiquetas. Forneça ao modelo texto rico e descritivo para trabalhar. Isto é especialmente importante para emoções complexas, como sarcasmo, medo ou entusiasmo.

  • Escreva comandos específicos e detalhados: quanto mais específico for o comando de estilo, mais fiável é o resultado. "Reage com uma risada divertida" é melhor do que apenas [laughing]. "Fala como um locutor de notícias de rádio dos anos 40" é melhor do que "Fala à moda antiga".

  • Teste e valide novas etiquetas: o comportamento de uma etiqueta nova ou não testada nem sempre é previsível. Uma etiqueta que considera um modificador de estilo pode ser vocalizada. Teste sempre uma nova combinação de etiqueta ou comando para confirmar o respetivo comportamento antes da implementação em produção.

Desativar os filtros de segurança

As contas com faturação mensal podem configurar pedidos para relaxar os filtros de segurança através do campo relax_safety_filters em AdvancedVoiceOptions. O campo relax_safety_filters só está ativado para contas com faturação mensal.

A diminuição dos filtros de segurança reduz o limite de bloqueio de conteúdo prejudicial de ser sintetizado.

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