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	Consulta las regiones disponibles.
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"

Síntesis de voz de Gemini 2.5 Flash Lite (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	Consulta las regiones disponibles.
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	Consulta las regiones disponibles.
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:

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.
Control del estilo: con 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.
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.
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 elegir la API adecuada para usar estas voces en tu aplicación, consulta Elegir la API adecuada.

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

Regiones disponibles

Gemini-TTS está disponible en varias regiones a través de la API Text-to-Speech de Cloud o de la API Vertex AI.

El tratamiento de aprendizaje automático de estos modelos se lleva a cabo en la región o multirregión específicas en las que se realiza la solicitud. Para obtener más información , consulta Residencia de datos.

En la API Cloud Text-to-Speech, se admiten las siguientes regiones:

Región	País o jurisdicción	Modelos disponibles
`global`	Global (sin 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ón Europea	`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`

Se puede acceder a estas regiones mediante los siguientes endpoints de API: <REGION>-texttospeech.googleapis.com. Ten en cuenta que la región global no tiene prefijo: texttospeech.googleapis.com.

En el caso de la API de Vertex AI, se admiten las siguientes regiones:

Región	País o jurisdicción	Modelos disponibles
`global`	Global (sin DRZ)	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-central2`	Unión Europea	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-north1`	Unión Europea	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-southwest1`	Unión Europea	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west1`	Unión Europea	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west4`	Unión Europea	`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`

Se puede acceder a estas regiones mediante los siguientes endpoints de API: <REGION>-aiplatform.googleapis.com. Ten en cuenta que la región global no tiene prefijo: aiplatform.googleapis.com.

Elegir la API adecuada

Descubre cómo usar los modelos de Gemini-TTS para sintetizar la voz de un solo interlocutor y de varios interlocutores con la API Text-to-Speech de Cloud o la API Vertex AI.

Gemini TTS está disponible a través de dos APIs para simplificar el proceso de integración de los clientes. API Text-to-Speech de Cloud y API Vertex AI, con endpoints REST y SDKs en varios lenguajes de programación.

A continuación, te ofrecemos algunas directrices para ayudarte a elegir la API adecuada.

Si se da alguna de las siguientes circunstancias, elige la API Text-to-Speech de Cloud:

Si usas Chirp 3 HD u otras voces, puedes seguir usando la misma API Cloud Text-to-Speech con actualizaciones incrementales mínimas.
Si necesitas tipos de codificación de salida específicos, la API Cloud Text-to-Speech puede especificar la codificación de audio. En la API de Vertex AI, la salida son datos de audio PCM de 16 bits y 24 kHz, y no tiene encabezados WAV. Si quieres convertir el audio a otro formato, la conversión debe realizarse del lado del cliente.
Si tienes que transmitir texto en varios fragmentos, la API Cloud Text-to-Speech admite la interacción de varias solicitudes y varias respuestas. Por el contrario, la API Vertex AI admite una sola solicitud y varias respuestas.

Si se da alguna de las siguientes circunstancias, elige la API de Vertex AI:

Si ya usas Gemini TTS en AI Studio, puedes cambiar a Vertex AI sin problemas para aprovechar la escalabilidad y el cumplimiento de Google Cloud.
Si usas la API de Vertex AI para otros modelos, la estructura de la API unificada te facilitará el uso de Gemini TTS especificando el nombre del modelo y las opciones de selección de voz.

Usar la API Cloud Text-to-Speech

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 que supera los 655 segundos, el audio se trunca.	Salida

Antes de empezar

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

Habilita Cloud Text-to-Speech en un proyecto.
Asegúrate de que la facturación esté habilitada en Cloud Text-to-Speech.
Configura la autenticación para tu entorno de desarrollo.
Asigna el permiso aiplatform.endpoints.predict al usuario autenticado. Este permiso se puede conceder con el rol roles/aiplatform.user.
Selecciona el endpoint de API correcto en función de las regiones disponibles.

Configurar un Google Cloud proyecto

Inicia sesión en la Google Cloud consola.
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 documentación deGoogle Cloud .
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.

Nota: Debes habilitar la facturación para usar la API Cloud Text-to-Speech, pero no se te cobrará a menos que superes la cuota sin coste económico. Para obtener más información sobre los precios, consulta la página de precios.
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.
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 para usarla con tu proyecto, haz clic en Habilitar.
Configura la autenticación para tu entorno de desarrollo. Para obtener instrucciones, consulta el artículo Configurar la autenticación de Cloud Text-to-Speech.

Definir el endpoint de la API para la región preferida

Puedes elegir un endpoint en función de las regiones disponibles.

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

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

La API Text-to-Speech de Cloud admite el tipo multiple request multiple response de streaming. Aunque es posible enviar los fragmentos de entrada a la API de forma asíncrona, como se muestra en request_generator, la API solo empieza a sintetizar cuando el cliente envía 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 o menos	Entrada
Campo de petición	4000 bytes o menos	Entrada
Campos de texto y de petición	8000 bytes o menos	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 que supera los 655 segundos, el audio se trunca.	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 o menos	Entrada
Campo de petición	4000 bytes o menos	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 que supera los 655 segundos, el audio se trunca.	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 la API de Vertex AI

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

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

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 que supera los 655 segundos, el audio se trunca.	Salida

Antes de empezar

Antes de empezar, sigue los pasos de instalación de la API Vertex AI. Para aprovechar las opciones de residencia de datos, asegúrate de definir el LOCATION en función de las regiones disponibles.

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

Realizar una síntesis de un solo interlocutor en streaming

En la API de Vertex AI, se admite el streaming unidireccional, es decir, el cliente envía una sola solicitud y recibe un flujo de respuestas.

En este código de ejemplo se muestra cómo realizar la síntesis de un solo interlocutor en streaming.

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

Realizar una síntesis multilocutor síncrona

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

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

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad, how about you?"""

# 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-preview-tts",
  contents=prompt,
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      )
  )
)

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

Audio("output_speech.wav")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following as a conversation between friends: Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?" }
  },
  "generation_config": {
    "speech_config": {
      "language_code": "en-in",
      "multi_speaker_voice_config": {
        "speaker_voice_configs": [{
          "speaker": "Sam",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Aoede"
            }
          }
        },{
          "speaker": "Bob",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Algieba"
            }
          }
        }]
      }
    }
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-2.5-flash-tts:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

Realizar una síntesis de varios interlocutores en streaming

En la API de Vertex AI, se admite el streaming unidireccional, es decir, el cliente envía una sola solicitud y recibe un flujo de respuestas.

En este código de ejemplo se muestra cómo realizar la síntesis de varios interlocutores en streaming.

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

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad! Honestly, I'm just blown away by this new Gemini Text-to-Speech model.
        Joe: Right?! This is a total game changer! And do you know what I just discovered?
        Jane: What?
        Joe: You can use the multi-speaker configuration to create a conversation, just like us!
        Jane: Just like us!"""

# 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. 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 = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      )
    )

    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(
    prompt,
    "gemini-2.5-flash-tts",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

Realizar la síntesis de voz en Media Studio

Permisos que se necesitan para completar esta tarea

Para llevar a cabo esta tarea, debes tener los siguientes permisos:

serviceusage.services.use

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.

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

Media Studio
Selecciona Voz en el menú desplegable de contenido multimedia.
En el campo de texto, escribe el texto que quieras convertir en voz.
En el panel Configuración, configure los siguientes ajustes:
1. Modelo: selecciona el modelo de conversión de texto a voz de Cloud 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 el habla 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).
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.
Haz clic en el icono Enviar situado a la derecha del cuadro de texto para generar el audio.
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 oral y traducirlos a un 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 y la forma de expresarse en general. 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 el tono sea 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

Nuestras investigaciones muestran 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 marcado 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, "Say this in a robotic way") 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 que coincida (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 posterior.	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 ha roto 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 y comas, y puntos) 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.

En estos ejemplos de código se muestra cómo personalizar las configuraciones de seguridad en la API Cloud Text-to-Speech. Para usarla en la API de Vertex AI, consulta los ejemplos de la API de 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 Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Modelos disponibles

Gemini 2.5 Flash TTS

Síntesis de voz de Gemini 2.5 Flash Lite (versión preliminar)

Gemini 2.5 Pro TTS

Controles adicionales

Opciones de voz

Available languages

Regiones disponibles

Elegir la API adecuada

Usar la API Cloud Text-to-Speech

Antes de empezar

Configurar un Google Cloud proyecto

Definir el endpoint de la API para la región preferida

Python

CURL

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

Python

CURL

Realizar una síntesis de un solo interlocutor en streaming

Python

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

Python

CURL

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

Python

CURL

Usar la API de Vertex AI

Antes de empezar

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

Python

CURL

Realizar una síntesis de un solo interlocutor en streaming

Python

Realizar una síntesis multilocutor síncrona

Python

CURL

Realizar una síntesis de varios interlocutores en streaming

Python

Realizar la síntesis de voz en Media Studio

Permisos que se necesitan para completar esta tarea

Consejos para hacer peticiones

Las tres palancas del control por voz

Guía de etiquetas de marcado

Modo 1: Sonidos no verbales

Modo 2: Modificadores de estilo

Modo 3: Marcado vocalizado (adjetivos)

Modo 4: Ritmo y pausas

Estrategias clave para obtener resultados fiables

Relajar los filtros de seguridad

Python

CURL

Gemini-TTS