Google Text-to-Speech: Free Use, API and Code (2026)

Google Text-to-Speech is really three products with one name: a free speech engine built into Android and Chrome, a paid Cloud API for developers, and a newer set of Gemini voices you can steer with plain-language instructions. Which one you need depends on whether you want to listen to text yourself or produce audio for an app, video or product. This guide covers all three, explains the voice tiers and costs, shows how to call the API, and walks through a worked example using a pay-per-request alternative when you want several voice models behind one key.

What is Google Text-to-Speech?

Text-to-speech (TTS) is software that converts written text into spoken audio. Modern systems use neural networks, models trained on many hours of recorded speech, to predict how a sentence should sound, including rhythm, stress and intonation. That’s why current voices sound far less robotic than the flat, choppy synthesis of ten years ago.

When people search for Google Text-to-Speech, they usually mean one of these:

• The Android speech engine. On Android it appears as the “Speech Recognition & Synthesis” app. It comes preinstalled on most devices and reads text aloud for accessibility tools, Google Play Books, navigation and any app that asks the system to speak.
• Google Cloud Text-to-Speech. A paid developer API. You send text or SSML (Speech Synthesis Markup Language, an XML format for controlling pauses, pronunciation and emphasis) and get back an audio file. It offers hundreds of voices across dozens of languages.
• Gemini TTS. Speech generation from Google’s Gemini models, available in Google AI Studio and through the API. Instead of tuning SSML tags, you describe the delivery you want (“warm and slow, like a bedtime story”).

The first is free and made for listening. The other two are for building things and are billed by usage.

How to use Google Text-to-Speech for free

If you only want to hear text read aloud, you don’t need an account, an API key or a credit card. The free side of Google Text-to-Speech is already on your phone and in your browser.

On Android

1. Open Settings, then Accessibility, then Text-to-speech output. The exact path varies by manufacturer. On some phones it sits under System or Languages.
2. Choose Speech Recognition & Synthesis by Google as the preferred engine.
3. Tap the gear icon to install voice data for your languages and pick a voice. Downloaded voices also work offline.
4. Adjust speech rate and pitch, then tap Play to hear a sample.
5. To have any screen read aloud, turn on Select to Speak in Accessibility, tap its icon, then tap or drag over the text.

If the engine is missing or broken, update or reinstall the app from the Play Store. Download APK files only from trusted sources, because a speech engine can see everything it reads.

In Chrome and Google Translate

• Chrome: desktop Chrome’s Reading mode has a read-aloud button, and Chrome on Android offers “Listen to this page” on many articles.
• Google Translate: type or paste text and tap the speaker icon. It’s the quickest way to hear how a word sounds in another language.
• ChromeOS: Select to Speak works the same way it does on Android.

This covers most “text to speech voices free” searches. The limit is that these tools play audio on your device. They don’t give you a clean audio file you can legally drop into a YouTube video, an e-learning course or an app. For that, you need an API.

Google Text-to-Speech voices: which tier to pick

Google Cloud groups its voices into tiers. The tier sets both sound quality and price, so choose it on purpose.

Voice tier	What it is	Good for
Standard	Older, non-neural synthesis. Clear but noticeably synthetic.	System prompts, IVR menus, high-volume alerts
WaveNet	The first generation of neural voices, much more natural than Standard.	General narration on a budget
Neural2	Newer neural voices with smoother prosody (the rise and fall of speech).	Apps, assistants, product audio
Studio	Voices tuned for long-form narration.	Audiobooks, news reading, courses
Chirp 3: HD	Google’s latest high-definition voices built on large audio models.	Conversational agents, natural-sounding content
Gemini TTS	Speech from Gemini models, steered with natural-language style prompts, with multi-speaker support.	Expressive reads, dialogue, podcast-style audio

Three practical notes before you pick:

• Coverage differs by language. English has every tier. Smaller languages may only have Standard and WaveNet. Check the voice list for your exact locale (for example en-GB versus en-US) before you commit.
• SSML support differs by tier. Older tiers support tags like <break>, <say-as> and <prosody> well. Some of the newest voices support only part of SSML. If your pipeline depends on precise pauses or phonetic overrides, test those tags on the voice you plan to ship.
• Voice names are version-specific. A name like en-US-Neural2-C pins one exact voice. Store it in config, not scattered through code, so a voice change is a one-line edit.

