Frequently asked questions
Is the Chrome Web Speech API free?
Yes, the Chrome Web Speech API is free to use within the browser without per-character charges. Unlike our cloud API, which costs $0.01 per 1,000 characters, the browser API has no usage fees. However, it lacks the consistent audio quality and specific voice presets available in our cloud service.
Which browsers support it?
The Chrome Web Speech API is primarily supported by Chromium-based browsers like Chrome, Edge, and Opera. Support varies across Firefox and Safari, often requiring polyfills or alternative implementations. For reliable cross-browser consistency in production, a cloud API like Speakable ensures uniform audio output regardless of the user's browser.
Can I use it on mobile?
Yes, the Chrome Web Speech API works on Android Chrome and iOS Safari to varying degrees. However, voice quality and available voices depend on the device’s operating system. Our cloud API provides consistent, high-quality audio across all devices by generating files server-side, avoiding local device limitations.
Does it work offline?
The Chrome Web Speech API can work offline if the browser caches the necessary voice data. This is useful for quick UI interactions without network latency. In contrast, our cloud API requires an internet connection to process text and return audio files, ensuring consistent quality and up-to-date voices.
What voices are available?
The Chrome Web Speech API offers voices provided by the operating system, which vary by device. Speakable provides 8 specific presets like Aria, Nova, and Felix, based on licensed recordings. Our voices are consistent across all users, whereas browser voices depend on the user’s installed language packs and OS.
Can I change the voice programmatically?
Yes, you can change voices programmatically in the Chrome Web Speech API by selecting from available SpeechSynthesisVoice objects. However, the list is limited to what the OS provides. Our API allows precise control over 8 distinct voices via a simple API call, ensuring predictable audio output for your application.
Is there a rate limit?
The Chrome Web Speech API has no strict rate limit but may throttle based on device performance. Our cloud API has a limit of 60 requests per minute per key. This ensures predictable performance for your application. You can increase limits by topping up your account, with automatic credit processing.
Does it support multiple languages?
The Chrome Web Speech API supports languages installed on the user’s device. Our cloud API supports 23 languages, including Arabic, Chinese, and Swahili, regardless of the user’s OS. We allow you to specify the language code explicitly, ensuring the correct voice is used even if the device defaults to English.
Can I save the audio to a file?
The Chrome Web Speech API does not natively support saving audio to a file; it plays audio directly. Our cloud API returns audio files in formats like MP3, WAV, or FLAC. This allows you to store, cache, or distribute the generated speech files as needed for your application’s workflow.
Is it suitable for production?
The Chrome Web Speech API is suitable for quick UI interactions but may lack consistency for production use. Voice quality varies by device. Our cloud API provides consistent, high-quality audio with reliable rate limits and clear pricing. It is better suited for applications requiring uniform user experience across different platforms and devices.
How does it compare to cloud TTS?
The Chrome Web Speech API is free and works offline but lacks consistent quality. Our cloud API offers 8 specific voices, supports 23 languages, and returns audio files for caching. It costs $0.01 per 1,000 characters but ensures uniform output. Use the browser API for quick interactions and our API for scalable, consistent audio.
Does it use AI?
The Chrome Web Speech API typically uses concatenative or parametric synthesis methods provided by the OS. Our cloud API uses a neural network engine to generate speech. Both produce synthetic speech, but our API includes an inaudible watermark to mark files as synthetic, ensuring transparency about the audio’s origin.
Can I clone voices?
No, the Chrome Web Speech API does not support voice cloning. Speakable also does not offer custom voice cloning. We provide 8 preset voices based on licensed recordings. If you need a specific voice, you must choose from our available presets or use the browser’s built-in OS voices.
Is it accessible?
The Chrome Web Speech API is accessible via standard web APIs and works with screen readers. Our cloud API returns standard audio files (MP3, WAV) that are universally accessible. Both methods support text-to-speech functionality, but our API allows you to control speed and format, enhancing accessibility for diverse user needs.
Definition and Scope
The Chrome Web Speech API provides browser-native text-to-speech synthesis, allowing developers to convert text into audible speech directly within the user’s environment. This JavaScript interface leverages the operating system’s existing voice engines, eliminating the need for external audio files or server-side processing for simple UI interactions.
Browser-native synthesis
Synthesis occurs locally on the client device, utilizing the host OS’s built-in speech engines. This approach ensures immediate playback with minimal latency, making it ideal for short, interactive prompts where server round-trip time would introduce noticeable delays.
JavaScript API interface
The SpeechSynthesis interface is accessible via standard JavaScript, allowing direct integration into web applications. Developers can queue utterances, adjust volume, and control playback speed, though options are limited to what the browser exposes.
Built into Chromium browsers
Since it is embedded in Chromium-based browsers, the API is widely available without additional plugins or dependencies. This reduces initial setup complexity for indie developers building quick prototypes or simple read-aloud features.
How It Works
The Chrome Web Speech API, powered by the Web Speech API specification, processes text locally on the user's device. It converts input strings into audio using the operating system’s built-in synthesis engine, requiring no network requests for audio generation.
Unlike cloud APIs, this method relies entirely on the client’s hardware and OS version. The API exposes the SpeechSynthesis interface, allowing developers to queue utterances and manage playback states directly within the JavaScript environment.
Text-to-speech conversion
The browser tokenizes the input text and passes it to the native speech engine. This happens entirely on the client side, meaning no data leaves the device for synthesis. The result is immediate audio output without server latency.
Developers interact with this via the speechSynthesis.speak() method. The API handles the internal buffering and encoding, delivering audio directly to the device’s sound card or Bluetooth output.
- No network dependency for synthesis
Voice selection from OS
Voices are not hosted by the API provider but are installed on the user’s operating system. The speechSynthesis.getVoices() method lists available voices, which vary by device, OS, and language pack.
This creates inconsistency. A voice sounding natural on a Mac may sound robotic on Windows or Android. Developers cannot guarantee the specific voice the end-user will hear, as it depends on their local configuration.
- Voices vary by device and OS
- No uniform voice quality across users
Real-time playback
Audio plays immediately as it is generated, providing low-latency feedback for UI interactions. The SpeechSynthesisUtterance object manages playback states like onstart, onpause, and onend.
Users can pause, resume, or cancel speech via standard browser controls. Volume adjustments affect the output directly, but there is no server-side control over pitch, speed, or emphasis tags like SSML.
- Low-latency playback
- Client-side playback controls
Use Cases
The Chrome Web Speech API is ideal for lightweight, browser-native interactions where network latency isn't critical. It allows developers to trigger speech instantly without waiting for a server response, making it perfect for simple UI feedback.
Because synthesis happens locally on the user’s device, there are no API rate limits or monthly costs. This makes it attractive for startups building prototypes or low-traffic apps that need basic audio without infrastructure overhead.
UI notifications
Use the API to announce button clicks, form submissions, or status changes. Since processing is local, the audio plays immediately, providing instant feedback without a network round-trip.
This is suitable for simple alerts where voice quality is secondary to speed. However, the voice may vary depending on the user’s operating system, so consistency isn’t guaranteed.
- Instant feedback for UI actions
- Zero network latency
- No server costs
Read-aloud features
Implement “read aloud” for blog posts or documentation directly in the browser. The API handles text segmentation and playback natively, requiring minimal JavaScript code.
Best for short articles or static content. For long texts, local processing can become resource-intensive on older devices, and background playback may be paused by the browser to save battery.
bullets
Accessibility tools
Enhance accessibility by allowing users to hear text content. The Web Speech API integrates with screen readers and supports standard web accessibility patterns.
Ensure users have control over playback, such as pause and resume. Since voices are OS-dependent, the experience may feel inconsistent across different devices and browsers.
bullets
Limitations
The Chrome Web Speech API relies on the operating system’s installed voices, leading to inconsistent experiences across devices. A feature that sounds clear on one user’s laptop may sound robotic on another’s tablet, making it difficult to guarantee a consistent brand voice in production environments.
Additionally, language support is limited to what the user’s OS provides. If a device lacks a specific language pack, that voice disappears from the selection, breaking read-aloud features for international users without warning. Finally, because synthesis happens locally, you have no server-side control over the audio generation, meaning you cannot enforce quality standards or retry failed requests from your backend.
Inconsistent voices across devices
The API uses whatever voices are installed on the user’s device. This means your application’s audio quality and tone can vary significantly depending on whether the user is on Windows, macOS, Android, or iOS. You cannot guarantee that the voice heard by your QA team is the same one heard by your end users.
This inconsistency makes it hard to maintain a uniform brand identity. If your product relies on a specific voice for UI feedback, you must account for the possibility that the user’s device has a different, potentially lower-quality voice installed.
- Voice selection is OS-dependent, not app-controlled.
- Quality varies by device hardware and installed language packs.
- No way to enforce a specific voice version remotely.
Limited language support
Language availability is tied to the user’s operating system settings. If a user’s device does not have the required language pack installed, the voice will not appear in the selection list, even if your app supports it. This can lead to silent failures or fallback to a default voice the user didn’t choose.
Unlike cloud APIs that offer a consistent set of voices regardless of the device, the Web Speech API’s language support is fragmented. Users in different regions may experience different available voices, complicating testing and user experience consistency.
- Language packs are OS-specific, not app-controlled.
- Missing packs result in missing voices, not errors.
- No central management of language availability.
No server-side control
Since synthesis occurs on the client side, you cannot monitor or control the process from your servers. You cannot retry a failed request, adjust parameters centrally, or ensure that the audio was generated correctly. This lack of oversight makes it difficult to debug issues or maintain quality in production.
Additionally, you cannot leverage server-side caching or processing to optimize performance. Every request consumes the user’s device resources, which can impact battery life and performance on lower-end devices, especially for longer texts.
For startups scaling their product, this lack of control can be a significant limitation. You cannot enforce consistent audio quality or manage costs based on server-side usage metrics, making it harder to predict resource consumption and user experience.
- No server-side retry or error handling.
- Client-side resource usage affects battery and performance.
- No central quality control or caching.
Comparison to Cloud API
The Chrome Web Speech API processes audio locally on the user’s device, offering immediate playback with zero network latency. In contrast, Speakable’s cloud API sends text to a server, where synthesis occurs before returning an audio file. This remote processing introduces a slight delay but ensures the audio is generated by our dedicated engines rather than the device’s system voices.
Local vs remote processing
Local synthesis depends entirely on the client’s hardware and operating system. Remote processing via Speakable’s POST /v1/audio/speech endpoint guarantees that the output matches the specified model (tts-1 or tts-1-hd) regardless of the user’s device. While local APIs are faster for instant feedback, cloud API allows for consistent quality across all platforms.
- Local: Zero latency, offline capable, device-dependent quality
- Cloud: Consistent engine, higher fidelity, requires internet
Consistency vs convenience
Browser-native voices vary significantly between Chrome on Windows, macOS, and Android. Speakable provides 8 distinct presets (e.g., Aria, Felix, Atlas) that sound identical whether accessed from a desktop browser or a mobile app. This consistency is critical for brand voice and user experience, eliminating the jarring shifts between system voices found in the Web Speech API.
- 8 consistent presets vs. dozens of varying system voices
- Unified experience across iOS, Android, and desktop browsers
Cost implications
The Web Speech API is entirely free, as it leverages the user’s existing device resources. Speakable charges $10 per 1 million characters, with a free trial of $0.50 for new accounts. For simple UI notifications, local API is cost-effective. For production-grade audio where voice consistency matters, the marginal cost of the cloud API is outweighed by the reliability and quality of the output.
- Web Speech: $0 fixed cost
- Speakable: $0.01 per 1,000 characters, pay-as-you-go
Technical Details
The Web Speech API is defined by the W3C specification, providing a standardized JavaScript interface for browser-based synthesis. It relies on the SpeechSynthesis interface, which interacts directly with the operating system’s installed voices rather than fetching audio from a server. This native approach enables immediate playback without network latency, making it ideal for simple UI feedback where consistent voice quality is less critical than responsiveness.
Web Speech API specification
The specification outlines how browsers must expose synthesis capabilities to web applications. It handles voice selection from the local OS, allowing developers to query available voices programmatically. Unlike cloud APIs that return audio files via endpoints like POST /v1/audio/speech, this interface manages real-time playback directly within the browser’s rendering thread, ensuring low-latency interaction for users.
- Standardized W3C interface for text-to-speech
- Native OS voice integration
- No network requests for audio generation
SpeechSynthesis interface
The SpeechSynthesis object provides methods for queueing, pausing, and resuming speech. It allows developers to select voices from the local OS list, but these voices vary significantly by device and platform. There is no server-side control over the synthesis engine, meaning the same text may sound different on Chrome versus Firefox, or on a Windows machine versus a Mac.
- Queue management for multiple utterances
- Local voice selection from OS
- Variability in voice quality across devices
Browser compatibility
Compatibility is generally high among modern Chromium-based browsers, but voice availability depends on the underlying operating system. Safari and Firefox may support different voice sets or behavior nuances. For production apps requiring consistent audio across all user devices, this variability is a key technical constraint compared to cloud-based solutions that guarantee the same voice regardless of the client environment.
- Supports Chrome, Edge, Safari, Firefox
- Voice availability varies by OS
- Inconsistent behavior across different browsers
When to Use It
The Chrome Web Speech API is ideal for lightweight UI interactions where immediate feedback matters more than voice quality. It processes text locally, eliminating network latency and ensuring instant playback for buttons, tooltips, or short status messages.
This approach works best when you only need basic speech synthesis without worrying about server costs, API keys, or backend infrastructure. It is a convenient, zero-cost solution for simple, browser-bound experiences.
Low-latency needs
Local processing ensures speech plays instantly without waiting for a server response. This is critical for interactive elements where users expect immediate audio feedback, such as confirming a button click or reading a short alert.
Since the audio is generated on the device, there is no network dependency. This makes the experience robust even in poor connectivity scenarios, provided the browser supports the necessary voices.
- Instant playback for UI interactions
- No network round-trip time
- Works offline once voices are cached
Simple text-to-speech
Use this API when you need to convert short strings of text into speech without complex configuration. It handles basic voice selection and rate adjustment directly through JavaScript, requiring minimal code.
It is suitable for reading out single sentences or brief instructions where high-fidelity audio is not a priority. The voices are adequate for functional communication but lack the nuance of cloud-generated speech.
No character limits or per-request costs apply, making it free for unlimited use within the browser environment.
- Minimal code implementation
- No per-character costs
- Automatic voice selection
Browser-only apps
If your application runs entirely within a web browser and does not require consistent voice branding across different devices, the Web Speech API is sufficient. It removes the need for backend services or API management.
This is ideal for internal tools, simple prototypes, or apps where voice consistency across platforms is not a strict requirement. You avoid the overhead of managing API keys and billing accounts.
Note that voices may vary between Chrome, Edge, and other Chromium-based browsers, so testing is essential to ensure acceptable quality.
- No backend dependency
- Ideal for prototypes
- Cross-browser variability acceptable

