Sprachausgabe

Mit der Gemini API kann Texteingabe mithilfe der Gemini-Text-zu-Sprache-Funktionen (TTS) in Audioinhalte mit einem oder mehreren Sprechern umgewandelt werden. Die Sprachsynthese ist steuerbar. Das bedeutet, dass Sie strukturierte Metadaten für die Äußerung (speech_metadata) und Inline-Sprachtags kombinieren können, um den Stil, Akzent, Rhythmus und Ton des Audios zu steuern.

Die TTS-Funktion unterscheidet sich von der Sprachgenerierung über die Live API, die für interaktive, unstrukturierte Audio- sowie multimodale Ein- und Ausgaben konzipiert ist. Während die Live API sich hervorragend für dynamische Konversationskontexte eignet, ist TTS über die Gemini API auf Szenarien zugeschnitten, in denen eine genaue Textrezitation mit detaillierter Steuerung von Stil und Klang erforderlich ist, z. B. bei der Generierung 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. 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 für einen einzelnen Sprecher

Wenn Sie mit Gemini 3.8 TTS-Modellen Text in Audio mit einem einzelnen Sprecher umwandeln möchten, übergeben Sie das wörtliche Transkript in parts[].text, fügen Sie die Formatierung auf Turn-Ebene in parts[].speech_metadata an und konfigurieren Sie die Stimme in speechConfig.voiceConfig. Sie können einen vordefinierten Sprachnamen, eine Extended Voice Library-ID, eine benutzerdefinierte Voice Design-ID (voice_...) oder eine Voice Replication-ID (voice_... oder optional statuslose voicekey_...) übergeben.

In diesem Beispiel wird die Audioausgabe des Modells in einer WAV-Datei gespeichert:

from google import genai

client = genai.Client()

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

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

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

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

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.wav', audioBuffer);
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode > out.wav

TTS mit mehreren Sprechern

Bei Dialogen mit mehreren Sprechern konfigurieren Sie zwei Sprecher in multiSpeakerVoiceConfig.speakerVoiceConfigs mit prebuiltVoiceConfig und übergeben jeden Dialogbeitrag als separates part mit speech_metadata, wobei sowohl speaker als auch optional style auf Beitragsebene angegeben werden:

from google import genai

client = genai.Client()

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

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

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

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

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [
            {
               text: "How's it going today Jane?",
               speechMetadata: {
                  speaker: 'Joe',
                  style: 'cheerful and friendly',
               },
            },
            {
               text: 'Not too bad, how about you? Ready to test these new voices?',
               speechMetadata: {
                  speaker: 'Jane',
                  style: 'calm and relaxed',
               },
            },
         ],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            multiSpeakerVoiceConfig: {
               speakerVoiceConfigs: [
                  {
                     speaker: 'Joe',
                     voiceConfig: {
                        prebuiltVoiceConfig: { voiceName: 'Puck' },
                     },
                  },
                  {
                     speaker: 'Jane',
                     voiceConfig: {
                        prebuiltVoiceConfig: { voiceName: 'Kore' },
                     },
                  },
               ],
            },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.wav', audioBuffer);
}

await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        {
          "text": "How'\''s it going today Jane?",
          "speech_metadata": {
            "speaker": "Joe",
            "style": "cheerful and friendly"
          }
        },
        {
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "speech_metadata": {
            "speaker": "Jane",
            "style": "calm and relaxed"
          }
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {
              "speaker": "Joe",
              "voiceConfig": {
                "prebuiltVoiceConfig": { "voiceName": "Puck" }
              }
            },
            {
              "speaker": "Jane",
              "voiceConfig": {
                "prebuiltVoiceConfig": { "voiceName": "Kore" }
              }
            }
          ]
        }
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
      base64 --decode > out.wav

Sprachstil mit Metadaten und Tags steuern

Bei Gemini 3.8 TTS wird das Feld text ausschließlich als wörtliches Transkript behandelt. 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 an, die für einen gesamten Turn gelten, z. B. "style": "whispered urgently", "style": "out of breath" oder "style": "warm and enthusiastic".speech_metadata.style
• Zeitpunktbezogene Ereignisse (Inline-Tags): Platzieren Sie kurze nicht sprachliche Vokalbursts oder Pausen direkt im Transkript mithilfe von spitzen 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 zum Erstellen von Prompts.

Stimmoptionen

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

