O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Gerar fala com o Gemini TTS

Os modelos de conversão de texto em voz (TTS) do Gemini convertem texto em áudio de uma ou várias pessoas. É possível controlar o estilo, o sotaque, o ritmo e o tom do áudio com metadados de turno estruturados (speech_metadata) e tags vocais inline.

Nesta página, mostramos como gerar fala com os seguintes modelos usando os métodos generateContent e streamGenerateContent da API Gemini Enterprise:

Gemini 3.8 Flash TTS (gemini-3.8-flash-tts)
Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts)

Os modelos de TTS são personalizados para recitação exata de texto com controle refinado sobre estilo e som, como narração, audiolivros e respostas de agentes de voz. Para conversas interativas em tempo real com entrada e saída de áudio, use a API Live.

Se você usa um modelo anterior do Gemini TTS, como gemini-3.1-flash-tts-preview, consulte o guia de migração.

Modelos compatíveis

Modelo	Falante único	Vários falantes	Streaming	Design de voz (pré-lançamento)	Replicação de voz (pré-lançamento)
Gemini 3.8 Flash TTS (`gemini-3.8-flash-tts`)
Gemini 3.8 Flash-Lite TTS (`gemini-3.8-flash-lite-tts`)
Pré-lançamento do Gemini 3.1 Flash TTS (`gemini-3.1-flash-tts-preview`)
Gemini 2.5 Pro TTS (`gemini-2.5-pro-tts`)
Gemini 2.5 Flash TTS (`gemini-2.5-flash-tts`)

Os exemplos e recursos nesta página se aplicam aos modelos de TTS do Gemini 3.8. Para os modelos anteriores, consulte Gemini-TTS na documentação da Text-to-Speech doGoogle Cloud .

Quando usar cada modelo

Os dois modelos do Gemini 3.8 TTS compartilham o mesmo esquema de solicitação e formato de comando, então é possível alternar entre eles mudando o ID do modelo:

Use o Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) quando a fidelidade acústica, a atuação com nuances e o controle expressivo forem a prioridade. Ele é adequado para trabalhos criativos de nível de estúdio, diálogos complexos com vários falantes, tags frequentes de explosão vocal, pronúncias difíceis, dialetos regionais ou minoritários e narrações longas que precisam de uma voz e um tom de ambiente estáveis.
Use o Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) para cargas de trabalho de produção rápidas e econômicas. É a substituição recomendada para gemini-3.1-flash-tts-preview e é adequada para produção em lote de alto volume, cascatas de agentes de voz de conversação, recursos de leitura em voz alta, replicação de voz e fala diária de um único locutor nos principais idiomas.

Antes de começar

Configure um projeto e ative a API Gemini Enterprise.
Configure o Application Default Credentials para seu ambiente de desenvolvimento.
Para usar os exemplos em Python, instale a versão 2.33.0 ou mais recente do SDK de IA generativa do Google:
```
pip install --upgrade "google-genai>=2.33.0"
```

Locais e endpoints regionais disponíveis

Os modelos de TTS do Gemini 3.8 estão disponíveis no local global e nos locais multirregionais us e eu:

Local	Parâmetro de local	Endpoint
Global	`global`	`https://aiplatform.googleapis.com`
Estados Unidos (multirregional)	`us`	`https://aiplatform.us.rep.googleapis.com`
União Europeia (multirregional)	`eu`	`https://aiplatform.eu.rep.googleapis.com`

Para direcionar solicitações a um endpoint regional, defina location="us" (ou location="eu") ao inicializar o cliente no SDK ou envie solicitações para o nome do host multirregional correspondente (https://aiplatform.us.rep.googleapis.com ou https://aiplatform.eu.rep.googleapis.com) com o caminho de local correspondente no URL REST:

Python

from google import genai

# Set location to 'us' or 'eu' for multi-region routing (or 'global' for global)
client = genai.Client(
    enterprise=True,
    project="PROJECT_ID",
    location="us",
)

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {"voice_config": {"voice": "Kore"}},
    },
)

with open("out.wav", "wb") as f:
    f.write(response.candidates[0].content.parts[0].inline_data.data)

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.us.rep.googleapis.com/v1/projects/PROJECT_ID/locations/us/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Have a wonderful day!",
        "speechMetadata": {"style": "cheerful and friendly"}
      }]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > out.wav

