Sprachausgabe

Die Gemini API kann Texteingaben mithilfe der Gemini-Funktionen für die Text-zu-Sprache-Generierung (TTS) in Audioinhalte mit einem oder mehreren Sprechern umwandeln. Die Text-zu-Sprache-Generierung ist steuerbar. Sie können also strukturierte Metadaten für Äußerungen (speech_metadata) und Inline-Sprach-Tags kombinieren, um Stil, Akzent, Tempo und Ton des Audios zu steuern.

Die TTS-Funktion unterscheidet sich von der Sprachgenerierung über die Live API, die für interaktive, unstrukturierte Audioinhalte sowie multimodale Ein- und Ausgaben konzipiert ist. Während die Live API sich in dynamischen Gesprächskontexten auszeichnet, ist TTS über die Gemini API auf Szenarien zugeschnitten, die eine genaue Textwiedergabe mit detaillierter Kontrolle über Stil und Klang erfordern, z. B. die Erstellung von Podcasts oder Hörbüchern.

In dieser Anleitung erfahren Sie, wie Sie mit Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) und Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) Audio für einen einzelnen Sprecher und für mehrere Sprecher aus Text generieren.

Hinweis

Verwenden Sie ein Gemini-TTS-Modell, das im Abschnitt Unterstützte Modelle aufgeführt ist, und führen Sie ein Upgrade auf das neueste Google GenAI SDK (google-genai >= 2.25.0 für Python oder @google/genai >= 2.24.0 für JavaScript/TypeScript) durch oder verwenden Sie die REST API. Die besten Ergebnisse erzielen Sie, wenn Sie Wann welches Modell verwendet werden sollte lesen, um das beste Modell für Ihre Arbeitslast auszuwählen.

Es kann hilfreich sein, die Gemini TTS-Modelle in AI Studio zu testen, bevor Sie mit der Entwicklung beginnen.

TTS mit einem Sprecher

Wenn Sie Text mit Gemini 3.8-TTS-Modellen in Audio von einem einzelnen Sprecher umwandeln möchten, übergeben Sie das wörtliche Transkript in input, hängen Sie mit einer speech_metadata-Annotation einen Stil auf Turn-Ebene an und konfigurieren Sie Ihre Stimme in generation_config.speech_config. Sie können eine Stimme aus den vordefinierten Stimmoptionen, der erweiterten Stimmenbibliothek (GET /v1beta/voices), einer benutzerdefinierten Stimmendesign-ID (voice_...) oder einer Stimmenreplikations-ID (voice_... oder optional zustandslos voicekey_...) auswählen.

In diesem Beispiel wird die standardmäßige WAV-Audioausgabe (audio/wav) des Modells direkt in einer Datei gespeichert:

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [{
            "type": "text",
            "text": "Have a wonderful day!",
            "annotations": [{
                "type": "speech_metadata",
                "style": "cheerful and friendly",
            }],
        }],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": [
            {"voice": "Kore"},
        ]
    },
)

with open("out.wav", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [{
            type: 'text',
            text: 'Have a wonderful day!',
            annotations: [{
               type: 'speech_metadata',
               style: 'cheerful and friendly',
            }],
         }],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: [
            { voice: 'Kore' },
         ],
      },
   });

   const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
   fs.writeFileSync('out.wav', audioBuffer);
}
await main();

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [{
        "type": "text",
        "text": "Have a wonderful day!",
        "annotations": [{
          "type": "speech_metadata",
          "style": "cheerful and friendly"
        }]
      }]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": [
        { "voice": "Kore" }
      ]
    }
  }' | jq -r '[.steps[] | select(.type=="model_output") | .content[] | select(.type=="audio")] | last | .data' | base64 --decode > out.wav

In den Python- und JavaScript-SDKs können Sie generierte Audiodaten mit dem Convenience-Attribut interaction.output_audio abrufen, das den zuletzt generierten Audioblock zurückgibt. In REST-JSON-Rohantworten werden die base64-codierten Audiodaten in steps[].content[].data gespeichert. Weitere Informationen zu Convenience-Attributen finden Sie in der Übersicht über Interaktionen.

TTS mit mehreren Sprechern

