Frequently asked questions
What is the Web Speech API?
The Web Speech API is a browser-native interface allowing JavaScript to synthesize speech directly within the user’s browser. It relies on the device’s operating system and local resources, meaning quality and availability vary significantly depending on the user’s specific browser and hardware configuration.
Is the Web Speech API reliable?
Reliability depends entirely on the user’s browser and network. Cloud TTS offers consistent, high-quality audio regardless of the client device. Our API processes requests on our servers, ensuring uniform voice quality and predictable performance for notifications and interfaces without local dependency.
What browsers support Web Speech?
Support varies by browser version and operating system. Chrome, Edge, and Safari generally support it, but implementation details differ. Cloud TTS works across all modern browsers since it returns standard audio files (mp3, wav, opus, flac, pcm) via a simple API endpoint.
Can Web Speech speak multiple languages?
Web Speech support is limited and inconsistent across browsers. Our cloud API supports 23 languages, including Arabic, Chinese, Hindi, and Swahili. Any voice can speak any supported language, providing consistent multilingual capabilities without relying on the user’s installed system languages.
Why is cloud TTS more reliable?
Cloud TTS uses dedicated servers, eliminating local hardware variability. Our API processes requests sequentially, ensuring consistent output. Unlike browser-based synthesis, cloud voices remain uniform across all user devices, which is critical for reliable SaaS notifications and interface consistency at scale.
Does cloud TTS cost money?
Yes, cloud TTS is a paid service at $0.01 per 1,000 characters. Failed requests are free. You can start with a $0.50 free trial (valid 7 days, given when you sign in with Google) or top up via USDT on TRON. There are no monthly plans or minimum spend requirements.
Can I customize Web Speech voices?
Web Speech voice options are limited to those installed on the user’s device. Cloud TTS offers 8 distinct presets like Aria, Nova, and Atlas. You can adjust speed between 0.25 and 4.0, but there is no custom voice cloning, SSML, or emotion tags support.
How do cloud voices differ from web voices?
Cloud voices are consistent, high-quality presets based on licensed recordings, delivered via API. Web voices depend on the user’s browser and OS. Cloud TTS provides uniform audio quality for all users, whereas Web Speech quality fluctuates based on local device capabilities.
Is Web Speech free forever?
Web Speech is free but limited by browser support and device resources. Cloud TTS costs $0.01 per 1,000 characters but offers superior reliability and consistency. For large-scale SaaS deployments, the predictable cost and uniform quality of cloud TTS often justify the expense.
What is the character limit for Web Speech?
Web Speech limits vary by browser but are generally restrictive. Our cloud API allows up to 4096 characters per request. For longer texts, you can split the input and join the resulting audio files, ensuring no hard limit on total message length.
Does cloud TTS store my data?
Input text is used only to produce audio and is not used for training. Generated audio is returned in the response and not stored. We keep request metadata (time, characters, status) solely for billing purposes, ensuring privacy for your notification content.
Can I use cloud TTS for notifications?
Yes. Cloud TTS is ideal for SaaS notifications and interfaces. With a rate limit of 60 requests per minute, it scales well. You can integrate it via standard HTTP or OpenAI SDKs to deliver consistent audio alerts to your users reliably.
Which is better for accessibility?
Cloud TTS is better for consistent accessibility. It provides uniform voice quality across all devices, unlike Web Speech which varies by browser. Our clear presets like Aria and Sage ensure predictable reading experiences, crucial for users relying on screen readers or audio interfaces.
How do I migrate from Web Speech?
Replace browser calls with API requests to https://api.playtop99.com/v1. Use the same OpenAI SDK structure by changing the base URL. Send text via POST /v1/audio/speech with your API key. Split long texts into 4096-character chunks and join the audio files.
What is Web Speech API?
The Web Speech API is a browser-native JavaScript interface that allows web applications to synthesize text into audio directly on the user’s device. It requires no external network calls, making it ideal for simple, offline-friendly prototypes where internet connectivity is guaranteed but server costs must remain zero.
Developers typically invoke the SpeechSynthesis interface to queue utterances or speak text immediately. While convenient for basic demos, the underlying engine relies on the operating system’s installed voice packs, meaning output quality varies significantly between Chrome on Windows, Safari on macOS, and Firefox on Linux.
Browser Native Synthesis
This feature is built into modern browsers, eliminating the need for third-party dependencies. It processes text locally, reducing latency for short phrases but limiting the voice library to what the user’s OS provides.
- Zero network overhead for initial setup
- Works offline once the browser is loaded
- Dependent on client OS version
JavaScript API Overview
The API exposes objects like SpeechSynthesis and SpeechSynthesisUtterance. Developers can set pitch, rate, and voice selection, but options are limited. There is no standard way to request specific audio formats like MP3 or WAV for storage.
- SpeechSynthesis for queue management
- SpeechSynthesisUtterance for individual lines
- Limited voice property access
Client-Side Processing
All computation happens on the user’s CPU. For large SaaS applications with many concurrent users, this shifts the processing load to their devices, potentially affecting battery life and performance on lower-end hardware.
- No server compute costs
- High client CPU usage
- Inconsistent audio quality
Limitations for SaaS
The Web Speech API relies entirely on the user’s browser environment, making behavior unpredictable across different devices and versions. For SaaS teams managing large-scale deployments, this client-side dependency means synthesis quality varies wildly depending on whether the user is on Chrome, Safari, or a legacy mobile browser. You lose control over the generation process once the command leaves your server.
This variability extends to voice consistency. Unlike a cloud API that guarantees the same voice preset for every request, browser-native voices are often tied to the operating system’s language pack. A user on Windows might hear one version of a voice, while a macOS user hears another, breaking the auditory identity of your application.
Browser Dependency
The Web Speech API relies entirely on the user’s browser environment, making behavior unpredictable across different devices and versions. For SaaS teams managing large-scale deployments, this client-side dependency means synthesis quality varies wildly depending on whether the user is on Chrome, Safari, or a legacy mobile browser. You lose control over the generation process once the command leaves your server.
This variability extends to voice consistency. Unlike a cloud API that guarantees the same voice preset for every request, browser-native voices are often tied to the operating system’s language pack. A user on Windows might hear one version of a voice, while a macOS user hears another, breaking the auditory identity of your application.
- - Behavior changes based on the user's browser and OS version. - No guarantee of consistent voice quality across different platforms. - Dependent on the user's device capabilities and internet connection.
Inconsistent Voices
Browser-native voices are often tied to the operating system’s language pack, leading to inconsistent auditory experiences. In contrast, our cloud API uses licensed recordings from LibriTTS-R and LibriVox, ensuring every generated file carries the same high-quality preset. This consistency is crucial for notification services where users expect a uniform brand voice.
Furthermore, browser voices may not support all 23 languages we offer, such as Swahili or Turkish, without requiring additional system downloads. This limitation forces your users to manage language packs manually, adding friction to the user experience.
- - Voice quality varies by OS and browser version. - Limited language support compared to cloud alternatives. - No guarantee of consistent voice preset across requests.
No Programmatic Control
The Web Speech API offers limited control over generation parameters. You cannot easily adjust speed beyond basic presets or choose specific audio formats like MP3 or WAV for download. This lack of programmatic control makes it difficult to integrate TTS into complex workflows where audio files need to be stored or processed server-side.
Additionally, there is no way to programmatically handle errors or retry failed synthesis attempts with different parameters. In a SaaS notification system, this can lead to silent failures or inconsistent user experiences when the browser decides the voice is unavailable.
- - Limited control over speed and audio format. - Difficult to integrate into complex server-side workflows. - No programmatic error handling or retry mechanisms.
Cloud API Advantages
We generate audio on our servers rather than relying on the user’s browser. This moves processing off the client device, ensuring that notification sounds or interface feedback play consistently regardless of whether the user is on Chrome, Safari, or a mobile browser.
Server-Side Generation
By sending text to https://api.playtop99.com/v1, your backend controls the synthesis. The client receives only the final audio file, eliminating browser-specific rendering quirks and allowing you to handle large volumes without taxing the user’s device.
Consistent Output
Web Speech API voices vary by operating system and version. Our eight licensed presets (e.g., Aria, Atlas) deliver uniform quality across all devices. Every file carries a synthetic watermark, ensuring brand consistency in your SaaS notifications.
Scalability
Requests are processed sequentially with queue management, handling 60 requests per minute per key. This predictable throughput supports large teams without the unpredictable CPU spikes associated with client-side synthesis, making it ideal for global SaaS interfaces.
Voice Quality Comparison
Web Speech API voices vary significantly by browser and OS version. A notification synthesized in Chrome may sound distinct from the same text in Safari, leading to inconsistent user experiences across your installed base. This variability makes it difficult to maintain a uniform brand voice in your interface.
Cloud TTS delivers consistent audio regardless of the client device. By using server-side generation, you ensure that every user hears the exact same tone, pitch, and pacing, standardizing the auditory experience across all platforms and browsers.
Web Speech Variability
Browser implementations of Web Speech API differ widely. Chrome, Firefox, and Safari use distinct engine variants, and updates can change voice characteristics without notice. This creates unpredictable audio quality for end-users, especially in accessibility contexts where consistency is critical.
Additionally, voices are often limited to what the operating system provides, which may include robotic or outdated sounding options. There is no way to force a specific voice variant across all users, leading to a fragmented auditory identity.
Cloud Preset Consistency
Our API uses eight carefully selected presets like Aria, Nova, and Atlas. These voices are generated from a single engine, ensuring uniform quality whether the user is on a desktop, tablet, or mobile device. This consistency supports reliable notification strategies and predictable interface behavior.
Each voice is designed for specific contexts, from warm narration to neutral news reading. This allows you to match the tone of your SaaS product precisely, something difficult to achieve with the limited and variable browser-native voices.
- Aria: Warm, clear narrator
- Atlas: Neutral, news-style
- Nova: Bright, upbeat
Licensed Sources
Our voices are derived from licensed recordings of LibriTTS-R (CC BY 4.0) and public-domain LibriVox audiobooks. This provides a high-quality, legal foundation for synthetic speech that avoids the uncanny valley effect common in lower-tier browser engines.
Every generated file includes an inaudible watermark, marking it as synthetic. This adds a layer of transparency and provenance to your audio outputs, which is useful for compliance and content verification in large-scale deployments.
Language Support Differences
The browser’s Web Speech API relies on the client’s operating system to provide voice packs. This creates a fragmented experience where voice quality and availability depend heavily on the user’s device and platform. A feature that works flawlessly on Chrome for Windows may be absent or degraded on Safari for macOS, forcing teams to build complex fallback logic to handle these inconsistencies across different user environments.
Cloud synthesis centralizes this complexity. By moving generation to the server, you ensure that every user hears the exact same voice quality regardless of their device. This consistency is critical for SaaS interfaces where brand identity and clarity must remain uniform across all touchpoints.
Browser Language Pack
Browsers only include a limited set of languages by default, often prioritizing English, Spanish, and major European languages. Users in regions with less common languages may need to manually install language packs, leading to a poor initial experience. Even with packs installed, the underlying engine varies by browser vendor, causing subtle differences in pronunciation and tone that are difficult to standardize.
- Dependent on OS and browser version
- Limited native language support
- Inconsistent voice quality across platforms
Cloud Language List
Our API supports 23 specific languages, including Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, and Turkish. This curated list ensures high-quality synthesis for each supported language, backed by licensed voice recordings. Unlike browser engines that may offer many low-quality voices, we prioritize quality over quantity, ensuring every voice is distinct and reliable for professional use.
Explicit Language Codes
In the browser, language detection is often automatic and prone to errors, especially with mixed-language text. Our API allows you to explicitly set the language parameter using an ISO code. This gives you precise control over the synthesis, ensuring that a Dutch sentence isn’t mispronounced as English just because the browser guessed incorrectly. If omitted, the system guesses based on the script, defaulting to English for Latin text, but explicit codes eliminate this ambiguity.
Performance at Scale
The Web Speech API offloads synthesis to the client, meaning every user’s device must handle the CPU load. For large SaaS teams with thousands of concurrent users, this creates unpredictable performance based on individual hardware capabilities. Cloud TTS centralizes this burden, ensuring consistent quality regardless of the user’s device.
Our architecture processes requests sequentially rather than in parallel. This means that under heavy load, requests enter a queue. While this avoids server bottlenecks, it implies that response times may vary depending on current demand, rather than guaranteeing instant playback across all clients simultaneously.
Client CPU Usage
Browser-native synthesis consumes significant processing power on the user’s device. High-end workstations handle this easily, but mobile devices or older laptops may experience lag or battery drain during long synthesis tasks. By moving synthesis to the cloud, you preserve client resources for your core application logic.
This shift is critical for SaaS notifications where multiple audio events might trigger simultaneously. Client-side processing can lead to audio glitches if the browser prioritizes other tasks, whereas cloud generation ensures the audio file is ready before being streamed to the interface.
- Preserves client CPU for core application tasks
- Eliminates device-specific performance variations
- Reduces battery drain on mobile devices
Server Load Balancing
Unlike client-side variability, our cloud infrastructure handles the heavy lifting. Requests are processed sequentially, which simplifies load management but requires careful queue monitoring during peak usage. This approach prevents single-server bottlenecks but introduces a predictable wait time under high volume.
The sequential processing model ensures that each request receives full attention, maintaining audio quality. However, it means that concurrent requests do not necessarily yield concurrent results. Teams must design their interfaces to handle potential delays gracefully, such as showing a loading state while the audio is generated.
Queue Management
Under load, requests wait in a queue. This is a direct consequence of our sequential processing architecture. While this ensures consistent output quality, it means that response times are not guaranteed to be instantaneous during peak periods. Developers should account for this latency in their user experience design.
Typical generation speed is roughly real-time for long texts, but short phrases may take a few seconds due to queue positioning. With a limit of 60 requests per minute per key, high-volume SaaS applications may need to implement intelligent batching or multiple API keys to maintain smooth user experiences.
Cost Implications
Web Speech API offers zero marginal cost per synthesis, but limits depend on the user’s device and browser. For notification-heavy SaaS platforms, this free model shifts processing load to the client, consuming battery and CPU during peak usage. Cloud TTS introduces a direct cost but guarantees consistent quality regardless of the end-user’s hardware.
Our pricing model charges $10 per 1 million characters, equating to $0.01 per 1,000 characters. Failed requests are free, ensuring you only pay for successful audio generation. This transparency allows SaaS teams to budget precisely for notification volumes without hidden fees or subscription tiers.
Free but Limited
The browser’s native engine consumes device resources, which can degrade performance for users on older hardware or during simultaneous app usage. While there is no direct monetary cost, the variability in voice quality and lack of programmatic control can lead to inconsistent user experiences across different platforms.
For high-volume notification services, relying on client-side synthesis means you cannot guarantee voice consistency or language support if the user’s browser lacks specific language packs. This unpredictability is often unacceptable for enterprise-grade interfaces where tone and clarity are critical.
- Zero direct cost per request
- Depends on user’s device CPU/Battery
- Inconsistent voice quality across browsers
Pay-Per-Use Cloud
Cloud TTS shifts the computational burden to our servers, ensuring uniform audio quality for every user. You receive an audio file via a simple API response, decoupling the synthesis process from the client’s capabilities. This allows for reliable, programmatic control over speed, format, and voice selection.
With a rate limit of 60 requests per minute per key, scaling is straightforward. Longer texts are split and joined seamlessly. The cost structure is linear: $10 per 1 million characters, with no minimum spend or monthly commitments, making it ideal for variable usage patterns.
- $0.01 per 1,000 characters
- $10 per 1 million characters
- Failed requests are free
Volume Discounts
- No monthly plans
- No minimum spend
- Balance does not expire