TTS de locutor único

Para converter texto em áudio de um único locutor, transmita a transcrição literal em parts[].text, adicione estilo opcional no nível da fala em parts[].speech_metadata e defina a voz em speechConfig.voiceConfig.voice. O campo voice aceita um nome de voz pré-criada, um ID de voz da Biblioteca de Vozes Estendida ou o ID (voice_...) de uma voz projetada ou replicada (ou uma chave voicekey_... sem estado opcional).

Por padrão, as solicitações unárias retornam um arquivo WAV completo (PCM de 16 bits, 24 kHz, mono), para que você possa gravar os bytes de áudio diretamente em um arquivo .wav. As solicitações de streaming retornam blocos de PCM brutos. Para detalhes e outras codificações, consulte Formatos de saída de áudio.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {"voice_config": {"voice": "Kore"}},
    },
)

# The SDK has already decoded the base64 audio, so inline_data.data is a
# complete WAV file by default.
with open("out.wav", "wb") as f:
    f.write(response.candidates[0].content.parts[0].inline_data.data)

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Have a wonderful day!",
        "speechMetadata": {"style": "cheerful and friendly"}
      }]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > out.wav

TTS de streaming de locutor único

Para receber áudio enquanto o modelo ainda está sendo sintetizado, use o método streamGenerateContent. As respostas de streaming retornam blocos PCM brutos de 16 bits sem cabeçalho (24 kHz, mono). Assim, é possível transmitir cada bloco para um player, um soquete ou outro pipeline de áudio conforme ele chega. No exemplo de Python a seguir, a função emit_audio representa esse destino.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

def emit_audio(pcm: bytes) -> None:
    """Sends a chunk of raw 16-bit PCM audio (24 kHz, mono) downstream."""
    # Replace with your audio destination, such as a player, a WebSocket,
    # or a telephony stream.
    print(f"Received {len(pcm)} bytes of audio")

response_stream = client.models.generate_content_stream(
    model="gemini-3.8-flash-lite-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {"voice_config": {"voice": "Kore"}},
    },
)

for chunk in response_stream:
    if not chunk.candidates or not chunk.candidates[0].content:
        continue
    for part in chunk.candidates[0].content.parts or []:
        if part.inline_data and part.inline_data.data:
            emit_audio(part.inline_data.data)

REST

curl -N -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-lite-tts:streamGenerateContent?alt=sse" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Have a wonderful day!",
        "speechMetadata": {"style": "cheerful and friendly"}
      }]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | sed -n 's/^data: //p' \
    | jq -r '.candidates[0].content.parts[0].inlineData.data // empty' \
    | while read -r chunk; do echo "$chunk" | base64 --decode; done > streamed.pcm

O arquivo streamed.pcm contém áudio PCM bruto de 16 bits a 24 kHz, mono.

TTS com vários locutores

Para diálogos entre dois locutores, configure ambos em speechConfig.multiSpeakerVoiceConfig.speakerVoiceConfigs. Em seguida, transmita cada turno como um part separado, defina speech_metadata.speaker em cada turno como um dos nomes de locutor configurados e adicione um style opcional no nível do turno.

As solicitações com vários locutores exigem exatamente dois locutores.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [
            {
                "text": "How's it going today, Jane?",
                "speech_metadata": {"speaker": "Joe", "style": "cheerful and friendly"},
            },
            {
                "text": "Not too bad, how about you? Ready to test these new voices?",
                "speech_metadata": {"speaker": "Jane", "style": "calm and relaxed"},
            },
        ],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "multi_speaker_voice_config": {
                "speaker_voice_configs": [
                    {"speaker": "Joe", "voice_config": {"voice": "Puck"}},
                    {"speaker": "Jane", "voice_config": {"voice": "Kore"}},
                ]
            }
        },
    },
)

with open("dialogue.wav", "wb") as f:
    f.write(response.candidates[0].content.parts[0].inline_data.data)

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        {
          "text": "How'\''s it going today, Jane?",
          "speechMetadata": {"speaker": "Joe", "style": "cheerful and friendly"}
        },
        {
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "speechMetadata": {"speaker": "Jane", "style": "calm and relaxed"}
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {"speaker": "Joe", "voiceConfig": {"voice": "Puck"}},
            {"speaker": "Jane", "voiceConfig": {"voice": "Kore"}}
          ]
        }
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > dialogue.wav

