Gemini-TTS

Prueba Gemini TTS en Vertex AI Studio Probar en Colab Ver cuaderno en GitHub

Gemini-TTS es la última evolución de nuestra tecnología Cloud TTS, que va más allá de la voz natural y proporciona un control granular sobre el audio generado mediante peticiones basadas en texto. Con Gemini-TTS, puedes sintetizar la voz de uno o varios interlocutores, desde fragmentos cortos hasta narraciones largas, y dictar con precisión el estilo, el acento, el ritmo, el tono e incluso la expresión emocional, todo ello mediante peticiones en lenguaje natural.

Modelos disponibles

Gemini-TTS incluye los siguientes modelos disponibles:

Gemini 2.5 Flash TTS

ID del modelo gemini-2.5-flash-tts
Optimizado para Generación de audio de Cloud TTS con baja latencia, controlable y con uno o varios interlocutores para aplicaciones cotidianas rentables
Modalidades de entrada y salida
  • Entrada: texto
  • Salida: audio
Compatibilidad con números de altavoz Un solo interlocutor o varios
Formatos de audio de salida admitidos
  • Unario: LINEAR16 (predeterminado), ALAW, MULAW, MP3, OGG_OPUS y PCM
  • Streaming: PCM (predeterminado), ALAW, MULAW, OGG_OPUS
Asistencia por región global
Opciones de voz Consulta las opciones de voz.
Available languages Consulta los idiomas disponibles.
Ejemplo 
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 (versión preliminar)

ID del modelo gemini-2.5-flash-lite-preview-tts
Optimizado para Generación de audio de Cloud TTS con baja latencia, controlable y de un solo interlocutor para aplicaciones cotidianas rentables. Ten en cuenta que este modelo está en versión preliminar.
Modalidades de entrada y salida
  • Entrada: texto
  • Salida: audio
Compatibilidad con números de altavoz Única
Formatos de audio de salida admitidos
  • Unario: LINEAR16 (predeterminado), ALAW, MULAW, MP3, OGG_OPUS y PCM
  • Streaming: PCM (predeterminado), ALAW, MULAW, OGG_OPUS
Asistencia por región global
Opciones de voz Consulta las opciones de voz.
Available languages Consulta los idiomas disponibles.
Ejemplo 
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 del modelo gemini-2.5-pro-tts
Optimizado para Alto control para flujos de trabajo estructurados, como la generación de pódcasts, audiolibros o asistencia al cliente, entre otros
Modalidades de entrada y salida
  • Entrada: texto
  • Salida: audio
Compatibilidad con números de altavoz Un solo interlocutor o varios
Formatos de audio de salida admitidos
  • Unario: LINEAR16 (predeterminado), ALAW, MULAW, MP3, OGG_OPUS y PCM
  • Streaming: PCM (predeterminado), ALAW, MULAW, OGG_OPUS
Asistencia por región global
Opciones de voz Consulta las opciones de voz.
Available languages Consulta los idiomas disponibles.
Ejemplo 
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"

Controles adicionales

Entre los controles y las funciones adicionales se incluyen los siguientes:

  1. Conversación natural: las interacciones de voz son de una calidad extraordinaria, la expresividad es más adecuada y los patrones de ritmo se ofrecen con una latencia muy baja para que puedas conversar con fluidez.

  2. Control del estilo: mediante peticiones en lenguaje natural, puedes adaptar la forma de expresarse en la conversación para que adopte acentos específicos y produzca una variedad de tonos y expresiones, incluido un susurro.

  3. Rendimiento dinámico: estos modelos pueden dar vida al texto para ofrecer lecturas expresivas de poesía, noticias y narraciones atractivas. También pueden actuar con emociones concretas y producir acentos cuando se les pide.

  4. Control mejorado del ritmo y la pronunciación: controlar la velocidad de lectura ayuda a mejorar la precisión de la pronunciación, incluidas palabras concretas.

Para obtener información sobre cómo usar estas voces en tu aplicación, consulta Usar Gemini-TTS.

Opciones de voz

Gemini TTS ofrece una amplia gama de opciones de voz similares a las voces en HD de Chirp 3, cada una con características distintas:

