Generación de texto a voz (TTS) con la API de Gemini


Puedes usar un modelo de TTS de Gemini (gemini-3.8-flash-tts o gemini-3.8-flash-lite-tts) para sintetizar voz (audio) natural y expresiva a partir de texto. Cuando usas Firebase AI Logic, puedes realizar esta solicitud directamente desde tu app web o para dispositivos móviles (como tu app de Apple (Swift), Android (Kotlin/Java), Web (JavaScript), Flutter (Dart) o Unity).

La generación de texto a voz (TTS) es controlable, lo que significa que proporcionas el texto exacto para sintetizarlo en voz, mientras guías la entrega, como la emoción, el ritmo, las voces de los interlocutores y los sonidos que no son de voz, como risas o suspiros, con metadatos estructurados y etiquetas vocales intercaladas. Puedes pensar en TTS como lo opuesto a la transcripción (voz a texto).

Con esta función, puedes crear funciones como las siguientes:

  • Narración interactiva y audiolibros: Narra historias de formato largo o juegos de rol en los que los personajes cambian de voz, reaccionan entre sí con canales de retroalimentación superpuestos y adaptan su expresión emocional (como susurrar en suspenso o reírse de un chiste).
  • Asistentes y agentes de voz de baja latencia: Transmite voz sintetizada en cuanto llegue el texto de un LLM, lo que mantiene una personificación de voz coherente en todos los turnos de conversación.
  • Lectores de contenido multilingüe y tutores de idiomas: Lee artículos, recetas o material de estudio en voz alta en más de 130 idiomas y acentos regionales, o cambia de idioma sin problemas en una sola conversación.

En esta guía, se muestra cómo generar voz de un solo interlocutor y de varios, transmitir respuestas de audio, dirigir la entrega de voz con SpeechMetadata y etiquetas intercaladas, y elegir entre voces precompiladas, de biblioteca o personalizadas.

Saltar al código de un solo interlocutor Saltar al código de varios interlocutores Saltar al código de transmisión

Comparación entre TTS y Live API

Tanto los modelos de texto a voz (TTS) como los de Live API son modelos de baja latencia que generan voz y se pueden configurar para diferentes voces y lenguajes de respuesta. Sin embargo, se usan para casos de uso muy diferentes.

  • La generación de texto a voz (TTS) es una interacción unidireccional de solicitud y respuesta (entrada de texto, salida de audio). Está adaptado para situaciones que requieren una recitación exacta del texto proporcionado con un control detallado del estilo y el sonido, como la narración de podcasts, audiolibros o la lectura de artículos en voz alta.

  • La generación Live API admite la transmisión bidireccional para conversaciones de voz en tiempo real (entrada y salida de voz). Se destaca en contextos conversacionales dinámicos en los que el modelo decide el discurso aplicable que se debe mostrar. Ten en cuenta que los modelos de Live API más recientes también admiten entradas de video y de imagen.

Antes de comenzar

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Si aún no lo hiciste, completa la guía de introducción, en la que se describe cómo configurar tu proyecto de Firebase, conectar tu app a Firebase, agregar el SDK, inicializar el servicio de backend para el proveedor de Gemini API que elijas y crear una instancia de GenerativeModel.

Para probar y, luego, iterar tus instrucciones, te recomendamos usar Google AI Studio.

Modelos que admiten esta capacidad

  • gemini-3.8-flash-tts
  • gemini-3.8-flash-lite-tts
Comparación de modelos de TTS

Ambos modelos de Gemini 3.x TTS tienen el mismo esquema de solicitud y formato de instrucción. Sin embargo, aquí se presentan algunas diferencias para cuando uses cada modelo.

Función o carga de trabajo gemini-3.8-flash-tts gemini-3.8-flash-lite-tts
Fortaleza principal Fidelidad de voz de nivel de estudio, matices de actuación y amplia cobertura de dialectos Alta capacidad de procesamiento, baja latencia y rentabilidad
Mejores casos de uso Audiolibros, narración de estudio, diálogo complejo de varios interlocutores, etiquetas frecuentes de ráfagas de voz, pronunciación difícil, dialectos regionales Producción de gran volumen, cascadas de agentes de voz en tiempo real, funciones de la IU de lectura en voz alta, voz de un solo interlocutor para el día a día
Idiomas compatibles 132 idiomas 103 idiomas

Generar voz a partir de texto

Puedes generar voz a partir de una entrada de texto con una voz de un solo interlocutor o un diálogo de dos interlocutores, ya sea como un archivo WAV completo (generateContent) o como una transmisión de audio PCM sin procesar de baja latencia (generateContentStream).

Genera voz con un solo interlocutor

Antes de probar este ejemplo, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y app.
En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página.