Konfigurieren Sie für Dialoge mit mehreren Sprechern zwei Sprecher in speech_config.speakers und übergeben Sie jeden Redebeitrag als separates Textelement mit einer speech_metadata-Annotation, die die speaker und optional die style auf Redebeitragsebene angibt. Beachten Sie, dass speech_config für die Generierung mit einem einzelnen Sprecher ein Array ([{"voice": "..."}]) und für die Generierung mit mehreren Sprechern ein Objekt ({"speakers": [...]}) akzeptiert:

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [
            {
                "type": "text",
                "text": "How's it going today Jane?",
                "annotations": [{
                    "type": "speech_metadata",
                    "speaker": "Joe",
                    "style": "cheerful and friendly",
                }],
            },
            {
                "type": "text",
                "text": "Not too bad, how about you? Ready to test these new voices?",
                "annotations": [{
                    "type": "speech_metadata",
                    "speaker": "Jane",
                    "style": "calm and relaxed",
                }],
            },
        ],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": {
            "speakers": [
                {"speaker": "Joe", "voice": "Puck"},
                {"speaker": "Jane", "voice": "Kore"},
            ],
        }
    },
)

with open("out.wav", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [
            {
               type: 'text',
               text: "How's it going today Jane?",
               annotations: [{
                  type: 'speech_metadata',
                  speaker: 'Joe',
                  style: 'cheerful and friendly',
               }],
            },
            {
               type: 'text',
               text: 'Not too bad, how about you? Ready to test these new voices?',
               annotations: [{
                  type: 'speech_metadata',
                  speaker: 'Jane',
                  style: 'calm and relaxed',
               }],
            },
         ],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: {
            speakers: [
               { speaker: 'Joe', voice: 'Puck' },
               { speaker: 'Jane', voice: 'Kore' },
            ],
         },
      },
   });

   const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
   fs.writeFileSync('out.wav', audioBuffer);
}

await main();

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [
        {
          "type": "text",
          "text": "How'\''s it going today Jane?",
          "annotations": [{
            "type": "speech_metadata",
            "speaker": "Joe",
            "style": "cheerful and friendly"
          }]
        },
        {
          "type": "text",
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "annotations": [{
            "type": "speech_metadata",
            "speaker": "Jane",
            "style": "calm and relaxed"
          }]
        }
      ]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": {
        "mode": "conversational",
        "speakers": [
          { "speaker": "Joe", "voice": "Puck" },
          { "speaker": "Jane", "voice": "Kore" }
        ]
      }
    }
  }'

Sprachstil mit Metadaten und Tags steuern

Gemini 3.8 TTS behandelt das Feld text strikt als wörtliches Transkript. Wenn Sie die Ausführung steuern möchten, ohne dass Regieanweisungen vorgelesen werden, teilen Sie Ihre Anweisungen nach Umfang auf:

• Kontinuierliche Bereitstellung auf Turn-Ebene (speech_metadata.style): Geben Sie Emotionen, Bereitstellungsstil, Prosodie, Tempo und Lautstärke, die für einen gesamten Turn gelten, im Feld style an (z. B. "style": "whispered urgently", "style": "out of breath" oder "style": "warm and enthusiastic").
• Zeitpunktbezogene Ereignisse (Inline-Tags): Platzieren Sie kurze, nicht sprachliche Geräusche oder Pausen direkt im Transkript. Verwenden Sie dazu spitze Klammern (z. B. "Wait... <short pause> did you hear that? <sigh>" oder "Excuse me <cough> as I was saying...").

Umfassende Best Practices finden Sie im Leitfaden für Prompts.

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [
            {
                "type": "text",
                "text": "Wait... <short pause> look under that fallen log! Is that a blue-spotted salamander?",
                "annotations": [{
                    "type": "speech_metadata",
                    "speaker": "Dr. Anya",
                    "style": "whispered urgently",
                }],
            },
            {
                "type": "text",
                "text": "<gasp> No way! <laugh> We've been searching for this species all season!",
                "annotations": [{
                    "type": "speech_metadata",
                    "speaker": "Liam",
                    "style": "warm and enthusiastic",
                }],
            },
        ],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": {
            "speakers": [
                {"speaker": "Dr. Anya", "voice": "Kore"},
                {"speaker": "Liam", "voice": "Puck"},
            ],
        }
    },
)