Nombre Sexo Demostración
Achernar Mujeres
Achird Hombres
Algenib Hombres
Algieba Hombres
Alnilam Hombres
Aoede Mujeres
Autónoe Mujeres
Callirrhoe Mujeres
Charon Hombres
Despina Mujeres
Encélado Hombres
Erinome Mujeres
Fenrir Hombres
Gacrux Mujeres
Jápeto Hombres
Kore Mujeres
Laomedeia Mujeres
Leda Mujeres
Orus Hombres
Pulcherrima Mujeres
Puck Hombres
Rasalgethi Hombres
Sadachbia Hombres
Sadaltager Hombres
Schedar Hombres
Sulafat Mujeres
Umbriel Hombres
Vindemiatrix Mujeres
Zephyr Mujeres
Zubenelgenubi Hombres

Available languages

Gemini TTS admite los siguientes idiomas:

Idioma Código BCP-47 Preparación para el lanzamiento
Árabe (Egipto) ar-EG GA
Bengalí (Bangladesh) bn-BD GA
Neerlandés (Países Bajos) nl-NL GA
Inglés (India) en-IN GA
Inglés (EE. UU.) en-US GA
Francés (Francia) fr-FR GA
Alemán (Alemania) de-DE GA
Hindi (India) hi-IN GA
Indonesio (Indonesia) id-ID GA
Italiano (Italia) it-IT GA
Japonés (Japón) ja-JP GA
Coreano (Corea del Sur) ko-KR GA
Maratí (India) mr-IN GA
Polaco (Polonia) pl-PL GA
Portugués (Brasil) pt-BR GA
Rumano (Rumanía) ro-RO GA
Ruso (Rusia) ru-RU GA
Español (España) es-ES GA
Tamil (India) ta-IN GA
Telugu (India) te-IN GA
Tailandés (Tailandia) th-TH GA
Turco (Turquía) tr-TR GA
Ucraniano (Ucrania) uk-UA GA
Vietnamita (Vietnam) vi-VN GA
Afrikáans (Sudáfrica) af-ZA Vista previa
Albanés (Albania) sq-AL Vista previa
Amárico (Etiopía) am-ET Vista previa
Árabe (Mundo) ar-001 Vista previa
Armenio (Armenia) hy-AM Vista previa
Azerbaiyano (Azerbaiyán) az-AZ Vista previa
Euskera (España) eu-ES Vista previa
Bielorruso (Bielorrusia) be-BY Vista previa
Búlgaro (Bulgaria) bg-BG Vista previa
Birmano (Myanmar) my-MM Vista previa
Catalán (España) ca-ES Vista previa
Cebuano (Filipinas) ceb-PH Vista previa
Chino mandarín (China) cmn-CN Vista previa
Chino mandarín (Taiwán) cmn-tw Vista previa
Croata (Croacia) hr-HR Vista previa
Checo (República Checa) cs-CZ Vista previa
Danés (Dinamarca) da-DK Vista previa
Inglés (Australia) en-AU Vista previa
Inglés (Reino Unido) en-GB Vista previa
Estonio (Estonia) et-EE Vista previa
Filipino (Filipinas) fil-PH Vista previa
Finés (Finlandia) fi-FI Vista previa
Francés (Canadá) fr-CA Vista previa
Gallego (España) gl-ES Vista previa
Georgiano (Georgia) ka-GE Vista previa
Griego (Grecia) el-GR Vista previa
Guyaratí (India) gu-IN Vista previa
Criollo haitiano (Haití) ht-HT Vista previa
Hebreo (Israel) he-IL Vista previa
Húngaro (Hungría) hu-HU Vista previa
Islandés (Islandia) is-IS Vista previa
Javanés (Java) jv-JV Vista previa
Canarés (India) kn-IN Vista previa
Konkani (India) kok-IN Vista previa
Lao (Laos) lo-LA Vista previa
Latín (Ciudad del Vaticano) la-VA Vista previa
Letón (Letonia) lv-LV Vista previa
Lituano (Lituania) lt-LT Vista previa
Luxemburgués (Luxemburgo) lb-LU Vista previa
Macedonio (Macedonia del Norte) mk-MK Vista previa
Maithili (India) mai-IN Vista previa
Malgache (Madagascar) mg-MG Vista previa
Malayo (Malasia) ms-MY Vista previa
Malayalam (India) ml-IN Vista previa
Mongol (Mongolia) mn-MN Vista previa
Nepalí (Nepal) ne-NP Vista previa
Noruego (bokmål) (Noruega) nb-NO Vista previa
Noruego (Nynorsk) (Noruega) nn-NO Vista previa
Oriya (India) or-IN Vista previa
Pastún (Afganistán) ps-AF Vista previa
Persa (Irán) fa-IR Vista previa
Portugués (Portugal) pt-PT Vista previa
Panyabí (India) pa-IN Vista previa
Serbio (Serbia) sr-RS Vista previa
Sindhi (India) sd-IN Vista previa
Cingalés (Sri Lanka) si-LK Vista previa
Eslovaco (Eslovaquia) sk-SK Vista previa
Esloveno (Eslovenia) sl-SI Vista previa
Español (Latinoamérica) es-419 Vista previa
Español (México) es-MX Vista previa
Suajili (Kenia) sw-KE Vista previa
Sueco (Suecia) sv-SE Vista previa
Urdu (Pakistán) ur-PK Vista previa