TTS de streaming com vários locutores

As solicitações com vários locutores também são compatíveis com streaming. Use a mesma solicitação da conversão de texto em voz com vários locutores com o método streamGenerateContent.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

def emit_audio(pcm: bytes) -> None:
    """Sends a chunk of raw 16-bit PCM audio (24 kHz, mono) downstream."""
    # Replace with your audio destination, such as a player, a WebSocket,
    # or a telephony stream.
    print(f"Received {len(pcm)} bytes of audio")

response_stream = client.models.generate_content_stream(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [
            {
                "text": "How's it going today, Jane?",
                "speech_metadata": {"speaker": "Joe", "style": "cheerful and friendly"},
            },
            {
                "text": "Not too bad, how about you? Ready to test these new voices?",
                "speech_metadata": {"speaker": "Jane", "style": "calm and relaxed"},
            },
        ],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "multi_speaker_voice_config": {
                "speaker_voice_configs": [
                    {"speaker": "Joe", "voice_config": {"voice": "Puck"}},
                    {"speaker": "Jane", "voice_config": {"voice": "Kore"}},
                ]
            }
        },
    },
)

for chunk in response_stream:
    if not chunk.candidates or not chunk.candidates[0].content:
        continue
    for part in chunk.candidates[0].content.parts or []:
        if part.inline_data and part.inline_data.data:
            emit_audio(part.inline_data.data)

REST

curl -N -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:streamGenerateContent?alt=sse" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        {
          "text": "How'\''s it going today, Jane?",
          "speechMetadata": {"speaker": "Joe", "style": "cheerful and friendly"}
        },
        {
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "speechMetadata": {"speaker": "Jane", "style": "calm and relaxed"}
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {"speaker": "Joe", "voiceConfig": {"voice": "Puck"}},
            {"speaker": "Jane", "voiceConfig": {"voice": "Kore"}}
          ]
        }
      }
    }
  }' | sed -n 's/^data: //p' \
    | jq -r '.candidates[0].content.parts[0].inlineData.data // empty' \
    | while read -r chunk; do echo "$chunk" | base64 --decode; done > dialogue_streamed.pcm

O arquivo dialogue_streamed.pcm contém áudio PCM bruto de 16 bits a 24 kHz, mono.

Controlar o estilo de fala com metadados e tags

Os modelos do Gemini 3.8 TTS tratam o campo text como uma transcrição literal. As instruções escritas no texto, como "Say cheerfully: Hello!" ou "Speaker 1: Hello!", podem ser lidas em voz alta. Para controlar a entrega, divida as instruções por escopo:

Entrega sustentada no nível da fala (speech_metadata.style): coloque emoção, estilo de entrega, prosódia, ritmo e volume que se aplicam a uma fala inteira em speech_metadata.style. Por exemplo, "style": "whispered urgently", "style": "out of breath" ou "style": "warm and enthusiastic".
Eventos pontuais (tags inline): coloque sons vocais momentâneos que não sejam de fala e pausas dentro da transcrição entre colchetes angulares. Por exemplo, "Wait... <short pause> did you hear that? <sigh>" ou "Excuse me <cough> as I was saying...".

Para mais orientações, consulte o guia de comandos.

Opções de voz

Os modelos de TTS do Gemini 3.8 oferecem quatro maneiras de selecionar ou criar vozes:

Vozes predefinidas: 30 vozes selecionadas.
Biblioteca de voz estendida: mais de 2.000 vozes predefinidas em vários idiomas, sotaques regionais e personas de personagens.
Design de voz (pré-lançamento): crie uma voz personalizada com base em uma descrição em linguagem natural com o método create da API Voices (client.voices.create() no SDK de IA generativa do Google ou POST https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/voices). Defina type como VOICE_TYPE_PROMPTED e store como true. A resposta retorna um ID de voice_... armazenado e uma amostra da voz.
Replicação de voz (pré-lançamento): replique a voz de um locutor usando áudios de referência e consentimento com o mesmo método create. Defina type como VOICE_TYPE_REPLICATED. Com store: true, a resposta retorna um ID de voice_... armazenado. Com store: false, ele retorna uma chave voicekey_... sem estado.

Limites de voz personalizada e TTL