with open("out.wav", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [
            {
               type: 'text',
               text: 'Wait... <short pause> look under that fallen log! Is that a blue-spotted salamander?',
               annotations: [{
                  type: 'speech_metadata',
                  speaker: 'Dr. Anya',
                  style: 'whispered urgently',
               }],
            },
            {
               type: 'text',
               text: "<gasp> No way! <laugh> We've been searching for this species all season!",
               annotations: [{
                  type: 'speech_metadata',
                  speaker: 'Liam',
                  style: 'warm and enthusiastic',
               }],
            },
         ],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: {
            speakers: [
               { speaker: 'Dr. Anya', voice: 'Kore' },
               { speaker: 'Liam', voice: 'Puck' },
            ],
         },
      },
   });

   if (interaction.output_audio?.data) {
      const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
      fs.writeFileSync('out.wav', audioBuffer);
   }
}

await main();

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [
        {
          "type": "text",
          "text": "Wait... <short pause> look under that fallen log! Is that a blue-spotted salamander?",
          "annotations": [{
            "type": "speech_metadata",
            "speaker": "Dr. Anya",
            "style": "whispered urgently"
          }]
        },
        {
          "type": "text",
          "text": "<gasp> No way! <laugh> We'\''ve been searching for this species all season!",
          "annotations": [{
            "type": "speech_metadata",
            "speaker": "Liam",
            "style": "warm and enthusiastic"
          }]
        }
      ]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": {
        "speakers": [
          { "speaker": "Dr. Anya", "voice": "Kore" },
          { "speaker": "Liam", "voice": "Puck" }
        ]
      }
    }
  }'

Sprachgenerierung per Streaming

Sie können die generierten Audioinhalte während der Synthese streamen, indem Sie stream: true festlegen. Im Gegensatz zu unären Anfragen, die eine vollständige WAV-Datei mit einem RIFF-Header zurückgeben, geben Streaminganfragen standardmäßig headerlose, signierte 16-Bit-Little-Endian-Linear-PCM-Rohdatenblöcke (audio/l16, 24 kHz, Mono) zurück, sodass Audioblöcke ohne Containerheader kontinuierlich abgespielt oder verkettet werden können.

import base64
from google import genai

client = genai.Client()

stream = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [{
            "type": "text",
            "text": "Have a wonderful day!",
            "annotations": [{
                "type": "speech_metadata",
                "style": "cheerful and friendly",
            }],
        }],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": [
            {"voice": "Kore"},
        ]
    },
    stream=True,
)

for event in stream:
    if event.event_type == "step.delta":
        if event.delta.type == "audio":
            audio_data = base64.b64decode(event.delta.data)
            # Process the audio chunk (e.g. play it or write to a file)

import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const stream = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [{
            type: 'text',
            text: 'Have a wonderful day!',
            annotations: [{
               type: 'speech_metadata',
               style: 'cheerful and friendly',
            }],
         }],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: [
            { voice: 'Kore' },
         ],
      },
      stream: true,
   });

   for await (const event of stream) {
      if (event.event_type === 'step.delta') {
         if (event.delta.type === 'audio') {
            const audioBuffer = Buffer.from(event.delta.data, 'base64');
            // Process the audio buffer
         }
      }
   }
}
await main();

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  --no-buffer \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [{
        "type": "text",
        "text": "Have a wonderful day!",
        "annotations": [{
          "type": "speech_metadata",
          "style": "cheerful and friendly"
        }]
      }]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": [
        { "voice": "Kore" }
      ]
    },
    "stream": true
  }'

Audioausgabeformate

Gemini 3.8-TTS-Modelle verwenden je nachdem, ob die Anfrage unär oder gestreamt ist, unterschiedliche Standardaudioformate:

• Unäre Anfragen (stream=False): Gib vollständiges WAV-Audio (audio/wav) mit einem standardmäßigen RIFF-Header (24 kHz, Mono, 16-Bit-PCM mit Vorzeichen und Little-Endian-Byte-Reihenfolge) zurück. Sie können die decodierten Audio-Bytes direkt in einer .wav-Datei speichern, ohne manuell einen WAV-Header voranstellen zu müssen.
• Streaminganfragen (stream=True): Geben standardmäßig headerlose lineare PCM-Rohdatenblöcke (audio/l16) (24 kHz, Mono, 16-Bit-PCM mit Vorzeichen und Little-Endian-Format) zurück, sodass Blöcke kontinuierlich gestreamt oder verkettet werden können, ohne dass jeder Block Containerheader enthält.

