"Free" means three different things across the major text-to-speech providers, and picking the wrong shape wastes either money or a weekend. Three names dominate — Google Cloud TTS, ElevenLabs, and OpenAI — and this guide compares them on the metrics that actually decide it: real free-tier ceiling, paid rate, voice quality, languages, latency, and the licensing fine print that quietly blocks commercial use.

The 30-Second Answer

The three shapes of "free" you're choosing between: a recurring free tier that resets monthly forever (Google, Azure, ElevenLabs); a time-limited one that lasts only your first 12 months (Amazon Polly); and pay-as-you-go with no free tier but a price so low it's near-free at small volume (OpenAI). A real workload makes the stakes concrete — 50 articles/month at 8,000 chars each is 400K chars/month, which is $0 on Google Standard, $6/month on OpenAI tts-1, and needs the $22/month Creator plan on ElevenLabs.

Google Cloud TTS: The Only True Recurring Free Tier

Google Cloud Text-to-Speech renews its free tier every month and never expires — the closest thing to a permanently free TTS API at scale.

Worth catching, because most write-ups still get it wrong: WaveNet now shares Standard's allowance and price — 4 million characters free, then $4/1M, on the same Google billing sku. There is no longer a reason to ship Standard voices to save money. Neural2 is the tier that costs $16/1M with a 1M free allowance. (Verified 2026-09-01.)

The 4-million-character Standard tier is the headline — roughly 66 hours of audio a month, free indefinitely, enough for a daily news-reader bot or a blog-to-audio pipeline. Google ships 380+ voices across 50+ languages with full SSML control, and the newer Chirp 3: HD voices push quality close to ElevenLabs. The catch: it requires a GCP account with a credit card on file (you aren't charged inside the free tier), auth is service-account/ADC rather than a single token, and there's no self-serve voice cloning.

Python with the official client library:

from google.cloud import texttospeech

client = texttospeech.TextToSpeechClient()

response = client.synthesize_speech(
    input=texttospeech.SynthesisInput(text="Hello from a free text to speech API."),
    voice=texttospeech.VoiceSelectionParams(
        language_code="en-US",
        name="en-US-Standard-C",  # swap to en-US-Neural2-F for premium
    ),
    audio_config=texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3,
        speaking_rate=1.0,
    ),
)

with open("out.mp3", "wb") as f:
    f.write(response.audio_content)

ElevenLabs: Best Voice Quality and Free Cloning

ElevenLabs is what you reach for when the sound matters more than the price — best-in-class prosody, and the only major option where instant voice cloning and a large public voice library are self-serve.

Every new account gets 10,000 credits/month, no credit card — roughly 10 minutes of audio on Multilingual v2, or ~20 minutes on the half-credit Flash/Turbo v2.5 models. Two pieces of fine print matter: attribution is required on the free tier, and commercial use requires a paid plan (from $6/month Starter, 30K credits, which also removes attribution and unlocks cloning). Treat the free quota as a high-quality evaluation/hobby tier, not a free production backend.

Python with the official SDK:

from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

audio = client.text_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",   # a stock library voice
    model_id="eleven_flash_v2_5",       # low-latency for agents
    text="Hello from the best-sounding free text to speech API.",
    output_format="mp3_44100_128",
)

with open("out.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)

OpenAI TTS: No Free Tier, but Cheap and Frictionless

OpenAI's audio API has no free tier — but at $15/1M chars, generating 10,000 characters costs $0.15, and if you already call OpenAI for chat or Whisper, adding speech is one more method on a client you've already configured. There's no quota to blow through; you just pay for use. tts-1 is $15/1M chars (lowest latency), tts-1-hd is $30/1M, and gpt-4o-mini-tts is billed in audio tokens and adds steerability — pass an instruction like "speak in a calm, sympathetic tone" and the model adapts delivery.

from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="nova",
    input="Hello from a pay-as-you-go text to speech API.",
    instructions="Speak in a warm, upbeat tone.",
) as response:
    response.stream_to_file("out.mp3")

Eleven built-in voices cover most needs, but there's no voice cloning, and you still need a credit card and standing billing — without a recurring free quota to justify it. If "$0/month" is a hard requirement, pick Google.

We tested Groq's free TTS — and hit two traps

Groq quietly serves a text-to-speech model (canopylabs/orpheus-v1-english) on the same free key as its chat and Whisper models. We measured it on 2026-08-31:

4.4× realtime means a minute of narration takes about fourteen seconds. Slower than transcription in the other direction — Groq's Whisper runs far faster than realtime — but quick enough to generate audio ahead of time.

Trap 0: four minutes a day

Speed turns out to be the least interesting thing about this tier. Push a few hundred words through it and the request fails with a limit that appears in no documentation we could find — only in the error body:

Rate limit reached for model `canopylabs/orpheus-v1-english`
... on tokens per day (TPD): Limit 3600, Used 2355, Requested 1494

3,600 tokens per day. The response headers advertise two other limits, and neither is the one that stops you — when this fired we had 92 of 100 daily requests unused and a full 1,200 tokens of the per-minute allowance available. Only the daily budget binds.

Measured in the same session, so you can convert it into work: 288 words of input consumed 1,494 tokens (~5.2 tokens per word), and 40 words produced 13.68 seconds of speech (~0.34 s per word). So the daily budget buys roughly 690 words, or under four minutes of audio:

That is a demo allowance, not a production one. One short podcast intro and you are done until tomorrow. Read the 4.4× realtime figure below in that light: the model is fast, and you get four minutes a day to enjoy it. If you need volume on a free tier, Google Cloud TTS's 4 million characters a month is three orders of magnitude more speech.