Use Cases for Replacement
Web Speech API is insufficient for production-grade SaaS notifications where consistent audio delivery is critical. Cloud TTS ensures reliable generation of alert sounds for user updates, independent of the client’s browser capabilities or network conditions.
Accessibility interfaces benefit from predictable voice qualities. Unlike variable browser engines, our API delivers consistent speech for screen readers, ensuring that critical information is conveyed clearly across all user devices without relying on local system voices.
Notification Services
Cloud TTS replaces inconsistent browser alerts with reliable, server-generated audio. This ensures that critical notifications are heard clearly, regardless of the user's device or browser version. It eliminates the variability of system voices, providing a uniform brand experience for alerts and updates.
Unlike client-side synthesis, cloud generation handles background processing efficiently. This reduces CPU load on the user's device, ensuring smooth application performance even during high-frequency notification events. The audio is delivered directly to the user, ready for immediate playback.
- Consistent alert tones across all browsers
- Reduced client-side CPU usage
- Reliable delivery for critical updates
Accessibility Interfaces
For accessibility, consistent voice quality is paramount. Cloud TTS provides stable, high-quality narration for screen readers, ensuring that users with visual impairments receive clear and predictable audio feedback. This consistency is difficult to achieve with the varying quality of built-in browser voices.
Our API allows precise control over speed and voice selection, enabling tailored experiences for different accessibility needs. This level of customization ensures that critical information is conveyed effectively, enhancing the overall usability of the SaaS product for all users.
- Predictable voice quality for screen readers
- Customizable speed and pitch
- Enhanced user experience for visually impaired users
Global SaaS Products
Global SaaS products require support for multiple languages without relying on users to have the correct language packs installed locally. Our API supports 23 languages, including less common ones, ensuring that users worldwide receive high-quality speech synthesis without additional setup.
Explicit language codes allow for precise control over speech generation, avoiding the ambiguity of auto-detection. This ensures that notifications and interface messages are delivered in the correct language, enhancing user satisfaction and reducing support queries related to audio playback issues.
- Support for 23 languages
- No need for local language packs
- Precise language code control
Integration Complexity
Moving from the browser's built-in speech synthesis to a cloud API requires minimal architectural change for most SaaS teams. The core shift is simply replacing the speechSynthesis object with standard HTTP POST requests. This abstraction removes browser-specific quirks and allows your backend to manage audio generation independently of the client device.
The API follows a request shape identical to major industry standards, meaning you can use existing OpenAI SDKs by just updating the base URL. This familiarity reduces onboarding time, as developers already understand the authentication and payload structure without learning a proprietary protocol.
Simple HTTP Calls
Integration relies on straightforward RESTful endpoints. You send text via JSON and receive the audio file directly. This simplicity means you do not need to manage complex WebSocket connections or handle partial streaming chunks if you prefer batch processing.
The endpoint accepts standard fields like model, voice, and input text. This predictability allows for easy integration into existing notification queues or user interface triggers without significant refactoring of your application logic.
- Standard JSON payload structure
- No custom protocol learning curve
- Direct audio file return
SDK Availability
While we do not offer a proprietary mobile or web SDK, the API is compatible with the official OpenAI SDKs. By pointing the SDK to https://api.playtop99.com/v1, you gain immediate access to robust, well-documented client libraries for Python, Node.js, and other languages.
This approach leverages existing developer familiarity. You avoid the maintenance overhead of a custom SDK.
- Compatible with OpenAI SDKs
- No custom SDK maintenance
- Wide language support
Error Handling
The API returns standard HTTP status codes for failures, such as 400 for invalid parameters or 429 for rate limits. Failed synthesis requests are free, so you can retry or degrade gracefully without incurring unnecessary costs.
Rate limits are set at 60 requests per minute per key. Implementing simple exponential backoff in your error handling logic ensures smooth operation even during sudden spikes in notification volume.
- Standard HTTP status codes
- Free retries on failure
- Predictable rate limits
Data Privacy Considerations
Web Speech API processes audio locally, keeping text within the user’s browser context. Cloud TTS moves synthesis to our servers, requiring data transmission over HTTPS. This shift centralizes storage of request metadata—such as timestamps, character counts, and status codes—necessary for accurate billing and usage tracking.
Client-Side Data
When using the browser’s native API, input text never leaves the client device. This minimizes exposure during transit but limits processing power to the user’s hardware, causing variable performance on lower-end devices.
- Text remains in local memory
- No network transmission required
- Dependent on user device capabilities
Server-Side Processing
Cloud synthesis sends text to our API endpoint for generation. We retain request metadata for billing purposes only. The generated audio is returned in the response and is not stored on our servers, ensuring minimal data retention after delivery.
- Metadata retained for billing
- Audio not stored post-response
- HTTPS encrypted transmission
Training Data Usage
Input text is used exclusively to produce the specific audio file requested. We do not use your submitted text or generated audio for training our models or improving the voice engine, ensuring your content remains proprietary to your application.
- Text used only for immediate synthesis
- No model training on user data
- Audio returned and discarded
Future Proofing
Cloud infrastructure allows us to update synthesis engines and voice models centrally without requiring client-side updates. Your SaaS notifications remain consistent regardless of the user’s browser version or operating system.
We handle the underlying infrastructure scaling, ensuring that new capabilities are available via simple API calls. This reduces the maintenance burden on your engineering team and keeps your product modern.
API Updates
We manage endpoint stability and versioning. Changes to the core engine are deployed server-side, so your integration code remains valid while benefiting from improved synthesis quality.
- Server-side engine upgrades
- Backward-compatible endpoint changes
Voice Additions
New voices can be added to the 8 presets or expanded as needed. Since voices are licensed recordings, we handle licensing and integration, making new options available immediately via the /v1/voices endpoint.
- New licensed voice releases
- Centralized voice management
Format Upgrades
Support for new audio formats like opus and flac is added as codec standards evolve. This ensures compatibility with modern web standards and efficient storage without requiring changes to your application logic.
- Expanded format support
- Efficient codec integration
Decision Matrix
Choosing between native synthesis and cloud TTS depends on specific architectural needs. While browser APIs offer zero-latency feedback for simple UI cues, they lack the consistency required for global SaaS notifications.
When to Keep Web Speech
Retain Web Speech API for lightweight, interactive elements where voice quality is secondary to instant response. It works well for simple, short-form UI prompts that do not require strict brand consistency or specific language support beyond major Western languages.
- Simple UI feedback cues
- Minimal latency requirements
- Low character volume
When to Switch to Cloud
Switch to our cloud API when you need consistent, high-quality audio across diverse languages and devices. Ideal for notification services requiring reliable delivery, precise voice presets (like aria or atlas), and predictable billing based on character count.
- Global SaaS notifications
- Consistent brand voice
- Multi-language support (23 languages)
- Predictable per-character billing
Hybrid Approaches
Use Web Speech for immediate, low-stakes interactions and reserve cloud synthesis for critical user-facing content. This balances the zero-cost advantage of browser APIs with the reliability and quality of server-side generation for important notifications.
- Fallback for errors
- High-priority alerts via cloud
- Low-priority cues via browser
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Your team receives seamless alerts directly within the unified interface for instant awareness and streamlined collaboration.
23 languages
Any voice speaks any of these languages.
Sources and further reading
- Wikipedia
- LibriTTS-R paper (arXiv 2305.18802)
- LibriVox public-domain audiobooks
- FFmpeg documentation
- IETF RFC 7845: Ogg Opus
- W3C WAI: making audio and video accessible
- curl documentation
- openai-node on GitHub
- MDN: Web Speech API
- Creative Commons Attribution 4.0
- ISO 639 language codes
- LibriTTS-R corpus (OpenSLR 141)