Wenn Sie eine andere Audiocodierung oder Abtastrate anfordern möchten, konfigurieren Sie mime_type und optional sample_rate in response_format:

Sie können sample_rate auch in Hertz angeben (z. B. 24000, 16000 oder 8000).

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [{
            "type": "text",
            "text": "Have a wonderful day!",
            "annotations": [{
                "type": "speech_metadata",
                "style": "cheerful and friendly",
            }],
        }],
    }],
    response_format={
        "type": "audio",
        "mime_type": "audio/l16",  # "audio/wav" (default), "audio/l16", "audio/mulaw", or "audio/alaw"
        "sample_rate": 24000,
    },
    generation_config={
        "speech_config": [
            {"voice": "Kore"},
        ]
    },
)

with open("out.pcm", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [{
            type: 'text',
            text: 'Have a wonderful day!',
            annotations: [{
               type: 'speech_metadata',
               style: 'cheerful and friendly',
            }],
         }],
      }],
      response_format: {
         type: 'audio',
         mime_type: 'audio/l16', // 'audio/wav' (default), 'audio/l16', 'audio/mulaw', or 'audio/alaw'
         sample_rate: 24000,
      },
      generation_config: {
         speech_config: [
            { voice: 'Kore' },
         ],
      },
   });

   const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
   fs.writeFileSync('out.pcm', audioBuffer);
}
await main();

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [{
        "type": "text",
        "text": "Have a wonderful day!",
        "annotations": [{
          "type": "speech_metadata",
          "style": "cheerful and friendly"
        }]
      }]
    }],
    "response_format": {
      "type": "audio",
      "mime_type": "audio/l16",
      "sample_rate": 24000
    },
    "generation_config": {
      "speech_config": [
        { "voice": "Kore" }
      ]
    }
  }'

Stimmoptionen

Gemini 3.8 TTS unterstützt vier Möglichkeiten zum Auswählen oder Erstellen von Stimmen:

1. Vordefinierte Studio-Stimmen: 30 ausgewählte Stimmen, die in der folgenden Tabelle aufgeführt sind.
2. Erweiterte Sprachbibliothek: Hunderte zusätzliche Stimmen in verschiedenen Sprachen, Akzenten und Charakterarchetypen, die über client.voices.list() (GET /v1beta/voices) zugänglich sind.
3. Voice Design: Generieren Sie eine benutzerdefinierte Stimm-Persona aus einer Beschreibung in natürlicher Sprache in Google AI Studio oder mit POST /v1beta/voices (type="prompted", das eine persistente voice_...-ID und eine sample_audio-WAV-Vorschau in CreateVoice und GetVoice zurückgibt).
4. Stimmreplikation:Die Stimme eines Sprechers wird anhand von Referenz- und Einwilligungs-Audio in Google AI Studio oder mit POST /v1beta/voices (type="replicated", standardmäßig persistent store=True oder optional zustandslos store=False) repliziert.

Benutzerdefinierte Sprachlimits und TTL

* TTL-Verlängerung:Die einjährige Aufbewahrungsfrist wird jedes Mal zurückgesetzt, wenn die Stimme aktiv verwendet wird (entweder durch Synthetisieren von Sprache mit der Stimme oder durch Verwendung als Basisstimme für das Remixen). Stimmen, die seit einem Jahr nicht mehr verwendet wurden, werden automatisch gelöscht.

Vordefinierte Stimmen

Erweiterte Stimmenbibliothek und Filter

Zusätzlich zu den 30 vorgestellten Studio-Stimmen in der vorherigen Tabelle bietet die erweiterte Stimmenbibliothek Hunderte zusätzliche Stimmen in verschiedenen Sprachen, regionalen Akzenten, Charakteren und Bereichen. Sie können die gesamte Voice Library interaktiv in Google AI Studio durchsuchen, filtern und testen oder sie programmatisch mit client.voices.list() abfragen (GET /v1beta/voices, mit google-genai 2.25.0+ / @google/genai 2.24.0+).