Sigue estos pasos para generar audio de un solo interlocutor:

  1. En tu GenerationConfig, establece responseModalities en AUDIO y configura un SpeechConfig con lo siguiente:

  2. Crea un TextPart con lo siguiente:

    • (Obligatorio) Es la transcripción textual que se pronunciará.

    • (Opcional) Un SpeechMetadata con una descripción de style (por ejemplo, "cheerful and friendly").

  3. Llama a generateContent. De forma predeterminada, las solicitudes unarias devuelven un archivo de audio WAV (audio/wav) completo (PCM lineal de 16 bits, 24 kHz, mono, con un encabezado RIFF estándar de 44 bytes) en las partes de datos intercalados de la respuesta.

Swift


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Set `responseModalities` to include `.audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: SpeechConfig(voiceName: "Kore", languageCode: "en-US")
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
)

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
  "Have a wonderful day!",
  speechMetadata: SpeechMetadata(style: "cheerful and friendly")
)

// Call `generateContent` to generate the speech output.
let response = try await model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let wavData = part.data       // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  let mimeType = part.mimeType  // for example: "audio/wav"
  print("Received audio data with MIME type: \(mimeType)")

  // Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
  playAudio(data: wavData)
}

Kotlin

En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutina.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = SpeechConfig(
        voice = Voice("Kore"),
        languageCode = "en-US"
    )
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
    text(
        text = "Have a wonderful day!",
        speechMetadata = SpeechMetadata(style = "cheerful and friendly")
    )
}

// Call `generateContent` to generate the speech output.
val response = model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val wavData = part.inlineData  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

    // Pass the audio data to your audio player or playback helper (which you'll need to implement).
    playAudio(wavData)
}

Java

En Java, los métodos de transmisión de este SDK devuelven un tipo Publisher de la biblioteca de Reactive Streams.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(new SpeechConfig(new Voice("Kore"), "en-US"))
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash-tts", config);

// Use the GenerativeModelFutures Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
    .addText("Have a wonderful day!", new SpeechMetadata(null, "cheerful and friendly"))
    .build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output.
// Extract the WAV audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        Part part = result.getCandidates().get(0).getContent().getParts().get(0);
        if (part instanceof InlineDataPart) {
            byte[] wavData = ((InlineDataPart) part).getInlineData();  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

            // Pass the audio data to your audio player or playback helper (which you'll need to implement).
            playAudio(wavData);
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } },
    languageCode: "en-US"
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.8-flash-tts",
  generationConfig
});

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
  {
    type: "text",
    text: "Have a wonderful day!",
    speechMetadata: { style: "cheerful and friendly" }
  }
];

// Call `generateContent` to generate the speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the WAV audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const wavBase64 = inlineDataParts[0].inlineData.data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  // Decode base64 to ArrayBuffer
  const wavBuffer = Uint8Array.from(atob(wavBase64), c => c.charCodeAt(0)).buffer;

  // The response is a complete WAV file, so the Web Audio API can decode and play it directly.
  const audioCtx = new AudioContext();
  const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
  const source = audioCtx.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioCtx.destination);
  source.start();
}

Dart


import 'package:firebase_ai/firebase_ai.dart';

// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
  responseModalities: [ResponseModalities.audio],
  speechConfig: SpeechConfig(voiceName: 'Kore', languageCode: 'en-US'),
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.8-flash-tts',
  generationConfig: config,
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
  TextPart(
    'Have a wonderful day!',
    speechMetadata: SpeechMetadata(style: 'cheerful and friendly'),
  ),
]);

// Call `generateContent` to generate the speech output.
final response = await model.generateContent([prompt]);

// Extract the WAV audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
  final Uint8List wavData = part.bytes;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

  // Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
  await playAudio(wavData);
}

Unity


using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Set `responseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name and language code.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: SpeechConfig.UsePrebuiltVoice("Kore", "en-US")
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
  new ModelContent.TextPart(
    "Have a wonderful day!",
    new SpeechMetadata(speaker: null, style: "cheerful and friendly")
  )
);

// Call `GenerateContentAsync` to generate the speech output.
var response = await model.GenerateContentAsync(prompt);

// Extract the WAV audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
  foreach (var part in response.Candidates[0].Content.Parts) {
    if (part is ModelContent.InlineDataPart inlineData) {
      byte[] wavData = inlineData.Data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

      // Pass the audio data to your audio player or playback helper (which you'll need to implement).
      PlayAudio(wavData);
    }
  }
}

Genera voz con varios interlocutores

Antes de probar este ejemplo, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y app.
En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página.

Puedes generar una conversación natural de dos interlocutores en una sola solicitud asignando a cada interlocutor una voz distinta y pasando cada línea de diálogo como su propio TextPart:

  1. Crea un MultiSpeakerVoiceConfig que asigne dos nombres de interlocutores (por ejemplo, "Joe" y "Jane") a sus SpeakerVoiceConfig voces.

  2. En tu GenerationConfig, establece responseModalities en AUDIO y pasa tu MultiSpeakerVoiceConfig (y languageCode opcional) a SpeechConfig.

  3. Proporciona un array o una lista de objetos TextPart, específicamente un TextPart por turno de diálogo. En cada TextPart, configura SpeechMetadata con lo siguiente:

    • (Obligatorio) Es un speaker que coincide con uno de los nombres de interlocutor definidos en tu MultiSpeakerVoiceConfig.
    • (Opcional) Una descripción de style (por ejemplo, "cheerful and friendly").
  4. Llama a generateContent. El modelo sintetiza la conversación completa y devuelve un archivo de audio WAV (audio/wav) completo.

