Chapter 08: Cost Analysis — Free Tiers, Pricing & Local-vs-Cloud Break-Even

Key free-tier reading for your use case: for low-volume personal/text-reading, Google (4M WaveNet + 1M Neural2 chars/month, both free) and Azure's 500k Neural chars/month are the two perpetual free tiers that also support natural Czech. Note a pleasant surprise from the live pricing data: Google's WaveNet tier is only $4/1M and carries a 4M-char/month free allowance (same as Standard), while the newer Neural2 voices are the $16/1M tier with a 1M-char free allowance. So if WaveNet Czech quality is acceptable to you, you get 4M free natural-ish Czech characters/month — very generous. ElevenLabs' free tier sounds the best but is non-commercial, which disqualifies it the moment you ship it inside your software product for others.

Czech caveat on Amazon Polly: Polly's free Neural tier is generous, but Polly does not offer a Czech Neural voice — Czech (cs-CZ) is only available on the older, robotic Standard engine. So Polly's "natural" tier is effectively English-and-friends-only for your purposes. This is the kind of thing that silently kills a plan; verify the voice, not just the language code.

2. Per-unit pricing, normalized

Here is every major paid tier converted to both comparison units. Where a vendor bills in something other than characters (OpenAI bills audio output tokens ≈ per-minute; ElevenLabs bills credits ≈ characters), I converted using the standard factors and label the assumption.

* Google bills Chirp 3 HD per byte of input; UTF-8 Czech with diacritics uses multi-byte characters, so your effective Czech rate can be noticeably higher than the per-character headline. Budget +10–20% for Czech text on byte-billed tiers. ** OpenAI's audio models bill by output audio tokens; $0.015/min × 60 min ≈ $0.90/hr of audio, and the per-character figure ($12/1M) is derived from that per-minute rate via the ~750 chars/min factor. Treat OpenAI's ~$12/1M as approximate. *** ElevenLabs is a subscription, not pure usage. The effective $/1M is the subscription cost divided by included credits (1 credit ≈ 1 char on standard models). Overage and the non-commercial Free tier change the math; this column shows the blended rate at full plan utilization.

What this table says in plain English:

• The top-quality natural-Czech cloud APIs cluster at $16/1M chars ($0.72/hr): Google Neural2 and Azure Neural. Google WaveNet is cheaper still at $4/1M (~$0.18/hr) with mid-tier-but-improved Czech — the best price/quality ratio for natural-ish Czech on a metered cloud.
• OpenAI is the cheapest "premium-ish" cloud voice per minute (~$0.68–0.90/hr) but its Czech has a non-native accent — fine for casual reading, not for polished Czech narration.
• ElevenLabs is ~8–10× more expensive per character than Google Neural2 (~$7–8/hr vs ~$0.72/hr) but is widely judged the most natural, including in Czech. You pay a large premium for top quality.
• Deepgram and Polly-Neural are no-Czech-natural (Deepgram Aura-2 doubled its price to $0.030/1k = $30/1M in late 2025 and has no Czech voice; Polly Neural has no Czech) — irrelevant for a bilingual EN+CZ product despite otherwise reasonable pricing.

3. The local / self-host cost model

"Local is free" is half-true. The compute is free at the margin, but the fixed costs (hardware, your time) and variable costs (electricity, or serverless GPU $/hr) are real. Let's build the model honestly across the three deployment shapes.

3.1 CPU-only local (Piper, Kokoro)

This is the genuine $0-marginal-cost path. Piper (rhasspy/piper) runs faster than real time on a CPU — it even runs on a Raspberry Pi 4 — and Kokoro (82M params) is small enough for snappy CPU inference too.

• Hardware cost: $0 extra if you already have the machine/server running your app. The TTS rides on existing CPU.
• Electricity: a CPU TTS task pulls maybe an extra ~15–40 W while synthesizing. At ~$0.165/kWh (US avg) that's roughly $0.005–0.011 per CPU-hour of synthesis, and synthesis is faster than real-time, so producing an hour of audio costs a fraction of a cent. Effectively rounding-error money.
• Czech reality check: Piper has Czech voices but they are mid-tier in naturalness — clearly synthetic, intelligible, not premium. Kokoro's Czech support is limited/experimental. So CPU-local is the cheapest path but you trade away top-end Czech naturalness. (See the model-quality chapters for the exact grading.)

Verdict: if your texts are English-heavy and "good enough, totally free, totally private" beats "best Czech," CPU-local Piper/Kokoro is unbeatable on cost — essentially $0/hour of audio.

3.2 GPU box you own (XTTS-v2, larger open models)

To get natural open-source Czech you generally need a heavier model (e.g. Coqui XTTS-v2, which does Czech and voice cloning, needs ~4 GB VRAM and runs real-time on something like an RTX 3060). Options:

• Use a GPU you already own: marginal cost = electricity only. An RTX-class GPU pulls ~250–450 W under load; at ~$0.165/kWh that's ~$0.04–0.07 per GPU-hour of compute. XTTS runs faster than real-time on a decent GPU, so an hour of generated audio costs single-digit cents in electricity. Still effectively free.
• Buy a GPU box for this: now you have capex. A modest used GPU workstation is a few hundred to ~$1,500. Amortized over, say, 3 years that's ~$15–40/month whether or not you use it — which only makes sense at high, steady volume (see break-even below).

3.3 Serverless GPU (RunPod, Modal, Replicate)

The middle path: no capex, no idle cost, pay per second of GPU time. Verified May-2026 rates:

Cost per hour of audio on serverless depends on the model's real-time factor (RTF). XTTS on a 4090 synthesizes well faster than real-time — call it ~3–6× faster conservatively. So one hour of audio needs ~10–20 min of GPU wall-time:

• RTX 4090 serverless at ~$1.10/GPU-hr × (~0.2–0.33 GPU-hr/audio-hr) ≈ $0.22–0.36 per hour of audio.
• Add cold-start overhead (serverless spins the container up per request) — for bursty "read this one text" calls, cold starts can dominate and inflate effective cost. RunPod FlashBoot can hit sub-200ms cold starts on warm-ish workers, but large-container cold starts run 6–12s. Serverless is best with batching or a warm pool.