ListVoices gibt Ihre benutzerdefinierten gespeicherten Stimmen (neueste zuerst) und dann die vorgefertigten Katalogstimmen zurück, die Ihren Filterkriterien entsprechen. Wenn mehrere Werte für einen Listenfilter übergeben werden, werden Stimmen zurückgegeben, die mit einem beliebigen Wert in diesem Filter übereinstimmen (OR). Unterschiedliche Filterparameter werden mit AND kombiniert:

from google import genai

client = genai.Client()

# Filter the Voice Library by language, gender, pitch, domain context, and keyword
response = client.voices.list(
    language_code=["en-US", "en-GB"],
    gender=["female"],
    pitch=["medium", "low"],
    contexts=["Audiobook", "Conversational"],
    type_=["prebuilt"],
    search="warm",
    page_size=50,
)

for voice in response.voices or []:
    print(
        f"{voice.id} | {voice.display_name} ({voice.language_code},"
        f" {voice.accent}, {voice.gender}, pitch={voice.pitch}):"
        f" {voice.description}"
    )

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI();

// Filter the Voice Library by language, gender, pitch, domain context, and keyword
const response = await ai.voices.list({
  language_code: ["en-US", "en-GB"],
  gender: ["female"],
  pitch: ["medium", "low"],
  contexts: ["Audiobook", "Conversational"],
  type: ["prebuilt"],
  search: "warm",
  page_size: 50,
});

for (const voice of response.voices ?? []) {
  console.log(
    `${voice.id} | ${voice.display_name} (${voice.language_code}, ${voice.accent}, ${voice.gender}, pitch=${voice.pitch}): ${voice.description}`
  );
}

curl -G "https://generativelanguage.googleapis.com/v1beta/voices" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  --data-urlencode "language_code=en-US" \
  --data-urlencode "language_code=en-GB" \
  --data-urlencode "gender=female" \
  --data-urlencode "pitch=medium" \
  --data-urlencode "context=Audiobook" \
  --data-urlencode "type=prebuilt" \
  --data-urlencode "search=warm" \
  --data-urlencode "page_size=50"

Unterstützte Sprachen

Die TTS-Modelle erkennen die Eingabesprache automatisch. Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) unterstützt über 130 Sprachen und Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) unterstützt über 100 Sprachen:

Unterstützte Modelle

Wann welches Modell verwendet werden sollte

Beide Gemini 3.8-TTS-Modelle verwenden genau dasselbe API-Schema und Prompt-Format, sodass Sie mit einer einzigen Parameteränderung zwischen ihnen wechseln können:

• Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) verwenden, wenn maximale akustische Wiedergabetreue, nuancierte Darstellung und ausdrucksstarke Steuerung oberste Priorität haben. Sie eignet sich ideal für kreative Arbeiten in Studioqualität, komplexe Dialoge mit mehreren Sprechern, Tags für starke Gesangspassagen, schwierige Aussprachen, regionale oder Minderheitendialekte und lange Erzählungen, die eine stabile Stimme und einen stabilen Raumton erfordern.
• Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) als schnelle, kostengünstige Alternative für gemini-3.1-flash-tts-preview verwenden. Es ist für die Massenproduktion in großem Umfang, Kaskaden von Sprach-Agents für Unterhaltungen, Vorlesefunktionen, zuverlässige Stimmenklonung und alltägliche Sprache mit einem einzelnen Sprecher in den wichtigsten Sprachen optimiert.

Migrationsanleitung

Wenn Sie von gemini-3.1-flash-tts-preview oder früheren Gemini TTS-Modellen zu Gemini 3.8 TTS migrieren:

1. Anweisungen auf Turn-Ebene in speech_metadata verschieben: Gemini 3.8 TTS behandelt Eingabetext strikt als wörtliches Transkript. Verschieben Sie Anweisungen zur anhaltenden Übermittlung (style, z. B. "whispering", "out of breath" oder "speaking slowly") und Sprecherlabels (speaker) in strukturierte speech_metadata-Anmerkungen, anstatt Regieanweisungen in den Transkripttext einzubetten.
2. Verwenden Sie Inline-Tags mit spitzen Klammern nur für punktuelle stimmliche Ereignisse: Behalten Sie kurze, nicht sprachliche Äußerungen und Pausen im Transkript bei, indem Sie spitze Klammern verwenden (z. B. <laugh>, <sigh>, <cough>, <breath> oder <short pause>). Vermeiden Sie Tags für Soundeffekte (z. B. Applaus oder dumpfe Geräusche) und setzen Sie Vortragsstile in speech_metadata.style.
3. Geben Sie speaker bei jedem Turn in Anfragen mit mehreren Sprechern an: Jeder Turn in einer Anfrage mit mehreren Sprechern muss explizit speaker in speech_metadata enthalten, das einem der konfigurierten Sprecher entspricht.
4. Design-Personas im Voraus mit Voice Design erstellen:Ersetzen Sie "Audio Profile"- oder "Director's Notes"-Blöcke mit mehreren Absätzen durch eine benutzerdefinierte Stimme, die in Voice Design erstellt wurde. Übertragen Sie dann die voice_...-ID in Ihre TTS-Anfragen mit minimalen oder leeren style-Strings.
5. Standard-WAV-Ausgabe (audio/wav) bei unären Anfragen berücksichtigen:Im Gegensatz zu gemini-3.1-flash-tts-preview und früheren TTS-Modellen (die standardmäßig headerloses rohes PCM audio/l16 zurückgegeben haben) gibt Gemini 3.8 TTS bei unären Anfragen standardmäßig WAV-Audio (audio/wav) mit einem Standard-RIFF-Header zurück.
   • Wenn Ihr Code zuvor Roh-PCM-Bytes in einen WAV-Header eingeschlossen hat (z. B. mit dem wave-Modul oder ffmpeg von Python), entfernen Sie den manuellen Header-Wrapper und schreiben Sie die zurückgegebenen Bytes direkt in eine .wav-Datei.
   • Wenn Ihre Pipeline unkomprimiertes PCM-, Mu-Law- oder A-Law-Audio ohne Header erfordert, legen Sie response_format.mime_type explizit auf "audio/l16", "audio/mulaw" oder "audio/alaw" fest (z. B. {"response_format": {"type": "audio", "mime_type": "audio/l16"}} in der Interactions API oder AUDIO_L16 in generateContent). Weitere Informationen finden Sie unter Audioausgabeformate.

Leitfaden für Prompts

Gemini 3.8 TTS-Modelle behandeln Eingabetext strikt als wörtliches Transkript. Im Gegensatz zu früheren Vorschau-Modellen, bei denen Regieanweisungen in Nur-Text eingebettet waren, trennt Gemini 3.8 TTS dauerhafte Anweisungen auf Turn-Ebene (speech_metadata) von punktuellen Inline-Vocal-Tags.

Stilfeld im Vergleich zu Inline-Tags

Teilen Sie Ihre Leistungsanweisungen nach Umfang auf:

• Lieferung auf Turn-Ebene (speech_metadata.style): Attribute für die kontinuierliche Lieferung, z. B. Emotion, Prosodie, allgemeines Tempo oder Lieferstil (z. B. "whispering", "out of breath", "muttering" oder "sarcastic"), werden in das Feld style von speech_metadata eingefügt. Damit die Figur und die Leistung über die verschiedenen Züge hinweg stabil bleiben, sollten Sie die Persona im Voraus im Voice Design entwerfen und style nur für optionale Anpassungen auf Zugebene verwenden.
• Zeitpunktbezogene Ereignisse (Inline-Tags): Setzen Sie kurze nicht sprachliche Vokalbursts, Atemzüge oder Pausen mit spitzen Klammern (<cough>, <breath>, <sigh>, <short pause>) in den Transkripttext ein. Verwenden Sie spitze Klammern (<...>) für die höchste Audioqualität und beschränken Sie sich auf menschliche Vokalisationen anstelle von nicht vokalen Soundeffekten.

Tempo und Pausen

Sie können Rhythmus und Stille auf drei Detaillierungsgraden steuern:

• Satzzeichen und Auslassungspunkte: Verwenden Sie Kommas, Gedankenstriche (--) und Auslassungspunkte (...), um natürliche Gesprächspausen zu erzeugen.
• Inline-Pausen-Tags: Fügen Sie <short pause> oder <long pause> an den genauen Stellen im Skript ein, an denen ein Sprecher eine Pause einlegen soll: text Hold on, let me think... <short pause> Alright, I've got it.
• Geschwindigkeit auf Turn-Ebene:Legen Sie "style": "speaking rapidly" oder "style": "speaking slowly" in speech_metadata fest, um die Sprechgeschwindigkeit für den gesamten Turn zu steuern.