Tipo de voz	Modo de armazenamento	Gerenciamento	Expiração
Vozes armazenadas (`voice_...`, projetadas ou replicadas)	`store: true`	Métodos `list`, `get` e `delete` da API Voices	1 ano após o último uso
Chaves de replicação de voz (`voicekey_...`)	`store: false`	Gerenciado pelo aplicativo. O Google não retém a chave.	7 dias após a criação

Gerar fala com uma voz armazenada reinicia o período de armazenamento de um ano, para que uma voz usada regularmente não expire. As solicitações de criação de voz estão sujeitas a uma cota por projeto e por minuto. Se você exceder esse limite, o método create vai retornar um erro RESOURCE_EXHAUSTED. Para mais informações, consulte Cotas e limites do sistema.

Armazenamento e retenção de dados

O Google armazena as entradas que você fornece ao criar uma voz armazenada, junto com os artefatos de voz derivados delas, em associação com o projeto doGoogle Cloud que criou a voz.

Quando você cria uma voz replicada com base na gravação de um locutor, ela armazena o seguinte:

Áudio de referência: a amostra do locutor cuja voz é replicada.
Áudio de consentimento: o locutor lendo a declaração de consentimento obrigatória.

Quando você cria uma voz criada usando uma descrição de texto de uma voz em um comando, ela armazena o seguinte:

O comando de texto que você escreveu para descrever a voz.
O áudio de voz gerado com base nesse comando, que o modelo usa como referência para a voz.

Uma voz criada não tem áudio de consentimento, porque é gerada com base em uma descrição, e não em uma gravação de uma pessoa.

As entradas de voz são armazenadas para que sua voz continue funcionando nas atualizações do modelo. Os artefatos de voz são gerados novamente com base nas entradas armazenadas quando o modelo subjacente é atualizado. Se nenhuma entrada armazenada for encontrada para uma voz, os artefatos dela não poderão ser gerados novamente, e a voz vai parar de funcionar após uma atualização do modelo. Em seguida, você precisa criar a voz novamente.

As entradas armazenadas são usadas apenas para gerar novamente a voz quando os modelos são atualizados. Eles são criptografados em repouso e isolados no projeto que criou a voz.

Período de armazenamento

As vozes e todos os dados armazenados associados são retidos por até um ano (365 dias) a partir da última vez que você usou a voz para sintetizar a fala. O período começa quando você cria a voz e é redefinido sempre que você envia uma solicitação de síntese que usa a voz. Se uma voz não for usada por 365 dias, ela, as entradas armazenadas e os artefatos derivados serão excluídos.

Exclusão pelo cliente

É possível excluir uma voz a qualquer momento com o método delete da API Voices. A exclusão de uma voz exclui as entradas armazenadas e os artefatos derivados. A exclusão do projeto do Google Cloud que possui uma voz também as exclui, seguindo o processo padrão de exclusão de projetos.

Vozes predefinidas

A lista a seguir mostra cada nome de voz predefinida e as características dela:

Achernar: suave
Achird: amigável
Algenib: rouca
Algieba: suave
Alnilam: firme
Aoede: descontraída
Autonoe: alegre
Callirrhoe: tranquila
Charon: informativa
Despina: suave
Enceladus: sussurrada
Erinome: clara
Fenrir: entusiasmada
Gacrux: madura
Iapetus: clara
Kore: firme
Laomedeia: positiva
Leda: jovem
Orus: empresa
Puck: alegre
Pulcherrima: projetada
Rasalgethi: informativa
Sadachbia: animado
Sadaltager: segura
Schedar: Even
Sulafat: quente
Umbriel: tranquila
Vindemiatrix: afável
Zephyr: alegre
Zubenelgenubi: casual

Biblioteca de vozes estendida

Além das 30 vozes predefinidas, a Biblioteca de Vozes Estendida oferece mais de 2.000 vozes predefinidas selecionadas em vários idiomas, sotaques regionais, personas de personagens e casos de uso, como audiolivros, agentes de conversação e notícias. Para usar uma voz da biblioteca, transmita o ID dela em speechConfig.voiceConfig.voice, da mesma forma que você transmite um nome de voz predefinido.

Para navegar pela biblioteca, chame o método list da API Voices (ListVoices). Ele retorna as vozes personalizadas armazenadas no seu projeto, seguidas pelas vozes pré-criadas e da Biblioteca de Vozes Estendida. Cada voz da biblioteca inclui o id e metadados como language_code, accent, gender, pitch, persona e description. Para restringir os resultados, use os seguintes filtros:

type: a fonte da voz: prebuilt para vozes pré-criadas e de biblioteca, prompted para vozes projetadas ou replicated para vozes replicadas. Se você transmitir mais de um valor, o método vai retornar vozes que correspondam a qualquer um deles.
search: texto a ser correspondido, sem diferenciar maiúsculas de minúsculas, com o nome de exibição e a descrição de cada voz.

O exemplo a seguir pesquisa vozes de narrador na biblioteca:

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.voices.list(type_=["prebuilt"], search="narrator", page_size=50)
for voice in response.voices or []:
    print(voice.id, voice.language_code, voice.gender, voice.description)

REST

curl -G \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/voices \
  --data-urlencode "type=prebuilt" \
  --data-urlencode "search=narrator" \
  --data-urlencode "pageSize=50"

O método list retorna até 50 vozes por página. Para acessar a próxima página, transmita o valor next_page_token da resposta como o parâmetro page_token.

Formatos de saída de áudio

A codificação de áudio padrão depende do método:

As solicitações unárias (generateContent) retornam um arquivo WAV completo (audio/wav) com um cabeçalho RIFF: PCM de 16 bits, 24 kHz, mono.
As solicitações de streaming (streamGenerateContent) retornam blocos PCM (audio/l16) brutos de 16 bits assinados em little-endian sem cabeçalho a 24 kHz, mono.

Para solicitar uma codificação diferente, defina generationConfig.responseFormat como um formato de áudio. Os modelos de TTS do Gemini 3.8 aceitam os seguintes valores de mimeType:

Valor de `mimeType`	Formatar	Descrição
`AUDIO_WAV` (padrão unário)	WAV (`audio/wav`)	Arquivo WAV completo com um cabeçalho RIFF (PCM de 16 bits, 24 kHz, mono).
`AUDIO_L16` (padrão de streaming)	PCM linear (`audio/l16`)	PCM de 16 bits assinado, little-endian, sem cabeçalho. Use para streaming, pipelines de áudio personalizados ou concatenação de clipes de vários turnos.
`AUDIO_MULAW`	μ-law (`audio/mulaw`)	Áudio compactado com a lei μ do G.711 (8 kHz, mono), usados com frequência na telefonia norte-americana e japonesa.
`AUDIO_ALAW`	Lei A (`audio/alaw`)	Áudio compactado G.711 A-law (8 kHz, mono), usados com frequência em telefonia europeia e internacional.

Os modelos ignoram o campo sampleRate. A saída PCM linear e WAV é de 24 kHz, e a saída μ-law e A-law é de 8 kHz, independentemente da taxa na resposta mimeType. Faça uma nova amostragem da saída no cliente se o pipeline exigir uma taxa de amostragem diferente.

O exemplo a seguir solicita a saída de lei μ para um pipeline de telefonia. O SDK de IA generativa do Google para Python não expõe responseFormat em GenerateContentConfig. Por isso, o exemplo em Python o transmite no corpo da solicitação com http_options.extra_body.

Python

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{"role": "user", "parts": [{"text": "Have a wonderful day!"}]}],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {"voice_config": {"voice": "Kore"}},
        "http_options": {
            "extra_body": {
                "generationConfig": {
                    "responseFormat": [{"audio": {"mimeType": "AUDIO_MULAW"}}]
                }
            }
        },
    },
)

# The response is headerless μ-law audio at 8 kHz, mono.
with open("out.mulaw", "wb") as f:
    f.write(response.candidates[0].content.parts[0].inline_data.data)