Verdict: serverless GPU lands you at ~$0.20–0.40/hr of audio — below the ~$0.72/hr top cloud-API rate (though above Google's $4/1M WaveNet ≈ $0.18/hr) — with no idle cost and no capex, while letting you run a natural open Czech model you control. The catch is engineering effort (container, model loading, cold starts) and that the open model's Czech must actually be good enough for you.

4. Break-even analysis

Now combine it. We compare four strategies at four monthly volumes. Assumptions: top cloud natural rate $16/1M chars (Neural2/Azure Neural); serverless GPU effective ~$0.30/hr of audio; conversion 45k chars = 1 hr of audio, so 1M chars ≈ 22 hr of audio and serverless ≈ $0.30 × 22 ≈ ~$6.60/1M chars.

Reading the break-evens:

• At 100k–1M chars/month (the realistic "reading my own texts" zone), the cloud free tier wins outright: Google's 1M-WaveNet/Neural2-free or Azure's 500k-Neural-free make natural EN+CZ literally $0, with zero ops burden. Don't self-host at this volume — you'd spend engineering hours to save pennies.
• Cloud-paid vs serverless-GPU break-even is essentially immediate once you exceed the free tier: serverless ($0.30/hr) beats cloud APIs ($0.86/hr) per unit. But serverless adds engineering and cold-start risk, so the practical break-even is around 5–20 hours of audio/month (~0.3–1M chars) — below that, free-tier cloud is simpler and cheaper; above it, self-host starts paying for the effort.
• Owned-GPU-box vs serverless break-even: a ~$30/month amortized box only beats serverless once you're producing ~100+ hours of audio/month (~5M+ chars) consistently. Below that, the box sits idle burning amortization while serverless charges only for what you use.
• CPU-local is $0 at every volume — it never loses on cost. It only loses on Czech naturalness. The whole decision reduces to: "is Piper's Czech good enough for me?" If yes, you're done and you never pay anyone.

5. The "reading my texts" volume reality

Let's ground this. If you're reading your own documents/articles/notes:

• A dense article is ~5,000–15,000 characters (~5–15 min audio).
• A book chapter is ~30,000–50,000 chars (~30–55 min).
• Reading one long article a day ≈ ~10k chars/day ≈ ~300k chars/month.
• Reading a chapter a day ≈ ~40k/day ≈ ~1.2M chars/month.

So a heavy personal-reading habit lands around 300k–1.2M characters/month — comfortably inside the perpetual free tiers. This is the single most important fact in the chapter for you: at your likely volume, natural EN+CZ TTS is free via Google (4M WaveNet + 1M Neural2 chars/mo, both free) or Azure (500k Neural chars/mo), possibly stacked across providers. You don't need to self-host to save money — you'd self-host for privacy, offline use, or because you exceed the free tier.

If your software will serve many users (not just you), volumes balloon to 10M+ chars/month and the calculus flips toward serverless GPU with a self-hosted open model (cheapest per unit, ~$0.30/hr) or a paid cloud contract — at which point caching repeated text and choosing the right tier per language matters.

6. Cost-cutting tactics that apply to any option

1. Cache aggressively. TTS output for identical text never changes — store the generated audio keyed by hash(text + voice + settings). For "read my texts," re-reads are common; caching can cut billed characters by a large fraction.

   import hashlib, os
   def cache_key(text, voice, fmt="mp3"):
       h = hashlib.sha256(f"{voice}|{text}".encode("utf-8")).hexdigest()
       return f"tts_cache/{h}.{fmt}"
   # synth only on cache miss:
   path = cache_key(text, "cs-CZ-Neural2")
   if not os.path.exists(path):
       audio = synth(text, voice="cs-CZ-Neural2")  # bills here
       open(path, "wb").write(audio)
   

2. Route by language and quality need. Use the free natural tier (Google/Azure) for Czech where naturalness matters; consider cheaper OpenAI or CPU-local for English where the bar is lower. A small router saves real money at scale.
3. Strip non-spoken text before synthesis (markdown syntax, code blocks, URLs, footnote markers). You're billed per character — don't pay to "speak" ** and https://.
4. Watch byte-billing on Czech. On byte-priced tiers (Google Chirp 3 HD), Czech diacritics inflate the bill 10–20%. Prefer character-billed Neural2/WaveNet for Czech.
5. Stay inside the free tier deliberately. Track monthly character usage; if you're near 1M on Google, that's your hard "free" ceiling — set an alert.

Key Takeaways

• At your realistic personal volume (~300k–1.2M chars/month), natural EN+CZ TTS is FREE. Google Cloud's perpetual 4M WaveNet + 1M Neural2 chars/month (both free) and Azure's 500k Neural chars/month all cover natural Czech at $0. This is the sweet spot you asked for.
• Cloud natural-Czech baseline is $16/1M chars ($0.72/hour of audio) for the top tier (Google Neural2, Azure Neural); Google WaveNet is just $4/1M (~$0.18/hr) for mid-tier Czech. OpenAI is cheap per minute (~$0.68–0.90/hr) but its Czech is accent-tinted. ElevenLabs is the most natural but 8–10× pricier ($7–8/hr) and non-commercial on its free tier.
• Amazon Polly and Deepgram are price-competitive but disqualified for natural Czech — Polly's Czech is robotic Standard-only; Deepgram Aura is English-only. Always verify the voice, not the language code.
• CPU-local (Piper/Kokoro) is genuinely ~$0/hour at any volume — the only cost is Czech naturalness, which is mid-tier. Serverless GPU (RunPod 4090 ~$1.10/hr) running XTTS-v2 lands at ~$0.20–0.40/hour of audio, beating cloud APIs per unit but adding engineering and cold-start overhead.
• Break-evens: below ~5–20 audio-hours/month, free-tier cloud wins (simplest + free). Above that, serverless GPU + open model is cheapest per unit. An owned GPU box only beats serverless above ~100 audio-hours/month of steady use. CPU-local never loses on price.
• Always cache (hash(text+voice) → audio), strip non-spoken characters, and route by language/quality to keep any option near-free.

Key References

• Google Cloud. Text-to-Speech AI pricing. 2026. https://cloud.google.com/text-to-speech/pricing — Standard $4 / WaveNet $4 / Neural2 $16 / Chirp 3 HD $30 / Studio $160 per 1M chars, and perpetual monthly free tiers (4M Standard+WaveNet, 1M Neural2/Chirp).
• Microsoft Azure. Pricing — Azure Speech. 2026. https://azure.microsoft.com/en-us/pricing/details/speech/ — Neural TTS $16/1M chars, Neural HD $22/1M (from Mar 2026), F0 free tier 500k chars/mo.
• Voices.com. Words to Time Conversion Calculator. 2026. https://www.voices.com/tools/words_to_time_conversion — basis for the ~150 WPM / ~750 chars-per-minute / ~45k chars-per-hour normalization factor.
• Amazon Web Services. Amazon Polly Pricing. 2026. https://aws.amazon.com/polly/pricing/ — Standard $4/1M, Neural $16/1M, Generative/Long-form tiers, 12-month free-trial allowances; Czech voice availability by engine.
• OpenAI. API Pricing. 2026. https://openai.com/api/pricing/ — tts-1 / tts-1-hd per-character rates and gpt-4o-mini-tts per-minute audio pricing.
• ElevenLabs. Pricing. 2026. https://elevenlabs.io/pricing — Free (10k credits, non-commercial), Starter $5, Creator $22, Pro $99 plans; credit-to-character mapping and multilingual (incl. Czech) support.
• Deepgram. Pricing / Aura Text-to-Speech. 2026. https://deepgram.com/pricing — Aura/Aura-2 per-1k-character rate, $200 signup credit, English-only voice coverage.
• PlayAI (PlayHT). Pricing. 2026. https://play.ht/pricing/ — API per-character pricing and trial character allowance.
• RunPod. Pricing. 2026. https://www.runpod.io/pricing — Serverless per-second GPU rates (RTX 4090, A100) and rented-pod hourly rates used for the self-host cost model.
• Modal. Pricing. 2026. https://modal.com/pricing — Per-second serverless GPU pricing (A10G, A100) for the serverless break-even comparison.
• Rhasspy. Piper — fast local neural TTS. 2026. https://github.com/rhasspy/piper — CPU-only / Raspberry-Pi-capable open TTS establishing the $0-marginal-cost local baseline; Czech voice availability.
• Coqui / community forks. XTTS-v2 model card & requirements. 2025–2026. https://github.com/coqui-ai/TTS — ~4 GB VRAM, Czech support and voice cloning; basis for the GPU/serverless audio-hour cost figures.
• getdeploying. Cloud GPU Pricing Comparison. 2026. https://getdeploying.com/reference/cloud-gpu — Cross-provider GPU $/hr reference cross-checking RunPod/Modal rates.