Usar Gemini-TTS

Descubre cómo usar los modelos de Gemini-TTS para sintetizar la voz de un solo interlocutor y de varios.

Si necesitas opciones que no sean las predeterminadas, puedes especificar formatos de audio y frecuencias de muestreo en el campo "audioConfig".

Descripción Límite Tipo
Campo de texto No debe superar los 4000 bytes. Entrada
Campo de petición No debe superar los 4000 bytes. Entrada
Campos de texto y de petición Menor o igual que 8000 bytes. Entrada
Duración del audio de salida Aproximadamente 655 segundos. Si el texto de entrada da como resultado un audio de más de 655 segundos, se truncará. Salida

Antes de empezar

Para empezar a usar Cloud Text-to-Speech, debes habilitar la API en laGoogle Cloud consola siguiendo estos pasos:

  1. Habilita Cloud Text-to-Speech en un proyecto.
  2. Asegúrate de que la facturación esté habilitada en Cloud Text-to-Speech.
  3. Configura la autenticación para tu entorno de desarrollo.

Configurar un Google Cloud proyecto

  1. Iniciar sesión en la Google Cloud consola

  2. Ir a la página del selector de proyectos

    Puedes elegir un proyecto que ya tengas o crear uno. Para obtener más información sobre cómo crear un proyecto, consulta la Google Cloud documentación.

  3. Si creas un proyecto, aparecerá un mensaje en el que se te informará de que debes vincular una cuenta de facturación. Si usas un proyecto que ya tenías, asegúrate de habilitar la facturación

    Consulta cómo confirmar que la facturación está habilitada en tu proyecto.

  4. Una vez que hayas seleccionado un proyecto y lo hayas vinculado a una cuenta de facturación, podrás habilitar la API Cloud Text-to-Speech. Vaya a la barra Buscar productos y recursos, situada en la parte superior de la página, y escriba "voz". Selecciona la API Text-to-Speech de Cloud en la lista de resultados.

  5. Para probar Cloud Text-to-Speech sin vincularlo a tu proyecto, elige la opción Probar esta API. Para habilitar la API Cloud Text-to-Speech en tu proyecto, haz clic en Habilitar.

  6. Configura la autenticación para tu entorno de desarrollo. Para obtener instrucciones, consulta Configurar la autenticación de Cloud Text-to-Speech.