1. Vorgefertigte Studio-Stimmen:30 ausgewählte Stimmen, die in der folgenden Tabelle aufgeführt sind.
2. Erweiterte Stimmenbibliothek:Hunderte zusätzlicher Stimmen in verschiedenen Sprachen, Akzenten und Charakterarchetypen, die über client.voices.list() (GET /v1beta/voices) verfügbar sind.
3. Voice Design:Generieren Sie eine benutzerdefinierte stimmliche Persona aus einer natürlichsprachlichen Beschreibung in Google AI Studio oder mit POST /v1beta/voices (type="prompted", die eine dauerhafte voice_...-ID und eine sample_audio-WAV-Vorschau in CreateVoice und GetVoice zurückgibt).
4. Stimmreplikation:Erstellen Sie eine Replik der Stimme eines Sprechers 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).

Benutzerdefinierte Sprachlimits und TTL

* Verlängerung der TTL:Der Aufbewahrungszeitraum von einem Jahr 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 Voice Library und Filterung

Neben den 30 Studio-Stimmen in der Tabelle oben bietet die erweiterte Stimmenbibliothek Hunderte von zusätzlichen 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 einem beliebigen Wert in diesem Filter entsprechen (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 haben dasselbe API-Schema und Prompting-Format. Sie können also mit einer einzigen Parameteränderung zwischen ihnen wechseln:

• Verwenden Sie Gemini 3.8 Flash TTS (gemini-3.8-flash-tts), 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 schnelles, kostengünstiges Arbeitstier anstelle von gemini-3.1-flash-tts-preview verwenden. Sie ist für die Massenproduktion in großem Umfang, Konversations-Voice-Agent-Kaskaden, Vorlesefunktionen, zuverlässige Sprachreplikation und alltägliche Einzelsprecher-Sprache in wichtigen Sprachen optimiert.

Migrationsanleitung

Wenn Sie von früheren Preview-Modellen (gemini-3.1-flash-tts-preview oder gemini-2.5-pro-preview-tts) auf Gemini 3.8 TTS (gemini-3.8-flash-tts oder gemini-3.8-flash-lite-tts) upgraden, sollten Sie sich diese fünf wichtigen Änderungen ansehen:

1. Stil vom Transkript trennen:Verschieben Sie Anweisungen zu Schauspiel, Tonfall, Prosodie und Tempo (z. B. "whispering", "out of breath" oder "speaking slowly") aus dem Nur-Text-Format in speech_metadata.style. Behalte text strikt als das wörtliche Transkript plus Inline-Tags für die Sprecher bei.
2. 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.
3. Strukturierte Dialogrunden verwenden:Bei Dialogen mit mehreren Sprechern übergeben Sie ein part pro Sprecherrunde mit speech_metadata.speaker, anstatt Speaker: ...-Präfixe in einen einzelnen Textblock einzubetten.
4. Winkelklammern für Inline-Vokal-Tags verwenden:Verwenden Sie Winkelklammern (<laugh>, <sigh>, <cough>, <breath>, <short pause>) für menschliche Vokalisationen und Pausen zu einem bestimmten Zeitpunkt. Vermeide Tags für nicht sprachliche Soundeffekte wie Applaus oder dumpfe Geräusche.
5. Standard-WAV-Ausgabe (AUDIO_WAV) bei unären Anfragen berücksichtigen:Im Gegensatz zu gemini-3.1-flash-tts-preview (bei dem standardmäßig headerloses rohes PCM AUDIO_L16 zurückgegeben wurde) geben Gemini 3.8-TTS-Modelle bei unären Anfragen vollständiges WAV-Audio (AUDIO_WAV) mit einem RIFF-Header (24 kHz, Mono, 16-Bit-PCM) zurück:
   • Wenn Ihr Code zuvor unformatierte PCM-Bytes in einen WAV-Header eingeschlossen hat (z. B. mit dem wave-Modul von Python oder dem wav-Paket von Node), entfernen Sie den manuellen Header-Wrapper und schreiben Sie die decodierten Audio-Bytes direkt in eine .wav-Datei.
   • Wenn für Ihre vorhandene Pipeline headerloses unkomprimiertes PCM-, Mu-Law- oder A-Law-Audio erforderlich ist, legen Sie response_format.audio.mime_type explizit auf "AUDIO_L16", "AUDIO_MULAW" oder "AUDIO_ALAW" fest (z. B. {"response_format": {"audio": {"mime_type": "AUDIO_L16"}}} in generateContent oder {"response_format": {"type": "audio", "mime_type": "audio/l16"}} in der Interactions API). Weitere Informationen findest du unter Audioausgabeformate.

Leitfaden für Prompts

Gemini 3.8 TTS-Modelle behandeln Eingabetext ausschließlich als wortwörtliches Transkript. Im Gegensatz zu früheren Vorschauversionen, in denen Regieanweisungen in Nur-Text eingebettet waren, trennt Gemini 3.8 TTS anhaltende Anweisungen auf Turn-Ebene (speech_metadata) von Inline-Vocal-Tags für bestimmte Zeitpunkte.

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 Bereitstellung, z. B. Emotion, Prosodie, allgemeines Tempo oder Bereitstellungsstil (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 in Voice Design entwerfen und style nur für optionale Anpassungen auf Zug-Ebene 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 Detaillierungsebenen 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 pausieren soll: text Hold on, let me think... <short pause> Alright, I've got it.
• Geschwindigkeit auf Zugebene:Legen Sie in speech_metadata "style": "speaking rapidly" oder "style": "speaking slowly" fest, um die Sprechgeschwindigkeit für den gesamten Zug zu steuern.

Prosodie und Tonhöhe

Verwenden Sie speech_metadata.style, um Prosodie, Tonhöhe und Betonung in einem Zug zu steuern (z. B. "style": "high pitch, cheerful and excited inflection" oder "style": "monotone and flat"). Wenn sich die Emotion oder Prosodie während des Dialogs ändert, teilen Sie das Skript in separate Züge mit unterschiedlichen style-Werten für jeden Zug auf.

Schwerpunkt

Sie können bestimmte Wörter im Transkript großschreiben und Satzzeichen und Inline-Vocal-Tags verwenden, um wichtige Wörter natürlich zu betonen:

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

Vocal-Bursts und Geräusche

Nicht sprachliche menschliche Äußerungen werden inline mit spitzen Klammern (<...>) an der genauen Stelle platziert, an der das Geräusch auftreten soll. Empfohlene Gesangstags:

Backchannels und sich überschneidende Sprache

Bei Dialogen mit mehreren Sprechern können Sie Reaktionen des Zuhörers in Pipe-Zeichen (|reaction|) innerhalb des Sprecherbeitrags einschließen, um natürliche Backchannels oder überlappende Sprache zu erzeugen, ohne dass für jede Reaktion ein separater Beitrag erforderlich ist.

• Kurze Backchannel-Reaktionen:Füge kurze Reaktionen des Zuhörers (|oh hmm|, |oh really?|, |absolutely|) in den Beitrag 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 Sprecherüberschneidung:"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 Stabilität der stimmlichen Identität über mehrere Turns hinweg zu gewährleisten:

• Design-Personas im Voice-Design vorab 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 Voice-Drift. Nutzen Sie diese kreative Intuition von Anfang an beim Stimmdesign, um eine dauerhafte benutzerdefinierte voice_...-Identität zu generieren, und verwenden Sie diese Stimm-ID dann in Ihren TTS-Aufrufen.
• Für Stabilität auf die Sprachreferenz verlassen (Meta-Anweisungen weglassen): Gemini 3.8-TTS-Modelle sind so trainiert, dass sie sich zuerst an der Audio-Referenz orientieren. Fügen Sie keine Anweisungen hinzu, die das Modell anweisen, die Stimme konstant 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 Sprachreferenz 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 Stimmenbibliothek aus oder erstellen Sie eine mit Stimmendesign.

Empfohlener Workflow

1. Charakter einmal erstellen:Erstellen Sie Ihren Charakter unter Stimmendesign 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 schreiben Sie das text als echtes gesprochenes Transkript – einschließlich natürlicher Unflüssigkeiten und Zögern (z. B. "Oh uh yeah I think... hm, so that's interesting").
3. Einfache TTS zuerst testen:Synthetisieren Sie Ihr Transkript zuerst mit einem leeren style-Feld. Für die meisten Anfragen ist überhaupt keine style-Anweisung erforderlich.
4. Fügen Sie kurze style-Prompts nur für Anpassungen hinzu:Fügen Sie einen kurzen style-String (z. B. "casual, friendly" oder "muttering, then reassuring") nur für Turns hinzu, die eine bestimmte Anpassung erfordern. Verwenden Sie diesen kurzen String für alle Turns, wenn Sie eine einheitliche Baseline wünschen.

Mehrfachdialog und Sprachagenten

Wenn Sie Echtzeit-Sprachagenten oder Mehrfachdialog-Anwendungen entwickeln:

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

Streaming-Sprachgenerierung

Sie können generierte Audioinhalte streamen, während sie vom Modell synthetisiert werden. Im Gegensatz zu unären Anfragen (bei denen eine vollständige WAV-Datei mit einem RIFF-Header zurückgegeben wird), werden bei Streaminganfragen standardmäßig Header ohne rohe 16-Bit-Chunks mit vorzeichenbehaftetem Little-Endian-Linearen PCM (AUDIO_L16 / audio/L16;codec=pcm;rate=24000, 24 kHz, Mono) zurückgegeben. So können Audio-Chunks ohne Container-Header kontinuierlich wiedergegeben oder verkettet werden:

from google import genai

client = genai.Client()

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

for chunk in response_stream:
    try:
        data = chunk.candidates[0].content.parts[0].inline_data.data
        # data contains raw PCM bytes (24kHz, 1-channel, 16-bit)
    except (IndexError, AttributeError):
        pass

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

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

   const responseStream = await ai.models.generateContentStream({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   for await (const chunk of responseStream) {
      const data = chunk.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
      if (data) {
         const audioBuffer = Buffer.from(data, 'base64');
         // Process the audio buffer
      }
   }
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:streamGenerateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }'

Audioausgabeformate

Gemini 3.8-TTS-Modelle verwenden je nach Art der Anfrage (unär oder Streaming) unterschiedliche Standardaudioformate:

• Unäre Anfragen (models.generate_content): Geben Sie vollständiges WAV-Audio (AUDIO_WAV) mit einem RIFF-Header zurück (24 kHz, Mono, 16-Bit-PCM mit Vorzeichen und Little-Endian-Byte-Reihenfolge). Sie können die decodierten Audio-Bytes direkt in eine .wav-Datei schreiben, ohne manuell einen WAV-Container hinzufügen zu müssen.
• Streaminganfragen (models.generate_content_stream / streamGenerateContent): Standardmäßig werden headerlose Roh-Chunks im linearen PCM-Format (AUDIO_L16) (24 kHz, Mono, 16-Bit-PCM mit Vorzeichen und Little-Endian-Format) zurückgegeben, sodass Chunks kontinuierlich gestreamt oder verkettet werden können, ohne dass jeder Chunk Containerheader enthält.

Sie können die Audioausgabecodierung und ‑abtastrate mit generationConfig.responseFormat.audio überschreiben:

Optional können Sie auch sampleRate angeben, z. B. 24000, 16000 oder 8000 Hz (Standardwert: 24000 Hz).

Im folgenden Beispiel wird headerloses rohes 16‑Bit-PCM (AUDIO_L16) mit 24 kHz angefordert:

from google import genai

client = genai.Client()

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

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

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

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

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         responseFormat: {
            audio: {
               mimeType: 'AUDIO_L16',
               sampleRate: 24000,
            },
         },
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.pcm', audioBuffer);
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "responseFormat": {
            "audio": {
              "mimeType": "AUDIO_L16",
              "sampleRate": 24000
            }
          },
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode > out.pcm

Beschränkungen

• TTS-Modelle akzeptieren nur Texteingaben und generieren nur Audioausgaben.
• Die Generierung mit mehreren Sprechern in einer einzelnen Anfrage (multiSpeakerVoiceConfig) unterstützt bis zu zwei 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ßerung jedes Sprechers einzeln synthetisieren. Da bei unären Anfragen standardmäßig audio/wav mit einem 44 Byte großen RIFF-Header zurückgegeben wird, sollten Sie rohes PCM (AUDIO_L16) anfordern oder den WAV-Header aus jedem Turn entfernen, bevor Sie die 24 kHz-PCM-Audio-Frames verketten.
• Speicherlimits und TTL für benutzerdefinierte Stimmen:
  • Statusbehaftete Stimmen (store=True, per Prompt erstellt oder repliziert): Maximal 200 Stimmen pro Projekt mit einer Gültigkeitsdauer von 1 Jahr (Time-to-Live).
  • Zustandslose Sprachschlüssel (store=False, voicekey_...): Gültigkeitsdauer (TTL) von 7 Tagen.
• Im Abschnitt Unterstützte Sprachen finden Sie Informationen zur Sprachabdeckung.

Nächste Schritte

• Mit Voice Design können Sie benutzerdefinierte Gesangspersonas aus natürlicher Sprache erstellen.
• Die Stimme eines vorhandenen Sprechers in der Stimmreplikation 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.