Esta página foi traduzida pela API Cloud Translation.

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, desde pequenos fragmentos a 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	Consulte as regiões disponíveis.
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 um único orador, com baixa latência e controlável 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	Consulte as regiões disponíveis.
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	Consulte as regiões disponíveis.
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:

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.
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.
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.
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 escolher a API certa para usar estas vozes na sua aplicação, consulte o artigo Escolha a API certa.

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 suporta 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

Regiões disponíveis

O Gemini-TTS está disponível em várias regiões através da Cloud Text-to-Speech API ou da Vertex AI API.

O processamento de ML para estes modelos ocorre na região específica ou em várias regiões onde o pedido é feito. Para mais informações , consulte o artigo Residência de dados.

Para a API Cloud Text-to-Speech, são suportadas as seguintes regiões:

Região	País ou jurisdição	Modelos disponíveis
`global`	Global (Non-DRZ)	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`eu`	União Europeia	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`northamerica-northeast1`	Canadá	`gemini-2.5-flash-tts` `gemini-2.5-flash-lite-preview-tts`

Pode aceder a estas regiões através dos seguintes pontos finais da API: <REGION>-texttospeech.googleapis.com. Tenha em atenção que a região global não tem um prefixo: texttospeech.googleapis.com.

Para a API Vertex AI, são suportadas as seguintes regiões:

Região	País ou jurisdição	Modelos disponíveis
`global`	Global (Non-DRZ)	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-central2`	União Europeia	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-north1`	União Europeia	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-southwest1`	União Europeia	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west1`	União Europeia	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west4`	União Europeia	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`northamerica-northeast1`	Canadá	`gemini-2.5-flash-tts` `gemini-2.5-flash-lite-preview-tts`
`us-central1`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east1`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east4`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east5`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-south1`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-west1`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-west4`	Estados Unidos	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`

Pode aceder a estas regiões através dos seguintes pontos finais da API: <REGION>-aiplatform.googleapis.com. Tenha em atenção que a global região não tem um prefixo: aiplatform.googleapis.com.

Escolha a API certa

Descubra como usar os modelos Gemini-TTS para sintetizar a fala de um único orador e de vários oradores através da API Cloud Text-to-Speech ou da API Vertex AI.

O Gemini-TTS está disponível através de duas APIs para ajudar a simplificar o processo de integração para os clientes. Cloud Text-to-Speech API e Vertex AI API, com pontos finais REST e SDKs em várias linguagens de programação.

Seguem-se algumas diretrizes para ajudar a escolher a API certa.

Se se aplicar o seguinte, escolha a Cloud Text-to-Speech API:

Se estiver a usar o Chirp 3 HD ou outras vozes, pode continuar a usar a mesma API Cloud Text-to-Speech com atualizações incrementais mínimas.
Se precisar de tipos de codificação de saída específicos, a API Cloud Text-to-Speech pode especificar a codificação de áudio. Na API Vertex AI, a saída são dados de áudio PCM de 16 bits a 24 kHz e não tem cabeçalhos WAV. Se quiser converter para outro formato de áudio, a conversão tem de ser processada no lado do cliente.
Se tiver de transmitir texto em vários blocos, a API Cloud Text-to-Speech suporta a interação com vários pedidos e várias respostas. Por outro lado, a API Vertex AI suporta um único pedido e várias respostas.

Se se aplicar o seguinte, escolha a API Vertex AI:

Se já estiver a usar o Gemini-TTS a partir do AI Studio, pode mudar para o Vertex AI de forma integrada para tirar partido da escalabilidade e da conformidade Google Cloud.
Se estiver a usar a API Vertex AI para outros modelos, a estrutura da API unificada facilita o início da utilização do Gemini-TTS especificando o nome do modelo e as opções de seleção de voz.

Use a Cloud Text-to-Speech API

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:

Ative o Cloud Text-to-Speech num projeto.
Certifique-se de que a faturação está ativada para o Cloud Text-to-Speech.
Configure a autenticação para o seu ambiente de desenvolvimento.
Atribua a autorização aiplatform.endpoints.predict ao utilizador autenticado. Esta autorização pode ser concedida com a função roles/aiplatform.user.
Selecione o ponto final da API correto com base nas regiões disponíveis.

Configure o seu Google Cloud projeto

Inicie sessão na Google Cloud consola
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.
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