REST

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash-tts:generateContent \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "Have a wonderful day!"}]}],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "responseFormat": [{"audio": {"mimeType": "AUDIO_MULAW"}}],
      "speechConfig": {
        "voiceConfig": {"voice": "Kore"}
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | base64 --decode > out.mulaw

Idiomas compatíveis

Os modelos de TTS do Gemini 3.8 detectam o idioma de entrada automaticamente. O Gemini 3.8 Flash TTS aceita 130 idiomas, e o Gemini 3.8 Flash-Lite TTS aceita 101 idiomas:

Idioma	Gemini 3.8 Flash TTS	Gemini 3.8 Flash-Lite TTS
Achinês (alfabeto árabe)
Africâner
Acã
Amárico
Armênio
Assamês
Awadhi
Balinês
Bengali
Banjarês (alfabeto árabe)
Banjarês (alfabeto latino)
Bashkir
Basco
Bielorrusso
Bemba
Boiapuri
Bósnio
Buginês
Búlgaro
Birmanês
Cantonês
Catalão
Cebuano
Curdo central
Chhattisgarhi
Chinês (alfabeto Hans)
Chinês (alfabeto Hant)
Tártaro da Crimeia
Croata
Tcheco
Dinamarquês
Holandês
Diúla
Dzonga
Árabe egípcio
Inglês
Estoniano
Filipino
Finlandês
Francês
Galego
Ganda
Georgiano
Alemão
Grego
Guarani
Gujarati
Crioulo haitiano
Mongol halh
Hauçá
Hebraico
Hindi
Húngaro
Islandês
Igbo
Iloko
Indonésio
Persa iraniano
Italiano
Japonês
Javanês
Kabyle
Kamba
Canarês
Caxemira (alfabeto árabe)
Caxemira (escrita devanágari)
Cazaque
Khmer
Kikuyu
Quiniaruanda
Quicongo
Coreano
Quirguiz
Laosiano
Latgaliano
Lingala
Lituano
Luxemburguês
Macedônio
Magahi
Maithili
Malaiala
Maltês
Manipuri
Marati
Minangkabau (alfabeto árabe)
Minangkabau (alfabeto latino)
Mizo
Nepalês (idioma individual)
Fulfulde nigeriano
Azerbaijano do norte
Soto do norte
Uzbeque do norte
bokmål norueguês
Norueguês (Nynorsk)
Nianja
Occitano
Oriá (idioma individual)
Língua pangasiana
Persa (Afeganistão)
Polonês
Português
Punjabi
Romeno
Russo
Santali
Sérvio
Sindi
Cingalês
Eslovaco
Esloveno
Somali
Azerbaijão do Sul
Pashto do sul
Soto do sul
Espanhol
Árabe padrão (alfabeto árabe)
Árabe padrão (alfabeto latino)
Letão padrão
Malaio padrão
Suaíli (idioma individual)
Swati
Sueco
Tadjique
Tâmil
Télugo
Tailandês
Tigrínia
Albanês Tosk
Uyghur

Limitações

Os modelos de TTS aceitam apenas entradas de texto e retornam apenas saídas de áudio.
As solicitações com vários locutores exigem exatamente dois locutores. Para combinar vozes projetadas (voice_...) ou replicadas (voice_... ou voicekey_...) em diálogos com vários personagens ou para usar mais de dois locutores, sintetize a fala de cada locutor individualmente e concatene o áudio. Solicite a saída AUDIO_L16 para cada turno ou remova o cabeçalho WAV de cada clipe antes de concatenar os clipes.
Os modelos estão disponíveis nos locais global, us e eu.
As vozes personalizadas do usuário (criadas com design ou replicação de voz) estão disponíveis apenas no local global.
Não há suporte para instruções do sistema.
Não é possível definir a taxa de amostragem de saída. Não há suporte para saída em MP3 e Ogg Opus.

A seguir

Saiba como direcionar o estilo, o ritmo e os sons vocais no guia de comandos.
Crie vozes personalizadas com base em uma descrição de texto com o Voice Design (pré-lançamento).
Replique a voz de um locutor com a replicação de voz (pré-lançamento).
Confira as especificações nas páginas dos modelos Gemini 3.8 Flash TTS e Gemini 3.8 Flash-Lite TTS.

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

Modelos compatíveis

Quando usar cada modelo

Antes de começar

Locais e endpoints regionais disponíveis

Python

REST

TTS de locutor único

Python

REST

TTS de streaming de locutor único

Python

REST

TTS com vários locutores

Python

REST

TTS de streaming com vários locutores

Python

REST

Controlar o estilo de fala com metadados e tags

Opções de voz

Limites de voz personalizada e TTL

Armazenamento e retenção de dados

Período de armazenamento

Exclusão pelo cliente

Vozes predefinidas

Biblioteca de vozes estendida

Python

REST

Formatos de saída de áudio

Python

REST

Idiomas compatíveis

Limitações

A seguir

Gerar fala com o Gemini TTS