Trap 1: it refuses to work until someone accepts the terms

Your first call fails, even with a valid key that works for every other Groq model:

{"error":{"message":"The model `canopylabs/orpheus-v1-english` requires
 terms acceptance. Please have the org admin accept the terms at
 https://console.groq.com/playground?model=canopylabs%2Forpheus-v1-english"}}

Unlike Groq's chat models, the TTS model is gated behind a one-time click in the console. It's quick, but it can't be done from the API — so it will break an automated deployment that assumes one key unlocks everything.

Trap 2: the WAV header lies about the length

This one cost us more time. Read the returned WAV with a standard library and you get:

import wave
w = wave.open("speech.wav", "rb")
w.getnframes() / w.getframerate()
# 89478.49   <- 24.9 hours, from a 10-second clip

The header reports 2147483647 frames — the maximum value of a signed 32-bit integer, the standard placeholder for "unknown length" when audio is streamed. The audio itself is perfectly fine; only the declared length is nonsense.

Anything that trusts that field — a duration display, a player's seek bar, billing by audio-minute, a benchmark like ours — will produce garbage. Compute the real duration from the file size instead:

import os, wave

w = wave.open(path, "rb")
data_bytes = os.path.getsize(path) - 44          # minus the WAV header
frames = data_bytes // (w.getnchannels() * w.getsampwidth())
duration = frames / w.getframerate()             # 10.80 s — correct

We only caught it because a 2.4-second request appeared to have produced a day of audio. Worth knowing before you build a playback UI on top of it.

Honorable Mentions

• Microsoft Azure AI Speech — recurring free tier of 500,000 chars/month for standard neural voices, 400+ voices across 140+ languages. The natural pick if you're already on Azure.
• Amazon Polly — time-limited to your first 12 months (5M chars/month standard, 1M neural), then standard rates. Best inside the AWS ecosystem.
• Deepgram Aura — no permanent free tier, but the $200 signup credit covers both TTS and transcription (see our free Whisper API comparison).
• Self-host Piper / Kokoro-82M / Coqui — Piper runs on a Raspberry Pi, Kokoro-82M runs on CPU, Coqui clones voices locally. Free at the margin; you own the ops.

Side-by-Side Spec Sheet

Which One Should You Pick?

• Hours of audio per month, free, forever → Google Cloud TTS (4M-char recurring Standard tier).
• Voice quality is the whole point → ElevenLabs if non-commercial and low volume; $6/mo Starter the moment you monetize.
• Clone a voice from a short sample → ElevenLabs (instant cloning, paid) — no one else does this self-serve.
• Already call OpenAI, just want your app to talk → OpenAI TTS (~$0.15 per 10K chars).
• Fine pronunciation/pause/pitch control via markup → Google Cloud TTS (full SSML).
• Tone from an instruction ("sound sympathetic") → OpenAI gpt-4o-mini-tts.
• Already on Azure or AWS → Azure AI Speech (500K/mo recurring) or Amazon Polly (free first 12 months).

A Full Free Voice Loop

The most powerful use of free TTS is the final leg of a complete voice agent: speech in via a free Whisper API (Groq's no-card tier is cleanest); reasoning via a free LLM — Groq Llama 3.3 70B, Together AI, or Google Gemini; speech out via Google Cloud TTS or ElevenLabs Flash v2.5. Three free quotas, and only Groq needs no card — Google Cloud requires billing enabled even inside the free tier — a complete speech-to-speech agent that would cost real money on a single commercial vendor.

FAQ

Is there a truly free TTS API with no time limit?

Yes — Google Cloud TTS and Azure AI Speech both offer recurring monthly free tiers that renew indefinitely (4M and 500K characters respectively). Both require a credit card on file, but you aren't charged inside the free quota. Amazon Polly's free tier, by contrast, lasts only your first 12 months.

Which free TTS API has the best voice quality?

ElevenLabs is widely regarded as the most natural and expressive, especially for long-form narration. Google's newer Chirp 3: HD voices are very close and come with a far larger free quota. If quality is the only axis, ElevenLabs; if quality-per-free-character, Google.

Can I use a free TTS API commercially?

It depends. Google Cloud and OpenAI allow commercial use of generated audio (Google inside its free tier, OpenAI as paid usage). ElevenLabs' free tier is non-commercial only and requires attribution — you must upgrade to at least the $6/month Starter plan to monetize. Always re-read each provider's terms before shipping; licensing changes.

Which TTS API is best for a real-time voice agent?

Latency decides it. ElevenLabs Flash v2.5 targets ~75 ms model latency and is purpose-built for conversational agents. OpenAI tts-1 and Google's Standard voices are also fast enough for most interactive use. For the lowest end-to-end latency, stream the audio as it's generated rather than waiting for the full file.

Related Reads

• Free Whisper API Tested: 160x Realtime on Groq — the speech-to-text half of any voice pipeline.
• Groq Free API Tested: ~525 tok/s + What You Can Build — the free LLM for the reasoning step.
• Together AI Free Tier Is Gone: What It Costs Now — another free model source for the text your TTS reads.
• Google Gemini Free API Tested: 34s to First Token — pairs naturally with Google Cloud TTS.
• Free AI APIs in 2026: We Tested 10, Four Now Want a Card — the wider map of which free API does what.
• Open Source Voice AI Agent: LiveKit vs Pipecat — which free TTS tiers you can legally ship inside a real voice agent.
• Free Speech-to-Speech API: Gemini Live and 3 Others — when one audio-in, audio-out model replaces the whole STT–LLM–TTS chain.