Realizar una síntesis síncrona de un solo interlocutor

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text: str, output_filepath: str = "output.mp3"):
    """Synthesizes speech from the input text and saves it to an MP3 file.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text: The text to synthesize.
        output_filepath: The path to save the generated audio file.
          Defaults to "output.mp3".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    # Select the voice you want to use.
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        name="Charon",  # Example voice, adjust as needed
        model_name="gemini-2.5-pro-tts"
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Perform the text-to-speech request on the text input with the selected
    # voice parameters and audio file type.
    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    # The response's audio_content is binary.
    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way",
    "text": "OK, so... tell me about this [uhm] AI thing."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "model_name": "gemini-2.5-flash-tts"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Realizar una síntesis de un solo interlocutor en streaming

La síntesis de streaming es adecuada para aplicaciones en tiempo real en las que la respuesta rápida es fundamental para la experiencia de usuario. En la conexión de streaming, la API devuelve el audio a medida que está disponible en pequeños fragmentos.

Como llamador de la API, asegúrate de consumir los fragmentos de audio y de enviarlos a tus clientes a medida que lleguen (por ejemplo, usando socket.io para aplicaciones web).

Aunque es posible enviar los fragmentos de entrada a la API de forma asíncrona, como se muestra en request_generator, la API solo empezará a sintetizar cuando el cliente envíe Half-Close como señal de que no enviará más datos a la API.

El campo prompt debe definirse en el primer fragmento de entrada, ya que se ignora en los fragmentos consecutivos.

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import datetime
import os
import numpy as np
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text_chunks: list[str], model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text_chunks: Text chunks to synthesize. Note that The synthesis will 
          start when the client initiates half-close. 
        model: gemini tts model name. gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts
        voice: voice name. Example: leda, kore. Refer to available voices
        locale: locale name. Example: en-us. Refer to available locales. 
    """
    client = texttospeech.TextToSpeechClient()

    config_request = texttospeech.StreamingSynthesizeRequest(
        streaming_config=texttospeech.StreamingSynthesizeConfig(
            voice=texttospeech.VoiceSelectionParams(
                name=voice,
                language_code=locale,
                model_name=model
            )
        )
    )

    # Example request generator. A function like this can be linked to an LLM
    # text generator and the text can be passed to the TTS API asynchronously.
    def request_generator():
      yield config_request

      for i, text in enumerate(text_chunks):
        yield texttospeech.StreamingSynthesizeRequest(
            input=texttospeech.StreamingSynthesisInput(
              text=text, 
              # Prompt is only supported in the first input chunk.
              prompt=prompt if i == 0 else None,
            )
        )

    request_start_time = datetime.datetime.now()
    streaming_responses = client.streaming_synthesize(request_generator())

    is_first_chunk_received = False
    final_audio_data = np.array([])
    num_chunks_received = 0
    for response in streaming_responses:
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")

        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        # accumulating audio. In a web-server scenario, you would want to 
        # "emit" audio to the frontend as soon as it arrives.
        #
        # For example using flask socketio, you could do the following
        # from flask_socketio import SocketIO, emit
        # emit("audio", response.audio_content)
        # socketio.sleep(0)
        audio_data = np.frombuffer(response.audio_content, dtype=np.int16)
        final_audio_data = np.concatenate((final_audio_data, audio_data))

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time
    audio_duration = len(final_audio_data) / 24_000  # default sampling rate.

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")
    print(f"Audio duration: {audio_duration} seconds")

    return final_audio_data

Realizar una síntesis síncrona de varios interlocutores con entrada de texto libre

Descripción Restricciones y límites Tipo
Campo de texto 4000 bytes como máximo Entrada
Campo de petición 4000 bytes como máximo Entrada
Campos de texto y de petición 8000 bytes como máximo Entrada
Alias de interlocutor Caracteres alfanuméricos y sin espacios en blanco Entrada
Duración del audio de salida Aproximadamente 655 segundos. Si el texto de entrada da como resultado un audio de más de 655 segundos, se truncará. Salida

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_freeform(
    prompt: str,
    text: str,
    output_filepath: str = "output_non_turn_based.wav",
):
    """Synthesizes speech from non-turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        text: The text to synthesize, containing speaker aliases to indicate
          different speakers. Example: "Sam: Hi Bob!\nBob: Hi Sam!"
        output_filepath: The path to save the generated audio file. Defaults to
          "output_non_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-2.5-pro-tts",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-2.5-flash-tts and gemini-2.5-pro-tts
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "text": "Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?"
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-2.5-flash-tts",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Realizar una síntesis multilocutor síncrona con una entrada de texto estructurada

La función de varios interlocutores con entrada de texto estructurado permite verbalizar de forma inteligente el texto de una forma similar a la humana. Por ejemplo, este tipo de entrada es útil para direcciones y fechas. La entrada de texto libre pronuncia el texto exactamente como se escribe.

cada campo de petición y diálogo debe tener un máximo de 4000 bytes.
Descripción Restricciones y límites Tipo
Campo MultiSpeakerMarkUp 4000 bytes como máximo Entrada
Campo de petición 4000 bytes como máximo Entrada
Campos MultiSpeakerMarkUp y de peticiones 8000 bytes como máximo Entrada
Alias de interlocutor Caracteres alfanuméricos y sin espacios en blanco Entrada
Duración del audio de salida Aproximadamente 655 segundos. Si el texto de entrada da como resultado un audio de más de 655 segundos, se truncará. Salida

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_structured(
    prompt: str,
    turns: list[texttospeech.MultiSpeakerMarkup.Turn],
    output_filepath: str = "output_turn_based.wav",
):
    """Synthesizes speech from turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        turns: A list of texttospeech.MultiSpeakerMarkup.Turn objects representing
          the dialogue turns.
        output_filepath: The path to save the generated audio file. Defaults to
          "output_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(
        multi_speaker_markup=texttospeech.MultiSpeakerMarkup(turns=turns),
        prompt=prompt,
    )

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-2.5-pro-tts",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-2.5-flash-tts and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "multiSpeakerMarkup": {
      "turns": [
        {
          "speaker": "Sam",
          "text": "Hi Bob, how are you?"
        },
        {
          "speaker": "Bob",
          "text": "I am doing well, and you?"
        }
      ]
    }
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-2.5-flash-tts",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Usar Gemini-TTS en la Google API de IA generativa