Prosodie und Tonhöhe

Verwenden Sie speech_metadata.style, um die Prosodie, die Tonhöhe und die Betonung innerhalb eines Turns zu steuern (z. B. "style": "high pitch, cheerful and excited inflection" oder "style": "monotone and flat"). Wenn sich die Emotion oder Prosodie mitten im Dialog ändert, teilen Sie das Skript in separate Turns mit unterschiedlichen style-Werten für jeden Turn auf.

Schwerpunkt

Bestimmte Wörter im Transkript werden großgeschrieben und mit Satzzeichen und Inline-Vokal-Tags kombiniert, um wichtige Wörter natürlich zu betonen:

This is a VERY important point!
It was a VERY long day <sigh> ... nobody listens anymore.

Vokale Ausrufe und Geräusche, die keine Sprache sind

Platzieren Sie nicht sprachliche menschliche Äußerungen inline mit spitzen Klammern (<...>) an der genauen Stelle, an der das Geräusch auftreten soll. Empfohlene Tags für Gesang:

Backchannels und sich überschneidende Sprache

In Dialogen mit mehreren Sprechern können Sie die Reaktionen der Zuhörer in Pipe-Zeichen (|reaction|) innerhalb des Redebeitrags eines Sprechers einschließen, um natürliche Backchannels oder überlappende Sprache zu erzeugen, ohne für jede Reaktion einen separaten Redebeitrag zu erstellen.

• Kurze Backchannel-Reaktionen:Füge kurze Reaktionen des Zuhörers (|oh hmm|, |oh really?|, |absolutely|) in den Zug des aktiven Sprechers ein:
  • Runde 1 (Sprecher A): "So the launch is Thursday |oh hmm| Are we actually ready?"
  • Runde 2 (Sprecher B): "Ready enough |oh really?| The last blocker cleared this morning."
  • Turn 3 (Speaker A): "Then let's ship it |absolutely| and watch the dashboards."
• Überlappende und verschachtelte Sprache:Verwenden Sie mehrere Pipe-Segmente, um gleichzeitige oder verschachtelte Sprache zwischen zwei Sprechern zu simulieren. Das funktioniert am besten mit gemini-3.8-flash-tts:
  • Gleichzeitiger Countdown/Refrain:"Let's surprise him on three |ok| ready?" gefolgt von "one. two. three. |happy| happy |birthday| birthday!"
  • Vollständige Überlappung der Sprecher: "Hello |oh| there |my| it |goodness| must |gracious| be |would| almost |you| time |look| for |at that| dinner"

Konsistenz über Generationen hinweg und was Sie vermeiden sollten

Beachten Sie die folgenden Richtlinien, um die Stimmidentität über mehrere Turns hinweg stabil zu halten:

• Designen Sie Personas im Voraus im Voice-Design anstelle von langen Stilblöcken: Lange "Audio Profile"-Absätze und "Director's Notes"-Listen mit mehreren Aufzählungszeichen, die aus früheren Modellen übernommen wurden, sind die häufigste Ursache für Abweichungen im Voice. Nutzen Sie diese kreative Intuition von Anfang an beim Voice Design, um eine dauerhafte benutzerdefinierte voice_...-Persona zu erstellen, und verwenden Sie diese Voice-ID dann in Ihren TTS-Aufrufen.
• Verlassen Sie sich auf die Sprachreferenz, um die Stabilität zu gewährleisten (keine Meta-Anweisungen): Gemini 3.8-TTS-Modelle sind so trainiert, dass sie sich zuerst an der Audioreferenz orientieren. Fügen Sie keine Anweisungen hinzu, die das Modell auffordern, die Stimme stabil zu halten (z. B. "do not switch speaker identity" oder "maintain identical timbre"). Zusätzlicher Prompt-Text erhöht die Abweichung. Lassen Sie unnötige Stilanweisungen weg und lassen Sie das Modell natürlich um den stabilen Punkt variieren, der durch die Stimmreferenz vorgegeben wird.
• Unveränderliche Sprechermerkmale in style nicht ändern: Geben Sie in speech_metadata.style keine Änderungen des Alters, Geschlechts, Namens oder des Akzents an. Wählen Sie stattdessen eine regionale Stimme aus der erweiterten Sprachbibliothek aus oder erstellen Sie eine mit Voice Design.