Nota: tem de ativar a faturação para usar a API Cloud Text-to-Speech. No entanto, não lhe será cobrado nenhum valor, a menos que exceda a quota gratuita. Para mais informações sobre preços, consulte a página de preços.
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.
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.
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.

Definir ponto final da API para a região preferencial

Pode escolher um ponto final com base nas regiões disponíveis.

Python

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
TTS_LOCATION = os.getenv("GOOGLE_CLOUD_REGION")

API_ENDPOINT = (
    f"{TTS_LOCATION}-texttospeech.googleapis.com"
    if TTS_LOCATION != "global"
    else "texttospeech.googleapis.com"
)
client = texttospeech.TextToSpeechClient(
    client_options=ClientOptions(api_endpoint=API_ENDPOINT)
)

CURL

GLOBAL_API_ENDPOINT=https://texttospeech.googleapis.com
REGIONAL_API_ENDPOINT=https://YOUR_REGION-texttospeech.googleapis.com

Realize a síntese síncrona de um único orador

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

A Cloud Text-to-Speech API suporta a transmissão em fluxo do tipo multiple request multiple response. 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 de 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 a API Vertex AI

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

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

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 API Vertex AI. Para tirar partido das opções de residência dos dados, certifique-se de que define o LOCATION com base nas regiões disponíveis.

Realize a síntese síncrona de um único orador

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 = os.getenv("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

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

Na API Vertex AI, a transmissão em fluxo unidirecional é suportada, ou seja, o cliente envia um único pedido e recebe um fluxo de respostas.

Este exemplo de código demonstra como realizar a síntese de streaming de um único orador.

Python

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

PROJECT_ID = os.getenv("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)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize.
        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 = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
          language_code=locale,
          voice_config=types.VoiceConfig(
              prebuilt_voice_config=types.PrebuiltVoiceConfig(
                voice_name=voice,
              )
          )
        ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # 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()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # 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", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    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")

    return final_audio_data

audio_data = synthesize(
    "Say the following in a curious way: Radio Bakery is a New York City gem, celebrated for its exceptional and creative baked goods. The pistachio croissant is often described as a delight with perfect sweetness. The rhubarb custard croissant is a lauded masterpiece of flaky pastry and tart filling. The brown butter corn cake stands out with its crisp edges and rich flavor. Despite the bustle, the staff consistently receives praise for being friendly and helpful.",
    "gemini-2.5-flash-tts",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

Realize a síntese síncrona de vários oradores

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

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

serviceusage.services.use

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.

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

Media Studio
Selecione Voz no menu pendente de multimédia.
No campo de texto, introduza o texto que quer sintetizar em voz.
No painel Definições, configure as seguintes definições:
1. Modelo: selecione o modelo de TTS (conversão de texto em voz) do Cloud que quer usar, como Gemini 2.5 Pro TTS. Para mais informações sobre os 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).
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.
Clique no ícone enviar à direita da caixa de texto para gerar o áudio.
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 envolvente e com um som natural a partir de texto requer a compreensão das nuances da linguagem falada e a sua tradução para o 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 mecanismos do controlo por 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 uma sensação 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 de comandos mínimo 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 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 descritivo e detalhado 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.

Estes exemplos de código demonstram como personalizar as configurações de segurança na API Cloud Text-to-Speech. Para utilização na API Vertex AI, consulte os exemplos da API Vertex AI.

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

Gemini-TTS Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Modelos disponíveis

Gemini 2.5 Flash TTS

Gemini 2.5 Flash Lite TTS (pré-visualização)

Gemini 2.5 Pro TTS

Controlos adicionais

Opções de voz

Idiomas disponíveis

Regiões disponíveis

Escolha a API certa

Use a Cloud Text-to-Speech API

Antes de começar

Configure o seu Google Cloud projeto

Definir ponto final da API para a região preferencial

Python

CURL

Realize a síntese síncrona de um único orador

Python

CURL

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

Python

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

Python

CURL

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

Python

CURL

Use a API Vertex AI

Antes de começar

Realize a síntese síncrona de um único orador

Python

CURL

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

Python

Realize a síntese síncrona de vários oradores

CURL

Realize a síntese de voz no Media Studio

Autorizações necessárias para esta tarefa

Sugestões de comandos

Os três mecanismos do controlo por voz

Guia de etiquetas de marcação

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

Modo 2: modificadores de estilo

Modo 3: marcação vocalizada (adjetivos)

Modo 4: ritmo e pausas

Estratégias importantes para resultados fiáveis

Desativar os filtros de segurança

Python

CURL

Gemini-TTS