Swift


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
let multiSpeechConfig = SpeechConfig(
  multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
    speakerVoiceConfigs: [
      SpeakerVoiceConfig(speaker: "Joe", voiceName: "Puck"),
      SpeakerVoiceConfig(speaker: "Jane", voiceName: "Kore")
    ]
  ),
  languageCode: "en-US"
)

// Set `responseModalities` to include `.audio`.
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: multiSpeechConfig
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
)

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
let prompt: [any PartsRepresentable] = [
  TextPart(
    "How's it going today, Jane?",
    speechMetadata: SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
  ),
  TextPart(
    "Not too bad, how about you?",
    speechMetadata: SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
  )
]

// Call `generateContent` to generate the multi-speaker speech output.
let response = try await model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let wavData = part.data       // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  let mimeType = part.mimeType  // for example: "audio/wav"
  print("Received audio data with MIME type: \(mimeType)")

  // Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
  playAudio(data: wavData)
}

Kotlin

En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutina.

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
val multiSpeechConfig = SpeechConfig(
    multiSpeakerVoiceConfig = MultiSpeakerVoiceConfig(
        speakerVoiceConfigs = listOf(
            SpeakerVoiceConfig(speaker = "Joe", voice = Voice("Puck")),
            SpeakerVoiceConfig(speaker = "Jane", voice = Voice("Kore"))
        )
    ),
    languageCode = "en-US"
)

// Set `responseModalities` to include `AUDIO`.
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = multiSpeechConfig
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
val prompt = content {
    text(
        text = "How's it going today, Jane?",
        speechMetadata = SpeechMetadata(speaker = "Joe", style = "cheerful and friendly")
    )
    text(
        text = "Not too bad, how about you?",
        speechMetadata = SpeechMetadata(speaker = "Jane", style = "calm and relaxed")
    )
}

// Call `generateContent` to generate the multi-speaker speech output.
val response = model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val wavData = part.inlineData  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

    // Pass the audio data to your audio player or playback helper (which you'll need to implement).
    playAudio(wavData)
}

Java

En Java, los métodos de transmisión de este SDK devuelven un tipo Publisher de la biblioteca de Reactive Streams.

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
MultiSpeakerVoiceConfig multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
    Arrays.asList(
        new SpeakerVoiceConfig("Joe", new Voice("Puck")),
        new SpeakerVoiceConfig("Jane", new Voice("Kore"))
    )
);

SpeechConfig multiSpeechConfig = new SpeechConfig(multiSpeakerVoiceConfig, "en-US");

// Set `responseModalities` to include `AUDIO`.
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(multiSpeechConfig)
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash-tts", config);

// Use the `GenerativeModelFutures` Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
Content content = new Content.Builder()
    .addText(
        "How's it going today, Jane?",
        new SpeechMetadata("Joe", "cheerful and friendly"))
    .addText(
        "Not too bad, how about you?",
        new SpeechMetadata("Jane", "calm and relaxed"))
    .build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the multi-speaker speech output.
// Extract the WAV audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        Part part = result.getCandidates().get(0).getContent().getParts().get(0);
        if (part instanceof InlineDataPart) {
            byte[] wavData = ((InlineDataPart) part).getInlineData();  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

            // Pass the audio data to your audio player or playback helper (which you'll need to implement).
            playAudio(wavData);
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    multiSpeakerVoiceConfig: {
      speakerVoiceConfigs: [
        { speaker: "Joe", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Puck" } } },
        { speaker: "Jane", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
      ]
    },
    languageCode: "en-US"
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.8-flash-tts",
  generationConfig
});

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `speechMetadata`.
const prompt = [
  {
    type: "text",
    text: "How's it going today, Jane?",
    speechMetadata: { speaker: "Joe", style: "cheerful and friendly" }
  },
  {
    type: "text",
    text: "Not too bad, how about you?",
    speechMetadata: { speaker: "Jane", style: "calm and relaxed" }
  }
];

// Call `generateContent` to generate the multi-speaker speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the WAV audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const wavBase64 = inlineDataParts[0].inlineData.data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  // Decode base64 to ArrayBuffer
  const wavBuffer = Uint8Array.from(atob(wavBase64), c => c.charCodeAt(0)).buffer;

  // The response is a complete WAV file, so the Web Audio API can decode and play it directly.
  const audioCtx = new AudioContext();
  const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
  const source = audioCtx.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioCtx.destination);
  source.start();
}

Dart