How to call the Google Cloud Text-to-Speech API

The developer path to Google Text-to-Speech goes through Google Cloud. Setup looks like this:

1. Create or select a Google Cloud project and attach a billing account. A billing account is required even if you stay within the free allowance.
2. Enable the Cloud Text-to-Speech API for that project.
3. Create credentials. Use a service account for servers, or an API key restricted to this one API for quick tests.
4. Send a synthesis request with three parts: the input (text or SSML), the voice (language code and voice name), and the audio config (encoding such as MP3 or LINEAR16, plus optional speaking rate and pitch).
5. Decode the response. The audio comes back as a base64 string in audioContent, which you decode and write to a file.

A typical request body looks like this:

{
  "input": { "ssml": "<speak>Your order has shipped. <break time=\"400ms\"/> It should arrive Thursday.</speak>" },
  "voice": { "languageCode": "en-US", "name": "en-US-Neural2-C" },
  "audioConfig": { "audioEncoding": "MP3" }
}

For Gemini voices, the simplest place to start is the speech generation playground in Google AI Studio. You write the script, add a style instruction, hear the result, and then export the matching API call. That’s the route most “Google text to speech Studio” and “Google text to speech AI” tutorials follow.

Google’s API works well, but it has real friction: a cloud project, IAM roles (Google’s permission system), a billing account and quota pages, all for one audio feature. If your app also generates images, video or music, you’ll set up the same plumbing again with each vendor.

How much does Google Text-to-Speech cost?

The consumer features are free. The Cloud API is billed per character of input, and the rate per million characters depends on the voice tier: Standard is cheapest, and the premium neural, Studio and newest HD tiers cost more. Each tier has a monthly free allowance, and SSML tags count toward your character total in many cases, so tag-heavy scripts cost more than their spoken length suggests. Gemini TTS follows Gemini API pricing, which works differently.

Google changes these numbers, so take current figures from its pricing page on the day you budget, not from a blog post. Here are the cost drivers worth modelling:

• Characters, not words. Spaces and punctuation count. A 1,000-word script is usually somewhere around 5,000 to 6,000 characters.
• Regeneration. You’ll rarely ship the first take. Budget for two or three passes on anything a customer hears.
• Tier creep. Teams often prototype on a premium voice and then find the bill scales with every user. Decide early which content truly needs the top tier.

A Google Text-to-Speech alternative with one API key

If you came looking for Google Text-to-Speech because you need narration for a product, it’s worth knowing the alternatives. ElevenLabs voices are a common choice when expressiveness matters more than raw language count, and Unicorn API gives you those models alongside image, video, music and chat models under one key and one bill, priced in credits.

Here are the relevant audio models and their prices:

Model	Price	Best for
Elevenlabs Text to Speech Turbo V2.5	6 credits per 1,000 characters	High-volume narration, drafts, app prompts
Elevenlabs Text to Speech Multilingual V2	12 credits per 1,000 characters	Final narration, non-English content
Elevenlabs Text to Dialogue V3	14 credits per request	Multi-voice conversations in one file

Credits cost $0.01 each on monthly plans (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-up credits cost $0.015 each and never expire. See pricing for the plan details.

Worked example: narrating a 4,500-character script

The two TTS models bill per started block of 1,000 characters, so the charge is the per-block price multiplied by ceil(characters / 1000). A 4,500-character script counts as 5 blocks:

• Turbo V2.5: 5 × 6 = 30 credits, which is $0.30 on a plan or $0.45 with top-ups.
• Multilingual V2: 5 × 12 = 60 credits, which is $0.60 on a plan or $0.90 with top-ups.

A sensible workflow is to draft and review timing on Turbo, then render the final take on Multilingual V2. Note the rounding: a 1,001-character request bills as two blocks, so don’t split a script into many tiny requests unless you need to.

Step 1: check the price before you run it

Get a key from the keys page, then send the same body you plan to submit to the price endpoint. It returns the exact credit cost without running the job:

curl https://api.unicornapi.net/v1/models/price \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"elevenlabs-text-to-speech-multilingual-v2","input":{"text":"Your order has shipped. It should arrive Thursday.","voice":"EkK5I93UQWFDigLMpZcX"}}'

Step 2: generate the audio and download it

Audio models run as jobs: you submit the job, poll until its status is succeeded, then read the file URL from outputs[0].url. This Python script does the whole loop:

import os
import time
import requests
from urllib.parse import urlparse

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

with open("script.txt", encoding="utf-8") as f:
    script = f.read()

resp = requests.post(f"{API}/v1/jobs", headers=HEADERS, json={
    "model": "elevenlabs-text-to-speech-multilingual-v2",
    "input": {"text": script, "voice": "EkK5I93UQWFDigLMpZcX"},
})
resp.raise_for_status()
job = resp.json()

deadline = time.time() + 300
while job["status"] not in ("succeeded", "failed"):
    if time.time() > deadline:
        raise SystemExit(f"Timed out waiting for job {job['id']}")
    time.sleep(2)
    resp = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS)
    resp.raise_for_status()
    job = resp.json()