Descubre cómo usar los modelos de Gemini-TTS para sintetizar la voz de un solo interlocutor y de varios interlocutores con la API de IA generativa Google .

En la API Text-to-Speech de Cloud, el usuario puede proporcionar campos de texto y de petición por separado. En la API de IA generativa, se trata de un solo campo contents, donde se especifica la entrada con el formato "{petición}: {texto}", por ejemplo: Google "Di lo siguiente de forma curiosa: Vale, entonces... cuéntame sobre esto de la IA".

En la API de IA generativa, la salida son datos de audio PCM de 16 bits y 24 kHz, y no tiene encabezados WAV. Google El cliente debe seguir pasos adicionales si quiere convertir el audio a otro formato.

Descripción Límite Tipo
Campo de contenido Menor o igual que 8000 bytes. Entrada
Duración del audio de salida Aproximadamente 655 segundos. Si el texto de entrada da como resultado un audio de más de 655 segundos, se truncará. Salida

Antes de empezar

Antes de empezar, sigue los pasos de instalación de la API de IA generativa.Google

Realizar una síntesis síncrona de un solo interlocutor

En estos ejemplos de código se muestra cómo realizar una síntesis síncrona de un solo interlocutor.

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 una síntesis multilocutor síncrona

En este ejemplo de código se muestra cómo realizar una síntesis multilocutor síncrona.

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

Usar la síntesis de voz en Media Studio

Puedes usar Media Studio en la consola de Google Google Cloud para experimentar con modelos de conversión de texto a voz. De esta forma, se proporciona una interfaz de usuario para generar rápidamente audio sintetizado, escucharlo y experimentar con diferentes instrucciones y parámetros de estilo.

  1. En la consola de Google Google Cloud , ve a la página Vertex AI Studio > Media Studio.

    Media Studio

  2. Selecciona Voz en el menú desplegable de contenido multimedia.

  3. En el campo de texto, escribe el texto que quieras convertir en voz.

  4. En el panel Configuración, configure los siguientes ajustes:

    1. Modelo: selecciona el modelo de Cloud TTS (conversión de texto a voz) que quieras usar, como Gemini 2.5 Pro TTS. Para obtener más información sobre los modelos disponibles, consulta Modelos de Cloud TTS.
    2. Instrucciones de estilo: opcional. Introduce una petición de texto que describa el estilo, el tono y la forma de transmitir las emociones que hayas seleccionado. De esta forma, puedes guiar el rendimiento del modelo más allá de la narración predeterminada. Por ejemplo: "Narra con un tono tranquilo y profesional para un documental".
    3. Idioma: selecciona el idioma y la región del texto de entrada. El modelo genera la voz en el idioma y el acento seleccionados. Por ejemplo, Inglés (Estados Unidos).
    4. Voz: elige una voz predefinida para la narración. La lista contiene las voces disponibles para el modelo y el idioma seleccionados, como Acherner (mujer).

  5. Opcional: Despliega la sección Opciones avanzadas para configurar los ajustes técnicos de audio:

    1. Codificación de audio: selecciona la codificación del archivo de audio de salida. LINEAR16 es un formato sin comprimir y sin pérdidas adecuado para el procesamiento de audio de alta calidad. MULAW también está disponible para la salida de audio comprimido.
    2. Frecuencia de muestreo de audio: selecciona la frecuencia de muestreo en hercios (Hz). Esto determina la calidad del audio. Los valores más altos, como 44.100 Hz, representan un audio de mayor fidelidad, equivalente a la calidad de un CD.
    3. Velocidad: ajusta la velocidad de elocución moviendo el control deslizante o introduciendo un valor. Los valores inferiores a 1 ralentizan el habla, mientras que los superiores a 1 la aceleran. El valor predeterminado es 1.
    4. Ganancia de volumen (dB): ajusta el volumen del audio de salida en decibelios (dB). Los valores positivos aumentan el volumen y los negativos lo reducen. El valor predeterminado es 0.

  6. Haz clic en el icono Enviar situado a la derecha del cuadro de texto para generar el audio.

  7. El audio generado aparece en el reproductor multimedia. Haz clic en el botón de reproducción para escuchar el resultado. Puedes seguir ajustando la configuración y generar nuevas versiones según sea necesario.