import 'package:firebase_ai/firebase_ai.dart';

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
final multiSpeechConfig = SpeechConfig.multiSpeaker(
  multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
    speakerVoiceConfigs: [
      SpeakerVoiceConfig(speaker: 'Joe', voiceName: 'Puck'),
      SpeakerVoiceConfig(speaker: 'Jane', voiceName: 'Kore'),
    ],
  ),
  languageCode: 'en-US',
);

// Set `responseModalities` to include `audio`.
final config = GenerationConfig(
  responseModalities: [ResponseModalities.audio],
  speechConfig: multiSpeechConfig,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.8-flash-tts',
  generationConfig: config,
);

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
final prompt = Content.multi([
  TextPart(
    "How's it going today, Jane?",
    speechMetadata: SpeechMetadata(speaker: 'Joe', style: 'cheerful and friendly'),
  ),
  TextPart(
    'Not too bad, how about you?',
    speechMetadata: SpeechMetadata(speaker: 'Jane', style: 'calm and relaxed'),
  ),
]);

// Call `generateContent` to generate the multi-speaker speech output.
final response = await model.generateContent([prompt]);

// Extract the WAV audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
  final Uint8List wavData = part.bytes;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

  // Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
  await playAudio(wavData);
}

Unity


using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
var multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
  new System.Collections.Generic.List<SpeakerVoiceConfig> {
    SpeakerVoiceConfig.UsePrebuiltVoice("Joe", "Puck"),
    SpeakerVoiceConfig.UsePrebuiltVoice("Jane", "Kore")
  }
);

var multiSpeechConfig = SpeechConfig.UseMultiSpeakerVoice(multiSpeakerVoiceConfig, "en-US");

// Set `responseModalities` to include `Audio`.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: multiSpeechConfig
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
);

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
var prompt = new ModelContent(
  new ModelContent.TextPart(
    "How's it going today, Jane?",
    new SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
  ),
  new ModelContent.TextPart(
    "Not too bad, how about you?",
    new SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
  )
);

// Call `GenerateContentAsync` to generate the multi-speaker speech output.
var response = await model.GenerateContentAsync(prompt);

// Extract the WAV audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
  foreach (var part in response.Candidates[0].Content.Parts) {
    if (part is ModelContent.InlineDataPart inlineData) {
      byte[] wavData = inlineData.Data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

      // Pass the audio data to your audio player or playback helper (which you'll need to implement).
      PlayAudio(wavData);
    }
  }
}

Transmite la respuesta

Antes de probar este ejemplo, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y app.
En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página.

Para reducir el tiempo hasta el primer audio (TTFA) y la reproducción en tiempo real, puedes transmitir la respuesta de audio a medida que se genera, en lugar de esperar a que termine todo el clip. La transmisión funciona con configuraciones de una sola bocina y de varias bocinas.

Para transmitir voz, llama a generateContentStream en lugar de generateContent. A diferencia de las solicitudes unarias (que devuelven un archivo WAV), las solicitudes de transmisión devuelven fragmentos de PCM sin encabezado, sin procesar, de 16 bits, con signo y con orden de bytes little-endian (audio/l16, 24 kHz, mono) para que puedas agregar cada fragmento directamente a tu búfer de salida de audio.