When to Switch
The Chrome Web Speech API relies on the user’s operating system for voice generation, meaning your app’s audio quality varies wildly between a Windows PC, a Mac, and an Android phone. For indie developers building products for startups, this inconsistency is often unacceptable for brand identity.
When you need your text-to-speech feature to sound identical for every user, regardless of their device, you must switch to a cloud API like Speakable. This ensures your product delivers a uniform, professional experience that doesn’t depend on the user’s browser settings.
Need for consistent voices
Local synthesis uses voices installed on the user’s device, which may differ in quality or availability. A cloud API guarantees the same voice preset, such as Aria or Felix, is used every time.
Consistent audio branding helps startups maintain a professional image. Users expect the same tone and clarity whether they are on a desktop or mobile device.
- Guaranteed voice identity across all platforms
- No dependency on OS voice packs
- Uniform audio experience for users
Multi-language support
The Chrome API’s language support depends on the user’s OS. If a user lacks a specific language pack, synthesis may fail or fall back to English. Speakable supports 23 languages natively, including Hindi, Korean, and Swahili, regardless of the user’s system.
You can explicitly set the language field in your API request. This prevents guessing errors and ensures correct pronunciation for non-English Latin script text, which the Chrome API often misinterprets.
- Support for 23 languages including niche options
- Explicit language control via API
- No reliance on OS language packs
Production-grade audio
For production apps, you need reliable audio formats like MP3 or WAV, not just real-time playback. The Chrome API streams audio directly to the speaker, making it hard to save, cache, or process files. A cloud API returns a downloadable audio file.
With Speakable, you receive a stable audio file that can be stored, shared, or embedded. This is essential for features like read-aloud articles or voice notifications where the user might want to replay the audio later.
- Downloadable audio files (MP3, WAV, FLAC)
- Cacheable and shareable audio assets
- Better error handling and retry logic
Development Workflow
Developers testing Chrome Web Speech API workflows should verify voice selection and playback controls across devices. Unlike cloud TTS, voices depend on the OS, requiring code to handle missing voices gracefully. This ensures consistent UI behavior without relying on server-side consistency.
Error handling is critical since browser synthesis may fail silently or throw exceptions if the device lacks speech support. Developers must implement fallbacks for unsupported features, ensuring the app remains usable even when native synthesis is unavailable or restricted.
Testing in Chrome
Use Chrome DevTools to inspect SpeechSynthesis events. Verify that voice lists populate correctly and that playback triggers align with user interactions. Test on multiple OS versions to observe voice variation, as Chrome relies on system voices rather than a unified cloud engine.
- Check
window.speechSynthesis.getVoices()for available options - Verify playback latency under network load
- Test voice selection persistence across page reloads
Handling voice changes
Browser voices may change if the OS updates or if multiple profiles exist. Code should dynamically refresh the voice list rather than caching it statically. This prevents users from hearing unexpected voices after a system restart or profile switch.
Error states
Wrap synthesis calls in try-catch blocks to handle abrupt failures. If the browser does not support the API, display a clear message or disable the audio feature. Unlike cloud APIs, there is no explicit error code for missing voices, so graceful degradation is essential.
Audio Output
The Chrome Web Speech API handles audio playback directly within the browser environment, eliminating the need for external media players. This native approach ensures immediate feedback for UI interactions like button clicks or form validation hints, where latency is critical.
Playback controls
Browsers manage the audio stream automatically. Once the SpeechSynthesisUtterance object is queued, the system initiates playback without requiring a dedicated media element. This reduces DOM complexity compared to loading external audio files from a cloud TTS API.
Pause and resume
The API exposes pause() and resume() methods to control the synthesis state. Unlike cloud APIs that return static audio files, the browser maintains the synthesis context, allowing seamless interruption and resumption of speech.
Volume adjustment
Each utterance includes a volume property ranging from 0.0 to 1.0, allowing per-speech volume control. This granular control lets developers adjust notification sounds independently from background narration without affecting the system’s master volume settings.
Accessibility
The Chrome Web Speech API provides native accessibility by leveraging the operating system’s text-to-speech engines. This allows users with visual impairments to hear UI elements without requiring additional browser extensions or external services, making it a viable baseline for basic screen reader integration in lightweight web applications.
However, this convenience comes with significant trade-offs. Because voice synthesis occurs locally on the device, the quality and consistency depend entirely on the user’s installed OS voices. This can lead to unpredictable audio experiences across different devices and browsers, limiting its suitability for professional-grade accessibility features where consistency is paramount.
Screen reader integration
The API integrates directly with the browser’s accessibility tree, allowing developers to programmatically trigger speech for form labels, buttons, or status updates. This reduces the need for complex ARIA live region updates for simple audio cues.
Unlike cloud APIs, there is no server-side rendering delay, but the reliance on local OS voices means the auditory experience varies significantly between Windows, macOS, and Android devices.
- Native OS voice integration
- No external service dependency
- Varies by device OS
User control
Users retain full control over pitch, rate, and voice selection through their system settings. The API respects these preferences, ensuring that users can adjust speech parameters to their comfort level without application interference.
This local control is a double-edged sword: while it empowers users, it means the developer cannot enforce a specific brand voice or ensure a consistent tone across all installations.
Performance impact
Since synthesis happens on the client side, there is no network latency, but CPU usage can spike during complex utterances. This may impact battery life on mobile devices or cause jank in resource-constrained environments.
For simple UI interactions, the impact is negligible. However, for longer texts or frequent updates, the local processing load can become noticeable compared to cloud solutions.
Future of Web Speech
The Chrome Web Speech API remains a stable, low-cost option for basic UI interactions, but it lacks the consistency and quality needed for polished user experiences at scale. While browser support is broad, voice quality varies significantly by device and OS version.
For indie developers building production-grade applications, relying solely on the browser’s native engine introduces unpredictable variables in audio output and language support, making a cloud API a more reliable choice for consistent branding and user satisfaction.
Browser updates
Browser vendors periodically update the underlying speech synthesis engines, which can subtly change voice characteristics or introduce regressions without major version bumps. This means a voice that sounds perfect today may sound different tomorrow, affecting user experience consistency.
- Voice quality varies by OS and browser version
- No guarantee of backward compatibility for audio output
API evolution
The Web Speech API is relatively static, offering limited control over pitch, rate, and voice selection compared to modern cloud APIs. It lacks features like SSML, custom pronunciation, or detailed voice metadata, limiting advanced use cases.
- Limited voice selection parameters
- No SSML or custom lexicon support
Industry trends
The industry is shifting towards cloud-based TTS for its superior quality, multi-language support, and consistent performance across devices. Developers are increasingly prioritizing audio fidelity and reliability over the convenience of native browser APIs for key user-facing features.
- Cloud TTS becoming the standard for quality
- Native APIs reserved for simple, low-stakes interactions
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. This sequential processing guarantees that each audio file is generated correctly without race conditions.
23 languages
Any voice speaks any of these languages.