if job["status"] != "succeeded":
    raise SystemExit(f"Job {job['id']} ended with status {job['status']}")

audio_url = job["outputs"][0]["url"]
ext = os.path.splitext(urlparse(audio_url).path)[1] or ".mp3"
with open(f"narration{ext}", "wb") as out:
    out.write(requests.get(audio_url).content)

print(f"Saved narration{ext}")

To switch to the cheaper model, change the model string to elevenlabs-text-to-speech-turbo-2-5. Both models also accept optional fields such as speed, stability, style, similarity_boost, language_code and timestamps. The API documentation lists accepted values.

Two voices in one file

Gemini TTS is popular for multi-speaker audio. The equivalent here is the dialogue model, which takes an array of lines, each with its own voice, for a flat 14 credits per request:

curl https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"elevenlabs-text-to-dialogue-v3","input":{"dialogue":[{"text":"Welcome back to the show.","voice":"EkK5I93UQWFDigLMpZcX"}]}}'

Add more objects to dialogue with different voice IDs to build a conversation, then poll the job exactly as in the Python example. If you’d rather hear voices before writing code, the audio playground runs the same models in the browser. If you work in Cursor or Claude Code, the agents setup lets your coding assistant call these models directly.

Narration is often only one layer of the final audio. The same key also runs music and effects models such as Ai Music API Sounds (3 credits per track), so a background bed for your voiceover doesn’t need another account. Browse everything in the model catalog, or read the broader AI text-to-speech API guide for a deeper model comparison.

Mistakes people make with text-to-speech

Most bad TTS output comes from the script, not the model. Whether you use Google Text-to-Speech or anything else, watch for these:

• Feeding raw text that’s written for reading. Abbreviations, URLs, version numbers and tables read badly aloud. Write “version two point five” or use SSML <say-as> where it’s supported. Spell out units and dates the way a person would say them.
• One giant request. Very long inputs make retakes expensive, because a single mispronounced word means regenerating everything. Split by paragraph or scene. With the ElevenLabs models, pass previous_text and next_text so the voice stays consistent across segments.
• Mismatched language and voice. An English voice reading French text sounds wrong even when every word is technically correct. Set languageCode on Google, or language_code on Unicorn API, to match the content.
• Using free consumer tools for commercial audio. Recording your phone’s screen reader for a client video is a licensing problem waiting to happen. Use an API whose terms cover the use.
• Ignoring rounding in per-block pricing. Billing per started 1,000 characters means many tiny requests can cost more than a few medium ones. Batch short lines when you can.
• Hard-coding a voice everywhere. Keep voice IDs and model names in one config file. Voices get updated and retired, and you’ll want to A/B test them.
• Skipping a listening pass. No model gets names, acronyms or brand terms right every time. A human should hear the final file before customers do.

Which option should you choose?

Pick based on what you’re actually doing:

• You want to listen to articles, books or messages yourself: use free Google Text-to-Speech on Android, Chrome or Translate. Nothing to pay and nothing to set up.
• You’re already on Google Cloud and need many languages: the Cloud Text-to-Speech API is a natural fit, especially for locales where it has voices and others don’t.
• You want expressive, prompt-steered delivery inside Google’s ecosystem: try Gemini TTS in AI Studio first.
• You’re building a product that mixes voice with images, video, music or chat: one key across all of them keeps billing and integration simple. Turbo V2.5 at 6 credits per 1,000 characters handles volume, and Multilingual V2 at 12 credits per 1,000 characters handles final narration.

Whichever route you take, test with your real script, in your real language, and listen to it end to end before you scale. The voice that sounds best on a demo sentence isn’t always the one that holds up across a ten-minute read.