Swift


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Set `responseModalities` to include `.audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: SpeechConfig(voiceName: "Kore")
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
)

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
  "Tell me a story about a brave knight.",
  speechMetadata: SpeechMetadata(style: "warm, engaging audiobook narrator")
)

// Call `generateContentStream` to stream the speech output as it is generated.
let responseStream = try model.generateContentStream(prompt)

// Extract the raw PCM audio chunks and queue them for playback:
for try await chunk in responseStream {
  for part in chunk.inlineDataParts {
    let pcmChunk = part.data  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
    appendAudioChunk(pcmChunk)
  }
}

Kotlin

En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutina.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = SpeechConfig(voice = Voice("Kore"))
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
    text(
        text = "Tell me a story about a brave knight.",
        speechMetadata = SpeechMetadata(style = "warm, engaging audiobook narrator")
    )
}

// Call `generateContentStream` to stream the speech output as it is generated.
// Extract the raw PCM audio chunks and queue them for playback.
model.generateContentStream(prompt).collect { chunk ->
    val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
    if (part is InlineDataPart) {
        val pcmChunk = part.inlineData  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
        appendAudioChunk(pcmChunk)
    }
}

Java

En Java, los métodos de transmisión de este SDK devuelven un tipo Publisher de la biblioteca de Reactive Streams.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(new SpeechConfig(new Voice("Kore")))
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash-tts", config);

// Use the `GenerativeModelFutures` Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
    .addText(
        "Tell me a story about a brave knight.",
        new SpeechMetadata(null, "warm, engaging audiobook narrator"))
    .build();

// Call `generateContentStream` to stream the speech output as it is generated.
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

// Extract the raw PCM audio chunks and queue them for playback.
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
  }

  @Override
  public void onNext(GenerateContentResponse chunk) {
      Part part = chunk.getCandidates().get(0).getContent().getParts().get(0);
      if (part instanceof InlineDataPart) {
          byte[] pcmChunk = ((InlineDataPart) part).getInlineData();  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

          // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
          appendAudioChunk(pcmChunk);
      }
  }

  @Override
  public void onComplete() {
      // Audio stream complete.
  }

  @Override
  public void onError(Throwable t) {
      t.printStackTrace();
  }
});

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } }
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.8-flash-tts",
  generationConfig
});

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
  {
    type: "text",
    text: "Tell me a story about a brave knight.",
    speechMetadata: { style: "warm, engaging audiobook narrator" }
  }
];

// Call `generateContentStream` to stream the speech output as it is generated.
const result = await model.generateContentStream(prompt);

// Extract the raw PCM audio chunks and queue them for playback:
const playbackQueue = [];
for await (const chunk of result.stream) {
  const inlineDataParts = chunk.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const pcmBase64 = inlineDataParts[0].inlineData.data;  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
    const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

    // Append the audio chunk to your audio queue/buffer for playback.
    // In a real app, start playing chunks as they arrive (rather than waiting for
    // the whole stream to finish) to get the low-latency benefit of streaming.
    playbackQueue.push(pcmBuffer);
  }
}

// To play back an array of PCM buffers in sequence, pass them to your playback helper (which you'll need to write).
processPlaybackQueue(playbackQueue);

Dart


import 'package:firebase_ai/firebase_ai.dart';

// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
  responseModalities: [ResponseModalities.audio],
  speechConfig: SpeechConfig(voiceName: 'Kore'),
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.8-flash-tts',
  generationConfig: config,
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
  TextPart(
    'Tell me a story about a brave knight.',
    speechMetadata: SpeechMetadata(style: 'warm, engaging audiobook narrator'),
  ),
]);

// Call `generateContentStream` to stream the speech output as it is generated.
final responseStream = model.generateContentStream([prompt]);

// Extract the raw PCM audio chunks and queue them for playback:
await for (final chunk in responseStream) {
  final part = chunk.candidates.first.content.parts.first;
  if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
    final Uint8List pcmChunk = part.bytes;  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
    appendAudioChunk(pcmChunk);
  }
}

Unity


using System.Collections.Generic;
using System.Linq;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Set `ResponseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
var config = new GenerationConfig(
    responseModalities: new List<ResponseModality> { ResponseModality.Audio },
    speechConfig: SpeechConfig.UsePrebuiltVoice("Kore")
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
    modelName: "gemini-3.8-flash-tts",
    generationConfig: config
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
    new ModelContent.TextPart(
        "Tell me a story about a brave knight.",
        new SpeechMetadata(speaker: null, style: "warm, engaging audiobook narrator")
    )
);

// Call `GenerateContentStreamAsync` to stream the speech output as it is generated.
var responseStream = model.GenerateContentStreamAsync(prompt);

// Extract the raw PCM audio chunks and queue them for playback:
await foreach (var response in responseStream)
{
    var audioParts = response.Candidates.FirstOrDefault().Content.Parts
                            .OfType<ModelContent.InlineDataPart>();

    foreach (var part in audioParts)
    {
        byte[] pcmChunk = part.Data; // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
        AppendAudioChunk(pcmChunk);
    }
}



Controla la respuesta por voz con metadatos y etiquetas intercaladas

Los modelos Gemini 3.x TTS tratan el text dentro de cada TextPart estrictamente como una transcripción literal que se debe decir en voz alta. No escribas instrucciones narrativas (como "Say cheerfully:") dentro de la cadena de texto, o el modelo podría leer esas palabras en voz alta.

Puedes dirigir la interpretación vocal con las siguientes técnicas:

style a nivel de turno y etiquetas de voz intercaladas

Divide las instrucciones de rendimiento por alcance entre SpeechMetadata y las etiquetas de corchetes angulares intercaladas (<...>).

Permiso Dónde colocarlo Qué controla Ejemplos
A nivel de turno
(se mantiene durante todo el turno)
SpeechMetadata.style Emoción, persona, tono, inflexión, tono y velocidad general del habla "cheerful and friendly",
"whispered, nervous",
"speaking rapidly",
"out of breath",
"sarcastic"
Momento determinado
(localizado en un momento específico de la oración)
Intercala en el texto de TextPart con <...> Ráfagas vocales humanas que no sean de voz, respiraciones, pausas o cambios momentáneos en la entrega "Wait... <short pause> did you hear that? <gasp> Someone's at the door."