Consejos para hacer peticiones

Para crear audio atractivo y natural a partir de texto, es necesario comprender los matices del lenguaje hablado y traducirlos a formato de guion. Los siguientes consejos te ayudarán a escribir guiones que suenen auténticos y reflejen el tono elegido.

Las tres palancas del control por voz

Para obtener los resultados más predecibles y matizados, asegúrate de que los tres componentes siguientes se ajusten al resultado que quieres obtener.

Petición de estilo Es el factor principal que determina el tono emocional general y la forma de expresarse. La petición define el contexto de todo el segmento de voz.

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

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

Contenido de texto: el significado semántico de las palabras que estás sintetizando. Una frase evocadora que sea coherente a nivel emocional con la petición de estilo dará resultados mucho más fiables que un texto neutro.

  • Bien: una petición para un tono de miedo funciona mejor con un texto como I think someone is in the house.

  • Menos eficaz: una petición para que se use un tono de miedo con texto como The meeting is at 4 PM. dará resultados ambiguos.

Etiquetas de marcado (vista previa) Las etiquetas entre corchetes, como [sigh], son más adecuadas para insertar una acción específica y localizada o una modificación de estilo, no para definir el tono general. Funcionan en consonancia con la petición de estilo y el contenido de texto.

Guía de etiquetas de marcado

Nuestros estudios demuestran que las etiquetas de marcas entre corchetes funcionan en uno de los tres modos distintos. Para usar una etiqueta de forma eficaz, es fundamental entender su modo.

Modo 1: Sonidos no verbales

El marcado se sustituye por una vocalización audible que no es verbal (por ejemplo, un suspiro o una risa). La etiqueta en sí no se pronuncia. Son excelentes para añadir dudas y reacciones realistas y similares a las humanas.

Etiqueta Comportamiento Fiabilidad Asesoramiento
[sigh] Inserta un sonido de suspiro. Alta La calidad emocional del suspiro se ve influida por la petición.
[laughing] Inserta una risa. Alta Para obtener los mejores resultados, usa una petición específica. Por ejemplo, una petición genérica puede generar una risa de sorpresa, mientras que "reacciona con una risa divertida" genera una risa de diversión.
[uhm] Inserta un sonido de duda. Alta Útil para crear un ambiente más natural y conversacional.

Modo 2: Modificadores de estilo

El lenguaje de marcas no se pronuncia, pero modifica la forma en que se pronuncia el texto posterior. El alcance y la duración de la modificación pueden variar.

