Use gTTS when a Python process needs a simple MP3 and network access is acceptable. Use the browser Web Speech API when a webpage needs immediate spoken playback without creating an audio file or operating a backend. Use a controlled neural TTS service or model when the product must deliver a predictable voice, consistent output across devices, or downloadable audio with an explicit service contract.
The names sound interchangeable, but they solve different engineering problems. The fastest decision is to start with the required output and reliability boundary rather than comparing voice demos.
Decision table
| Requirement | gTTS | Browser Web Speech API | Controlled neural TTS |
|---|---|---|---|
| Primary environment | Python or CLI | Browser JavaScript | Server, managed API, or local model runtime |
| Normal output | MP3 file or byte stream | Playback through the device/browser speech service | Audio file or stream, depending on implementation |
| Network requirement | Yes | Depends on the selected voice; local and remote services can exist | Depends on whether the model is hosted or local |
| Voice consistency across users | Limited | Low; available voices vary by device | High when the same model and voice are used |
| Voice controls | Language, slow mode, and accent-related top-level domain options | Rate, pitch, volume, language, and available voice selection | Model-specific controls; may include speed, style, SSML, or reference audio |
| Browser UI integration | Requires a server or generated file | Direct | Requires client/server integration unless running locally |
| Standard audio export | Yes | No standard export method | Usually, but implementation-specific |
| Main operational risk | Network/service dependency and request failures | Cross-device voice differences and browser lifecycle behavior | Cost, infrastructure, latency, privacy, and model operations |
The official references behind this comparison are the gTTS documentation and MDN’s documentation for SpeechSynthesis, getVoices(), and the voiceschanged event.
What gTTS is
gTTS is a Python library and command-line tool that interfaces with Google Translate’s text-to-speech service. It is a network client, not a speech model embedded in the Python package.
A minimal file workflow is straightforward:
from gtts import gTTS
speech = gTTS("Build finished. Twelve checks passed.", lang="en")
speech.save("status.mp3")That makes gTTS useful for prototypes, personal automation, notifications, language examples, and low-volume scripts where an MP3 is the desired result.
gTTS strengths
- It produces an audio file without requiring audio capture from a browser.
- The Python and CLI interfaces are small and easy to automate.
- It supports many language codes and can alter accent behavior through supported top-level-domain settings.
- It can write to a file or file-like object, which fits pipelines that store or deliver MP3 data.
gTTS limits that affect architecture
- Every synthesis request needs network access.
- The package does not provide a local fallback model.
- It does not give the fine-grained voice catalog, style, or prosody controls expected from a dedicated neural TTS platform.
- A production caller still needs timeouts, retries, input-size handling, caching, and failure reporting.
- Sensitive text leaves the local process for synthesis, so data policy must be reviewed before use.
Do not infer a service-level agreement from a successful prototype. The library makes synthesis convenient; it does not remove the operational responsibility of a product that depends on an external speech service.
What browser TTS is
Browser TTS normally means window.speechSynthesis and SpeechSynthesisUtterance, the synthesis side of the Web Speech API.
const utterance = new SpeechSynthesisUtterance(
'This sentence is spoken by an available browser voice.'
);
utterance.rate = 1.1;
window.speechSynthesis.speak(utterance);The important phrase is “available browser voice.” MDN defines speechSynthesis.getVoices() as returning voices available on the current device. A SpeechSynthesisVoice also exposes localService, which indicates whether the voice is supplied by a local synthesizer service.
Browser TTS strengths
- It starts from client-side JavaScript with no mandatory application backend.
- It is widely available in modern browsers.
- The page can control rate, pitch, volume, language, and voice selection.
- It fits small interface features such as pronouncing a word, reading a notification, or playing a short selected passage.
- A local voice can avoid sending the utterance to an application server, though the implementation must not assume that every selected voice is local.
Browser TTS limits that affect architecture
- Voice names and quality differ across operating systems and devices.
getVoices()may not contain the final list at initial page load; applications should populate immediately and also listen forvoiceschanged.- The API speaks through the available service but does not define a standard method to export the result as an MP3 or WAV.
- Boundary events, long-document behavior, background-tab behavior, and voice availability must be tested in every supported browser and operating system.
- A voice with
localService === falsemay use a remote speech service, so “browser TTS is always offline” is not a safe claim.
The voice-loading pattern browsers need
A robust voice selector handles both an immediately available list and a later update:
const synth = window.speechSynthesis;
function loadVoices() {
const voices = synth.getVoices();
// Rebuild the UI from the current list.
return voices;
}
loadVoices();
synth.addEventListener('voiceschanged', loadVoices);The UI should not save only an array index because the order can change. Store a stable combination such as voice name, language, and URI, then fall back by language if the preferred voice is unavailable on another device.
Where controlled neural TTS changes the tradeoff
A managed neural API or a self-hosted model provides a speech engine the application can choose and version. That can make output more consistent than a device-dependent browser voice.
It also adds responsibilities:
- define where text is processed and retained;
- authenticate and rate-limit requests;
- set maximum input and output sizes;
- decide whether to stream or wait for a complete file;
- handle retries without charging or generating twice;
- cache only when content policy permits it;
- monitor latency, cost, and provider/model changes;
- document language and pronunciation limits.
Local neural models can reduce external data transfer, but they shift compatibility, model download, memory, and compute requirements to the device. “Neural” describes the synthesis method, not whether the system is cloud-only.
Choose by the actual job
A Python task needs an MP3
Start with gTTS if the volume is modest, the content is not restricted, and the dependency is acceptable. Add timeouts, retry with backoff, a cache key based on normalized text and language, and an explicit failure path.
Choose a contracted TTS provider or controlled model if the audio is customer-facing, high-volume, latency-sensitive, or subject to a reliability commitment.
A webpage needs a short read-aloud button
Start with the Web Speech API. Load voices correctly, let users preview them, and test the supported browser/device matrix. Do not promise one named voice on every machine unless the application supplies that voice itself.
A product needs the same narrator everywhere
Use a controlled model or service. Version the voice, test pronunciation, and define a fallback. Browser TTS cannot guarantee that Windows, macOS, Android, and iOS expose the same catalog.
A user wants long pages, PDFs, and books read aloud
The synthesis engine is only part of the solution. Long-form reading also needs content extraction, queueing, highlighting, navigation, playback recovery, and source-specific limits. A finished reader can be more appropriate than building those layers around gTTS or speechSynthesis.
A test matrix before committing
| Test | Why it matters |
|---|---|
| Cold start with an empty browser voice list | Confirms the UI handles voiceschanged |
| Preferred voice missing on another operating system | Confirms language fallback instead of silence |
| Offline test | Separates local voices from network dependencies |
| Ten-second and ten-minute inputs | Reveals queue, chunking, memory, and background behavior |
| Names, acronyms, numbers, URLs, and mixed languages | Exposes pronunciation and language-detection limits |
| Network timeout and repeated submission | Confirms retry and idempotency behavior |
| Private or regulated text | Confirms the selected service is allowed by policy |
| Screen-reader and keyboard operation | Prevents a read-aloud control from creating a new accessibility barrier |
Testing one sentence on one laptop is not enough evidence for a production decision.
Where CastReader fits
CastReader is a user-facing reading system rather than a general TTS programming interface. It combines speech with source-specific extraction and reading controls for supported webpages, PDFs, documents, ebooks, and AI chats.
It is publicly available on Chrome, Edge, iPhone, iPad, and Android. CastReader is free to start with daily allowances; Pro provides higher usage limits and additional voice and explanation access. The Mac desktop app is not publicly available.
Use CastReader when the requirement is “help me listen to this content where I am reading it.” Use gTTS, browser TTS, or another synthesis system when the requirement is “help me build speech into my own software.” Useful examples include reading Gmail aloud, listening to Substack, reading Wikipedia, and opening a text PDF in the browser.
Frequently asked questions
Is gTTS an offline text-to-speech engine?
No. The package interfaces with Google Translate’s text-to-speech service and requires network access for synthesis. If offline operation is mandatory, choose an installed system voice or a local model and test it on the target device.
Why does speechSynthesis.getVoices() return an empty list?
Some browsers populate the voice list after the page initializes. Call getVoices() immediately, listen for voiceschanged, and rebuild the selector when that event fires.
Can browser TTS create an MP3 file?
The Web Speech API defines speech playback, not a standard audio-export function. If the product needs a downloadable file, use a synthesis system that returns audio data or record through a separately designed and permitted workflow.
Is browser text to speech always offline?
No. SpeechSynthesisVoice.localService distinguishes local from non-local speech services, and available voices depend on the device. Test the selected voice without a network connection before claiming offline support.
Which option gives the same voice on every device?
A controlled neural model or service is the strongest starting point because the application selects the synthesis engine. Browser TTS intentionally uses the device’s available catalog, so consistency across users is limited.
Which option is best for reading a long webpage?
The answer depends on more than the voice. A long-page reader needs extraction, queueing, highlighting, and recovery when the page changes. Use a finished read-aloud workflow unless building and maintaining those layers is part of the project.
Bottom line
Choose gTTS for a simple networked Python-to-MP3 task, browser TTS for immediate in-page playback with device-dependent voices, and controlled neural TTS when consistency and service guarantees justify the additional infrastructure. Then test the real content, device matrix, network failures, and privacy boundary before shipping.