Ritmo, pausas, tono y énfasis

  • Puntuación y puntos suspensivos: Usa comas, guiones (--) y puntos suspensivos (...) en la transcripción para crear frases y vacilaciones naturales.

  • Etiquetas de pausa explícitas: Inserta <short pause> o <long pause> intercaladas en el punto exacto en el que el interlocutor debe pausar:

    Hold on, let me think... <short pause> Alright, I've got it.
    
  • Velocidad de habla y tono: Configura style en SpeechMetadata para controlar el ritmo, el tono o la inflexión generales del turno (por ejemplo, "speaking rapidly and excitedly", "speaking slowly" o "monotone and flat"). Si la emoción o el ritmo cambian a mitad del monólogo, divide el guion en turnos de TextPart independientes, cada uno con su propio style.

  • Énfasis en las palabras: Escribe en mayúscula palabras específicas de la transcripción para destacarlas:

    It was a VERY long day <sigh> ... nobody listens anymore.
    

Estallidos vocales y sonidos no verbales

Inserta vocalizaciones humanas que no sean de voz de forma intercalada con corchetes angulares (<...>) en el límite exacto de la palabra donde debe producirse el sonido. Usa vocalizaciones humanas en lugar de efectos de sonido no vocales. Estas son las etiquetas recomendadas que puedes usar:

<argh> <exhales> <heavy breath> <scream> <snort>
<breath> <gasp> <hiss> <short pause> <sob>
<cackle> <giggle> <laugh> /
<laughter>
<shout> <throat-clearing>
<cheer> <groan> <long pause> <shriek> <tsk>
<chuckle> /
<chuckles>
<growl> <moan> <sigh> /
<sighs>
<whimper>
<cough> <grr> <pant> <sneeze> <whispers> /
<whispering>
<cry> <grunt> <pff> /
<phew>
<snicker> <yawn>

Canales de retroalimentación y voces superpuestas

En el diálogo de varios interlocutores, puedes encerrar las reacciones breves de los oyentes entre caracteres de barra vertical (|reaction|) dentro de la transcripción del interlocutor activo. El interlocutor no activo interviene de forma natural en ese punto sin necesidad de un turno separado:

  • Respuestas breves del oyente:

    • Turno 1 (speaker: "Joe"): "So the launch is Thursday |oh hmm| Are we actually ready?"
    • Turno 2 (speaker: "Jane"): "Ready enough |oh really?| The last blocker cleared this morning."
  • Voz superpuesta: Puedes usar varios segmentos de barra vertical para simular la voz simultánea (funciona mejor con gemini-3.8-flash-tts), como los siguientes:

    • Turno 1 (speaker: "Joe"): "Let's surprise him on three |ok| ready?"
    • Turno 2 (speaker: "Jane"): "one. two. three. |happy| happy |birthday| birthday!"