Etiqueta Comportamiento Fiabilidad Asesoramiento
[sarcasm] Añade un tono sarcástico a la frase siguiente. Alta Esta etiqueta es un modificador potente. Demuestra que los conceptos abstractos pueden dirigir con éxito la entrega del modelo.
[robotic] Hace que la voz posterior suene robótica. Alta El efecto puede abarcar toda una frase. Una petición de estilo de apoyo (por ejemplo, "Dilo con voz robótica") sigue siendo la opción recomendada para obtener los mejores resultados.
[shouting] Aumenta el volumen de la voz posterior. Alta Es más eficaz cuando se combina con una petición de estilo coincidente (por ejemplo, Grita esta parte") y texto que implique gritos.
[whispering] Reduce el volumen de la voz posterior. Alta Para obtener los mejores resultados, la petición de estilo también debe ser explícita (por ejemplo, Ahora susurra esta parte lo más suavemente posible").
[extremely fast] Aumenta la velocidad de la voz siguiente. Alta Ideal para avisos o diálogos rápidos. Necesita una asistencia mínima para las peticiones.

Modo 3: Marcado vocalizado (adjetivos)

La propia etiqueta de marcado se pronuncia como una palabra, al tiempo que influye en el tono de toda la frase. Este comportamiento suele aplicarse a los adjetivos que expresan emociones.

Advertencia: Como la etiqueta se pronuncia, es probable que este modo sea un efecto secundario no deseado en la mayoría de los casos prácticos. Te recomendamos que uses la petición de estilo para definir estos tonos emocionales.

Etiqueta Comportamiento Fiabilidad Asesoramiento
[scared] Se pronuncia la palabra "asustado" y la frase adopta un tono de miedo. Alta El rendimiento depende en gran medida del contenido de texto. La frase "I just heard a window break" (Acabo de oír cómo se rompe una ventana) produce un resultado que da miedo de verdad. Una frase neutra produce un resultado "espeluznante", pero menos auténtico.
[curious] Se pronuncia la palabra "curioso" y la frase adopta un tono curioso. Alta Usa una frase inquisitiva para apoyar la intención de la etiqueta.
[bored] Se pronuncia la palabra "aburrido" y la frase se dice con un tono aburrido y monótono. Alta Úsalo con texto monótono o repetitivo para obtener el mejor efecto.

Modo 4: Ritmo y pausas

Estas etiquetas insertan silencio en el audio generado, lo que te permite controlar el ritmo, los tiempos y el compás de forma granular. La puntuación estándar (comas, puntos, puntos y comas) también creará pausas naturales, pero estas etiquetas ofrecen un control más explícito.

Etiqueta Comportamiento Fiabilidad Asesoramiento
[short pause] Inserta una breve pausa, similar a una coma (unos 250 ms). Alta Se usa para separar cláusulas o elementos de una lista para que se entiendan mejor.
[medium pause] Inserta una pausa estándar, similar a la que se hace entre frases (unos 500 ms). Alta Es eficaz para separar frases o ideas distintas.
[long pause] Inserta una pausa significativa para crear un efecto dramático (más de 1000 ms). Alta Usar para crear un efecto dramático. Por ejemplo: "La respuesta es... [long pause] ...no". No abuses de ellas, ya que pueden sonar poco naturales.

Estrategias clave para obtener resultados fiables

  • Alinea las tres palancas: Para conseguir la máxima predictibilidad, asegúrate de que tu petición de estilo, el contenido de texto y las etiquetas de marcado sean semánticamente coherentes y estén orientados al mismo objetivo.

  • Usa texto con carga emocional: no te limites a usar las peticiones y las etiquetas. Proporciona al modelo un texto enriquecido y descriptivo con el que trabajar. Esto es especialmente importante en el caso de las emociones sutiles, como el sarcasmo, el miedo o la emoción.

  • Escribe peticiones específicas y detalladas: cuanto más específica sea tu petición de estilo, más fiable será el resultado. "Reacciona con una risa divertida" es mejor que solo [laughing]. "Habla como un locutor de noticias de radio de los años 40" es mejor que "Habla de forma anticuada".

  • Prueba y verifica las etiquetas nuevas: el comportamiento de una etiqueta nueva o no probada no siempre es predecible. Es posible que se vocalice una etiqueta que crees que es un modificador de estilo. Prueba siempre una nueva combinación de etiqueta o petición para confirmar su comportamiento antes de implementarla en producción.

Relajar los filtros de seguridad

Las cuentas con facturación mensual pueden configurar solicitudes para reducir los filtros de seguridad mediante el campo relax_safety_filters en AdvancedVoiceOptions. El campo relax_safety_filters solo está habilitado en las cuentas con facturación mensual.

Si relajas los filtros de seguridad, se reducirá el umbral de bloqueo del contenido dañino que se sintetice.

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