Gemini 3.8 Flash TTS: turning director-level voice direction into API parameters
gemini-3-8-flash-tts
Google's speech generation model (gemini-3.8-flash-tts), positioned for studio-grade voice fidelity, expressive acting and long-form stability, the most overlooked being the last: audiobook failure is not an ugly sentence but timbre drift by hour three. The design separates scopes: text is strictly a script while performance direction travels on another channel and is never read aloud, fixing "(sighs)" that used to be spoken; round style goes into speech_metadata.style, word-level emotion into pipe tags. Four voice sources: prebuilt, an extended library, voice design IDs (describe it, then reuse) and replication IDs; design and replication arrived only in 3.8. Specs: 130 languages with automatic language detection, WAV by default at 24 kHz, at most 2 speakers per request and only with prebuilt voices. Billing is per audio token at 25 tokens per second, $0.50 input and $9.00 output per million through 2026-12-31 then $1.00/$18.00. Limits: 24 kHz is not mastering grade; replication compliance rests with the user. No speech board among the 12 synced here, so listed alongside ElevenLabs v3 without ranking. Graded C (vendor-stated): no intelligibility or independent blind listening test.
- CONFIDENCE
- Vendor Claim
- Official model card or keynote only, no independent re-test
- KEY METRIC
- Voice design + cloning + multi-speaker
- Vendor Claim · 2026-09
- MATURITY
- Product
- research → demo → product → production
Editor's takeGraded C (vendor claim). The confidence ceiling in this domain is inherently low: none of the twelve third-party leaderboards covers speech, so there is no independent reading to cite and all that can be checked is the official feature matrix and pricing. Grade C is not disparagement; it is an admission that claims like "supports 130 languages" and "studio-grade fidelity" are not scorable.
Its real engineering contribution is separating the scopes of verbatim transcript and performance direction completely. It looks like mere API design, but it removes a long-standing class of unpredictable TTS behaviour: stage direction written into the text was sometimes performed and sometimes spoken aloud. The 3.8 split is "`text` is strictly the transcript, `speech_metadata.style` carries sustained turn-level delivery, pipe tags carry inline per-word emotion", plus multi-speaker interruption and overlap - which together turn "a director giving notes to an actor" into structured parameters. For teams running audiobook and podcast pipelines, that predictability is worth more than raw audio quality.
The pricing direction deserves separate mention: 3.8 Flash TTS audio output is $9.00 per million tokens while the previous 3.1 Preview was $20.00 - price cut to under half while capability increased, which at 25 tokens per second works out to roughly $13.5 per minute today and about $27 from 2027-01-01. Flagship iterations usually go the other way, so this materially changes the cost structure of long-form audio at scale; and the row saying free-tier output is used to improve products while paid-tier output is not is a hard constraint for enterprises. Read the boundaries clearly: multi-speaker is capped at two per request with prebuilt voices only, so ensemble work is out; and Google explicitly recommends splitting long replies into shorter turns rather than pushing harder style prompts, meaning long-form expressiveness is bought with structure, not with prompt. Compliance for voice cloning stays with the operator - capability is not authorisation.
The problem it solves: turning director-level voice direction into API parameters
Conventional TTS expressiveness stops at picking a voice and adjusting speed: you choose a preset and move a few sliders. Podcasts, audiobooks and dubbing need something else - directable performance. This line should be held back, that one should break into a laugh, two speakers should talk over each other. Gemini 3.8 Flash TTS (`gemini-3.8-flash-tts`) builds that into the model: the text field is treated strictly as a verbatim transcript, and performance direction travels through a separate channel so it is never read aloud.
That design is the crux of the model and deserves its own paragraph. The usual older approach was writing "(sighs)" into the text and hoping the model understood, which produced unpredictable behaviour - sometimes performed, sometimes spoken. 3.8 TTS separates the scopes explicitly:
- Sustained turn-level delivery goes in `speech_metadata.style` (emotion, pacing, volume, prosody), for example `"style": "cheerful and friendly"`.
- Inline per-word emotion tags are written straight into the transcript between pipes: `"Then let's ship it |absolutely| and watch the dashboards."` - affecting only that word.
- Overlap and interruption is simulated with multiple pipe segments for simultaneous speech, and the docs state this works best on `gemini-3.8-flash-tts`.
Google positions the model as "studio-grade voice fidelity, expressive acting, and long-form stability". The easiest of those three to overlook is long-form stability: the real failure mode of an audiobook is not an ugly sentence but a voice drifting and an emotional register collapsing by hour three.
Capability matrix and how the family is tiered
| Model | Single / multi-speaker | Voice design | Voice cloning | Positioning |
|---|---|---|---|---|
| gemini-3.8-flash-tts | Yes (up to 2 speakers, prebuilt voices) | Yes | Yes | The asset catalogued here: the expressiveness ceiling |
| gemini-3.8-flash-lite-tts | Yes | Yes | Yes | Same schema, higher throughput and lower cost; 101 languages |
| gemini-3.1-flash-tts-preview | Yes | No | No | Previous generation: low latency and price-performance, but no design or cloning |
The tiering matters: voice design and voice replication are the two capabilities the 3.8 generation added; 3.1 Preview has neither. So "Gemini can do TTS" and "Gemini can create a new voice from a description or replicate a real person's voice" are different claims, and the second is what dubbing and audiobook pipelines actually need.
Four voice sources are available, all configured in `generation_config.speech_config`: prebuilt voices (such as `Kore` or `Puck`), the Extended Voice Library (searchable via `GET /v1beta/voices`, filterable by `type=prebuilt` and keyword), a Voice design ID (`voice_...`, describe a voice in natural language then reuse it), and a Voice replication ID (`voice_...`, or the stateless `voicekey_...`). A single multi-speaker request supports at most 2 speakers using prebuilt voices only; mixing custom-designed or replicated voices into a multi-speaker dialogue requires separate handling per the official docs.
Language coverage and output specs
- 130 languages, with input language detected automatically and no explicit declaration needed. Flash-Lite TTS covers 101. Coverage reaches Acehnese (Arabic script), Akan, Awadhi and Balinese - this is long-tail coverage, not a mainstream language pack.
- Default output is WAV (`audio/wav`, RIFF header, 16-bit signed little-endian PCM, mono, 24 kHz default). Streaming defaults to headerless raw Linear PCM (`audio/l16`, 24 kHz mono 16-bit) so chunks concatenate continuously without a container header each time. Encoding and sample rate are configurable in `response_format`.
- Billing is per audio token, at 25 tokens per second of audio. That is the key to converting price into cost per second, as below.
- Text in, audio out only: TTS models accept no audio or image input. Audio understanding goes through the Live API or the audio-understanding line, not this model.
Pricing: Google published an explicit price-increase date
| Item | Free tier | Paid tier (per 1M tokens) |
|---|---|---|
| Input (text) | Free | $0.50 through 2026-12-31, then $1.00 from 2027-01-01 |
| Output (audio) | Free | $9.00 through 2026-12-31, then $18.00 from 2027-01-01 |
| Used to improve products | Yes | No |
Substituting 25 tokens per second, current audio output costs roughly $13.5 per minute ($9.00/M divided by 25, times 60), doubling to about $27 per minute from 2027-01-01. For comparison, the previous 3.1 Flash TTS Preview was $1.00 input / $20.00 output, so 3.8 cut audio output price to under half while adding capability. That is an unusual direction for a flagship iteration and one of the hard reasons we place this asset at the top of the audio ladder.
The "free tier output is used to improve products, paid tier is not" row is a substantive difference for enterprise users, not a footnote.
Boundaries
- Multi-speaker is hard-capped at 2 and prebuilt voices only: ensemble scenes or audiobooks with three-plus characters cannot be done in one request; you stitch it yourself and hold voice consistency yourself.
- The verbatim-transcript semantics are strict: anything written into `text` gets spoken. Stage direction must go into `style` or a pipe tag; putting it in the wrong place is an incident. This is the single biggest trap in the API.
- The docs explicitly advise against pushing long responses with stronger style prompts: the recommended approach is splitting long replies into shorter turns and leaving per-turn style empty or one fixed short string. In other words expressiveness over long form comes from structure, not prompt intensity, which contradicts the common intuition that more description means better output.
- 24 kHz default sample rate: fine for podcast and audiobook, not mastering grade. Higher rates need an explicit `sample_rate`, and the model's ceiling is not unlimited.
- Compliance for voice cloning sits with the operator: replicating a real person's voice touches personality and voice rights and varies by jurisdiction. Model capability is not authorisation. We do not evaluate that layer, but it belongs in the boundaries.
- No public third-party TTS board readings: none of the twelve third-party leaderboards this site syncs covers speech, so this asset cannot be given a rank; its capability surface can only be read from the official feature matrix and pricing.
Our verification status
Facts come from two Google official documents read in full: the Gemini API speech generation guide (model matrix, the scope split between verbatim transcript and `speech_metadata`, inline pipe emotion tags, overlapping speech, the four voice sources, the 2-speaker limit, the 130/101 language tables, WAV and L16 output specs, long-form best practice) and the Gemini API pricing page (`$0.50/$9.00` current and `$1.00/$18.00` from 2027-01-01, 25 tokens per second, the free-vs-paid data-use difference, and the 3.1 Preview `$1/$20` comparison).
Confidence is graded C (vendor claim), and the reason needs to be precise: "supports voice design and cloning", "130 languages" and "studio-grade fidelity" are self-descriptions in official documentation, not scorable benchmark readings. We have not run intelligibility tests across the 130 languages, not run blind listening comparisons against ElevenLabs v3 or OpenAI TTS on identical text, and not measured timbre drift over long form (say a continuous three-hour audiobook). Reaching grade A would require intelligibility and speaker-similarity measurement on a fixed multilingual test set, organised blind preference comparisons, and quantitative long-form stability measurement (timbre drift, prosody collapse).
We place it at the top of the audio ladder not because it is provably best but because it is one of the few models that puts voice design, voice cloning, multi-speaker performance and inline emotion control into one API, with pricing and specs fully published and checkable. The ElevenLabs v3 asset we catalogue alongside it has a different centre of gravity (70+ languages, Text to Dialogue, a ~280ms realtime tier, and a complete audio stack including Scribe and Music). The two sit side by side, unranked - with no third-party board in this domain, any ranking would be ours alone.