Prácticas recomendadas para mantener la coherencia

  • Primero, realiza pruebas sin style y, luego, agrega ajustes concisos de style: La mayoría de las solicitudes suenan naturales con un campo style vacío. Agrega una frase corta de style (como "casual, friendly" o "reflective and awe-inspired") solo cuando un turno necesite un ajuste de publicación específico y vuelve a usar esa misma cadena corta en todos los turnos cuando quieras una base coherente.

  • Escribe transcripciones de voz naturales: Incluye contracciones conversacionales y disfluencias naturales (como "Oh, uh, yeah I think... hm, that's interesting") directamente en el texto de la transcripción.

  • Evita los bloques [Audio Profile] heredados y las metainstrucciones: Los párrafos largos de personas, los bloques [Director's Notes] o las metainstrucciones como "maintain identical timbre" aumentan la desviación de la voz. En su lugar, elige una voz coincidente de la Biblioteca de voces extendida o crea una voz de personaje persistente con Diseño de voz.

  • No intentes anular los rasgos de voz inmutables en style: Evita usar SpeechMetadata.style para cambiar la edad, el género o el acento permanente de una voz. En su lugar, selecciona o diseña una voz con esas características.



Voces admitidas

Los modelos Gemini 3.x TTS admiten tres formas de especificar una voz:

Todas las voces son multilingües, lo que significa que puedes usar la misma voz para generar voz en cualquiera de los idiomas admitidos y, al mismo tiempo, mantener una identidad de interlocutor coherente. Por ejemplo, si configuras la voz en la voz precompilada Kore y envías instrucciones en español, hindi y vietnamita, todas las respuestas usarán la voz Kore en cada uno de esos idiomas. Si bien las 30 voces precompiladas principales son voces multilingües de uso general, las voces de la biblioteca de voces extendida y las voces personalizadas están vinculadas a una configuración regional principal o a un acento regional. Esto significa que pueden hablar otros idiomas, pero suenan más auténticos en su configuración regional principal.

Voces prediseñadas principales

Los modelos de TTS de Gemini admiten 30 voces precompiladas principales (como Kore, Puck, Zephyr, Charon y Fenrir), cada una con características vocales distintas. Pasa el nombre de la voz en SpeechConfig (como se muestra en los ejemplos de una sola bocina y varias bocinas que aparecen antes en esta página).

Voces predeterminadas de la biblioteca de voces extendida

Además de las 30 voces precompiladas, la biblioteca de voces extendida proporciona más de 2,000 voces predeterminadas seleccionadas que abarcan diversos idiomas, acentos regionales, rangos de edad, personajes y casos de uso (como audiolibros, agentes de asistencia al cliente y lectores de noticias).

A continuación, se explica cómo usar cualquier voz de la biblioteca de voces extendida en tu app:

  1. Explora y obtén una vista previa de las voces con una de estas opciones:

  2. Pasa la cadena id de la voz de la biblioteca como el nombre de la voz en SpeechConfig (similar a lo que se muestra en el ejemplo de un solo interlocutor que aparece antes en esta página).

Voces personalizadas: Diseño y replicación de voz

Los modelos Gemini 3.x TTS también admiten voces personalizadas con cualquiera de las siguientes opciones:

  • Diseño de voz (versión preliminar): Genera una voz personalizada única a partir de una descripción en lenguaje natural de la edad, el timbre vocal, el acento y la personalidad de un interlocutor (sin necesidad de ningún audio de referencia). Devuelve un ID de voz almacenado (voice_...).

  • Replicación de voz (versión preliminar): Replica la voz, el tono y la cadencia de un interlocutor a partir de una grabación de referencia y una grabación de consentimiento hablado. Devuelve un ID de voz almacenado en el proyecto (voice_...) o una clave de replicación de voz sin estado administrada por la app (voicekey_...).

Usa una voz personalizada en tu app de Firebase AI Logic

La creación y administración de voces personalizadas es una operación administrativa o del servidor, por lo que los SDK cliente de Firebase AI Logic no exponen directamente los extremos de administración de voces (CreateVoice, ListVoices, DeleteVoice).

En su lugar, para usar una voz personalizada, debes hacer lo siguiente:

  1. Crea la voz personalizada una vez con una de estas opciones:

  2. Pasa la cadena voice_<id> o voicekey_<id> como el nombre de la voz en SpeechConfig (similar a lo que se muestra en el ejemplo de un solo interlocutor que aparece antes en esta página).

Ten en cuenta los siguientes requisitos cuando uses voces personalizadas:

  • Ubicación (Agent Platform Gemini API (formerly Vertex AI)): Las voces personalizadas (voice_... y voicekey_...) solo se admiten en la ubicación global (que es la ubicación predeterminada cuando se usa Firebase AI Logic).

  • Solicitudes de un solo interlocutor: MultiSpeakerVoiceConfig solo admite las voces precompiladas principales. Para usar voces diseñadas o replicadas de forma personalizada en un diálogo de varios personajes, sintetiza el turno de cada personaje en una solicitud de un solo interlocutor independiente.

  • Retención y vencimiento: Las voces personalizadas almacenadas (voice_...) vencen si no se usan durante 1 año (cada solicitud de síntesis restablece el temporizador de retención de 1 año); las claves de replicación de voz sin estado (voicekey_...) vencen 7 días después de la creación.

Lenguajes compatibles

Los modelos Gemini 3.x TTS detectan automáticamente el idioma de tu texto de entrada, incluso cuando una instrucción cambia de idioma en los turnos de un diálogo de varios interlocutores.

  • Gemini 3.8 Flash TTS (gemini-3.8-flash-tts): Admite 132 idiomas.
  • Gemini 3.8 Flash‑Lite TTS (gemini-3.8-flash-lite-tts): Admite 103 idiomas.

(Opcional) Establece un código de idioma de forma explícita

Si quieres restringir de forma explícita la síntesis de voz a una configuración regional específica, puedes pasar un languageCode de BCP-47 en tu SpeechConfig:



Formatos de salida de audio

El formato de audio predeterminado que se muestra en InlineDataPart depende de si realizas una solicitud unaria o de transmisión:

Método de solicitud Tipo de MIME predeterminado que se devuelve Detalles del formato de audio
Unario
(generateContent)
audio/wav Archivo WAV completo (PCM lineal de 16 bits, 24 kHz, mono, little-endian) con un encabezado RIFF estándar de 44 bytes.

Se puede reproducir directamente con reproductores de audio de plataformas estándar (como AVAudioPlayer en plataformas de Apple, Web Audio decodeAudioData o reproductores basados en archivos).

Transmisión
(generateContentStream)
audio/l16 Fragmentos de PCM sin encabezado, sin procesar, de 16 bits, con signo y con formato little-endian a 24 kHz, mono.

Está diseñado para la puesta en cola de búferes y la concatenación de baja latencia sin encabezados de archivo por fragmento.



Limitaciones y requisitos

Ten en cuenta las siguientes limitaciones y requisitos cuando uses los modelos de Gemini 3.x TTS:

  • Entrada solo de texto, salida solo de audio: Los modelos de TTS solo aceptan entradas de texto (TextPart) y requieren que responseModalities se establezca en AUDIO.

  • Solo síntesis textual: Los modelos recitan la transcripción proporcionada textualmente y no generan respuestas de texto conversacionales.

  • Límites de tokens: La entrada máxima es de 8,192 tokens y la salida máxima es de 16,384 tokens por solicitud.

  • Límite de varios interlocutores: MultiSpeakerVoiceConfig requiere 2 interlocutores y solo admite voces precompiladas principales. Cada TextPart en una solicitud de varios interlocutores debe incluir un SpeechMetadata.speaker que coincida con uno de los interlocutores configurados.

  • Parámetros y métodos no admitidos:

    • Los SDK de Firebase AI Logic todavía no admiten la configuración de responseFormat en GenerationConfig para anular el formato de salida de audio predeterminado.
    • No se admite la configuración de systemInstruction, temperature, topP, topK, candidateCount, presencePenalty o frequencyPenalty, y hace que las solicitudes fallen con un error 400 INVALID_ARGUMENT.
    • No se admite la llamada a countTokens para los modelos de TTS (los recuentos de tokens se devuelven en usageMetadata en la respuesta).
  • Ubicación (Agent Platform Gemini API (formerly Vertex AI)): Las voces personalizadas (voice_... y voicekey_...) requieren la ubicación global (que es la ubicación predeterminada cuando se usa Firebase AI Logic).



Migra desde gemini-3.1-flash-tts-preview

Tanto gemini-3.8-flash-tts como gemini-3.8-flash-lite-tts usan la misma estructura de solicitud. Revisa la tabla de comparación de modelos para elegir el mejor reemplazo para tu carga de trabajo y actualiza tu código de la siguiente manera:

Área gemini-3.1-flash-tts-preview (heredada) gemini-3.8-flash-tts y
gemini-3.8-flash-lite-tts
Estilo y dirección de la presentación Incorporado en el texto de la instrucción. Por ejemplo:
"Say cheerfully: ...",
[Audio Profile],
[Director's Notes]
Se pasa en SpeechMetadata(style: "...") en cada TextPart

Mantén el texto de TextPart estrictamente en la transcripción textual de lo que se dice.

Diálogo con varios interlocutores Cadena de texto única con prefijos "Speaker: ..." intercalados Un TextPart por turno de diálogo, con SpeechMetadata(speaker: "...", style: "...") en cada TextPart
Etiquetas de voz intercaladas Corchetes. Por ejemplo,
[sigh] o [laughs]
Corchetes angulares. Por ejemplo,
<sigh>, <laugh> o <short pause>

Escribe las disfluencias habladas, como "uhm", directamente en el texto.

Formato de audio unario predeterminado (generateContent) PCM sin procesar de 16 bits sin encabezado (audio/pcm, 24 kHz, mono) Archivo WAV completo (audio/wav, PCM de 16 bits, 24 kHz, mono, con un encabezado RIFF de 44 bytes)

La transmisión (generateContentStream) sigue siendo PCM sin procesar de 16 bits sin encabezado (audio/l16).

Instrucciones del sistema, temperatura, top-P y top-K Ignorada Se rechazó con un error 400 INVALID_ARGUMENT. Quita estos parámetros de la configuración del modelo.

Lista de tareas para la migración

  • Actualiza a la versión más reciente del SDK de Firebase AI Logic y cambia el nombre de tu modelo a gemini-3.8-flash-tts o gemini-3.8-flash-lite-tts.

  • Mueve las instrucciones de estilo a SpeechMetadata.style: Quita los prefijos "Say cheerfully:", [Audio Profile], [Scene] y [Director's Notes] de tus cadenas de instrucciones para que el modelo no las lea en voz alta. En su lugar, pasa una descripción de estilo concisa en SpeechMetadata.style.

  • Divide los guiones de varios interlocutores en turnos de TextPart independientes: Reemplaza los bloques de texto "Joe: ... \n Jane: ..." por un array o una lista de objetos TextPart en los que cada turno establezca SpeechMetadata.speaker.

  • Convierte las etiquetas [...] en etiquetas <...>: Reemplaza las etiquetas de audio entre corchetes (como [whispers], [sighs] y [laughs]) por etiquetas de voz entre corchetes angulares (como <whispers>, <sigh>, <laugh> y <short pause>).

  • Actualiza la reproducción de audio unario: Debido a que generateContent ahora devuelve un archivo WAV completo (con un encabezado RIFF de 44 bytes) en lugar de PCM sin procesar y sin encabezado, quita cualquier código que anteponga de forma manual un encabezado WAV a las respuestas unarias (o omite el encabezado de 44 bytes si ingresas muestras de PCM sin procesar en una API de búfer de bajo nivel, como AudioTrack de Android o AudioClip de Unity).

  • Quita los parámetros de configuración no admitidos: Quita temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty y systemInstruction de tu configuración de TTS GenerativeModel.



¿Qué más puedes hacer?

Prueba otras funciones

Aprende a controlar la generación de contenido

También puedes experimentar con instrucciones y configuraciones de modelos, y hasta obtener un fragmento de código generado con Google AI Studio.

Más información sobre los modelos compatibles

Obtén información sobre los modelos disponibles para varios casos de uso, sus cuotas y sus precios.


Envía comentarios sobre tu experiencia con Firebase AI Logic