Empfohlener Workflow

1. Charakter einmal erstellen:Erstellen Sie Ihren Charakter unter Voice Design oder wählen Sie eine regionale Stimme aus der erweiterten Stimmenbibliothek aus, die zu Ihrer Zielsprache und Persona passt.
2. Natürliche gesprochene Transkripte mit Unflüssigkeiten schreiben: Für maximale Natürlichkeit sollten Sie die text als echtes gesprochenes Transkript schreiben, einschließlich natürlicher Unflüssigkeiten und Zögern (z. B. "Oh uh yeah I think... hm, so that's interesting").
3. Zuerst einfache Sprachausgabe testen: Synthetisieren Sie Ihr Transkript zuerst mit einem leeren style-Feld. Für die meisten Anfragen ist überhaupt keine style-Anweisung erforderlich.
4. Kurze style-Prompts nur für Anpassungen hinzufügen: Fügen Sie einen kurzen style-String (z. B. "casual, friendly" oder "muttering, then reassuring") nur für Turns hinzu, die eine bestimmte Anpassung der Ausgabe erfordern. Verwenden Sie diesen kurzen String für alle Turns, wenn Sie eine einheitliche Baseline wünschen.

Mehrfachdialog- und Sprach-Agenten

Wenn Sie Echtzeit-Sprachagenten oder Anwendungen mit mehreren Durchgängen erstellen:

• Führen Sie einen TTS-Aufruf pro Runde aus, wenn LLM-Textblöcke eingehen.
• Lassen Sie die konfigurierte voice (vordefiniert, entworfene voice_... oder replizierte voice_... / voicekey_...) die Identität des Sprechers über die Turns hinweg tragen. Senden Sie niemals eine lange Zeichenpersona bei jedem Turn neu.
• Lassen Sie das Feld style für jede Runde leer oder senden Sie einen kurzen konstanten String (z. B. "casual, friendly") für die gesamte Unterhaltung.
• Teilen Sie lange Antworten des Agenten in kürzere Abschnitte auf, anstatt stärkere Stil-Prompts zu verwenden.

Beschränkungen

• TTS-Modelle akzeptieren nur Texteingaben und generieren nur Audioausgaben.
• Die Generierung von mehreren Sprechern mit einer einzelnen Anfrage (speech_config.speakers) unterstützt bis zu 2 Sprecher mit vordefinierten Stimmen. Wenn Sie benutzerdefinierte (voice_...) oder replizierte (voice_... / voicekey_...) Stimmen in einem Dialog mit mehreren Figuren kombinieren möchten, müssen Sie die Äußerungen der einzelnen Sprecher separat synthetisieren. Da unäre Anfragen standardmäßig audio/wav mit einem 44-Byte-RIFF-Header zurückgeben, sollten Sie Roh-PCM ({"type": "audio", "mime_type": "audio/l16"}) anfordern oder den WAV-Header aus jeder Runde entfernen, bevor Sie die 24-kHz-PCM-Audioframes verketten.
• Speicherlimits und TTL für benutzerdefinierte Stimmen:
  • Zustandsorientierte Stimmen (store=True, Prompt- oder replizierte Stimmen): Maximal 200 Stimmen pro Projekt mit einer Gültigkeitsdauer von 1 Jahr.
  • Zustandslose Sprachschlüssel (store=False, voicekey_...): Gültigkeitsdauer (TTL) von 7 Tagen.
• Informationen zur Sprachabdeckung finden Sie im Abschnitt Unterstützte Sprachen.

Nächste Schritte

• Mit Voice design können Sie benutzerdefinierte Gesangspersonas aus natürlicher Sprache erstellen.
• Stimme eines vorhandenen Sprechers in Stimmenklonen replizieren.
• Vergleichen Sie die Modellspezifikationen auf den Modellseiten Gemini 3.8 Flash TTS und Gemini 3.8 Flash-Lite TTS.
• Mit der Live API können Sie interaktive bidirektionale Audiofunktionen nutzen.