Frequently asked questions
Is cloud TTS better than Web Speech API?
Cloud TTS offers consistent, high-quality audio files via API, whereas Web Speech API relies on the user’s browser engine. For production apps requiring reliable delivery and specific formats like MP3 or WAV, our cloud endpoint provides predictable results without browser dependency.
Can I use Web Speech API for production apps?
Web Speech API works well for simple prototypes but lacks consistency across browsers. For production, cloud TTS ensures uniform voice quality, supports 23 languages, and returns standard audio files. It also provides billing transparency; text splitting is handled by the client.
Why is cloud TTS more consistent?
Cloud TTS uses a dedicated engine (tts-1 or tts-1-hd) regardless of the user’s device. Web Speech API varies by browser and OS. Our API returns standardized audio files, ensuring the same voice and quality for every user, every time.
Does Web Speech API support all languages?
Web Speech API support depends entirely on the user’s browser and operating system. Our cloud API explicitly supports 23 languages including English, Spanish, and Japanese. You control the language parameter, ensuring consistent output even if the user’s browser lacks native support.
Can I download audio from Web Speech API?
Web Speech API typically returns audio as a stream for immediate playback and does not provide a downloadable file. Our cloud API returns an audio file (MP3, WAV, OPUS, FLAC, or PCM) in the response, allowing you to store, cache, or distribute the generated speech.
Is cloud TTS expensive for small projects?
Pricing is $0.01 per 1,000 characters. New accounts receive a free trial with $0.50 credit (approx. 50,000 characters) valid for 7 days. There are no monthly fees, so you only pay for what you use, making it ideal for small-scale projects.
Do I need a backend for Web Speech API?
Web Speech API runs directly in the browser using JavaScript, requiring no backend. Our cloud TTS API is called via HTTP requests from your frontend or backend. You can call it directly from the browser using your API key or via a proxy.
Which API is better for accessibility?
Both APIs support accessibility. Web Speech API is built into browsers for immediate use. Our cloud API provides consistent, high-quality synthetic speech across all devices. It supports 23 languages and returns standard audio files, which screen readers and assistive technologies handle reliably.
Can I customize Web Speech API voices?
Web Speech API voices depend on the user’s installed system voices. Our cloud API offers 8 curated presets (e.g., Aria, Nova, Felix) with consistent quality. You can adjust speed (0.25–4.0) and select from 5 audio formats, ensuring uniform experience for all users.
How does latency compare between the two?
Web Speech API generates audio in real-time within the browser. Cloud TTS processes requests on our servers; short phrases take a few seconds, while long texts generate at roughly real-time speed (about 25 characters per second). Under load, requests may queue, but results are consistently delivered.
Is Web Speech API available in all browsers?
Web Speech API support varies by browser and version. Our cloud API works in any environment that can make HTTP requests. It is not tied to browser capabilities, ensuring your voice feature works for all users regardless of their specific browser version.
Can I use both APIs in one app?
Yes. Use Web Speech API for quick, local previews and our cloud API for final, high-quality audio delivery. This hybrid approach leverages browser-native speed for testing while ensuring consistent, downloadable audio for end-users via our reliable REST API endpoint.
Which API has better voice quality?
Cloud TTS uses licensed recordings from LibriTTS and delivers consistent, high-fidelity audio files. Web Speech API quality varies by the user’s OS and browser. Our voices (e.g., Aria, Atlas) are designed for clarity and realism, providing a uniform experience across all devices.
Do I need an API key for Web Speech API?
No, Web Speech API works directly in the browser without authentication. Our cloud API requires a Bearer token (tts-...) for each request. You generate this key in your account dashboard, and it enables usage tracking and billing for your generated audio.
Defining Cloud TTS API
A cloud TTS API generates speech on remote servers rather than within the browser. You send text via HTTP POST to an endpoint, and the server returns an audio file. This shifts the processing load away from the user’s device, ensuring consistent performance regardless of the device's capabilities.
Server-side speech generation
Unlike browser-based synthesis, cloud processing happens on dedicated infrastructure. This allows for higher-quality voice engines and faster generation times for long texts. The client simply receives the final audio file, eliminating the need to manage complex browser state or background tabs.
- Endpoint: POST https://api.playv57.com/v1/audio/speech
- Returns standard audio formats (mp3, wav, opus)
- Handles up to 4096 characters per request
Consistent output quality
Quality remains uniform across all devices. Whether a user is on a high-end desktop or a low-end mobile phone, they receive the same audio file generated by the same engine. This eliminates the variability where the same text sounds different depending on the browser engine (Chromium vs. WebKit).
Programmatic access
Access is entirely via JSON requests. You can integrate the API directly into backend workflows, cron jobs, or mobile apps using standard HTTP libraries. This makes it easier to build automated voice features without relying on browser-specific JavaScript APIs.
Defining Web Speech API
The Web Speech API is a browser-based synthesis tool built directly into modern web browsers. It allows developers to generate speech using JavaScript without requiring external servers or API keys. This makes it ideal for lightweight, client-side features where simplicity is prioritized over consistency.
Browser-based synthesis
Speech generation happens locally on the user’s device. The browser handles the processing, meaning there are no network requests to a third-party server for audio synthesis. This reduces latency for simple read-aloud features and works offline if the browser caches the necessary engines.
Dependent on browser engine
The available voices and their quality depend entirely on the user’s browser and operating system. A voice that sounds natural in Chrome on Windows may sound robotic in Safari on macOS. There is no guarantee of consistent audio quality across different devices or browsers.
Limited format options
Unlike cloud APIs, the Web Speech API does not allow you to choose output formats like MP3, WAV, or FLAC. It typically returns audio as a stream for immediate playback. You cannot easily download or store the generated audio file without complex workarounds.
Key Differences
The Web Speech API relies on the user’s operating system and browser engine, meaning voice quality and language support vary significantly between Chrome, Firefox, Safari, and different devices. A voice that sounds natural on a desktop may sound robotic or unavailable on a mobile browser.
Voice consistency across devices
Cloud TTS ensures uniform audio output regardless of the client device. Since synthesis happens on our servers, your users receive the same voice quality whether they are on Windows, macOS, Android, or iOS, eliminating the fragmentation inherent in browser-based solutions.
Control over audio format
The Web Speech API typically returns audio via streaming or limited formats constrained by the browser’s capabilities. Our API lets you explicitly request MP3, WAV, Opus, FLAC, or PCM, giving you full control over file size, compatibility, and playback behavior in your application.
Reliability for production use
Browser engines update frequently, which can silently break speech synthesis features in your app. A cloud API provides a stable, versioned endpoint (/v1/audio/speech) that remains consistent over time, ensuring your voice features do not degrade after a browser update.
Use Cases for Cloud TTS
Cloud TTS excels in scenarios requiring consistent, high-quality audio delivery independent of the user's device. Unlike browser-based synthesis, our API generates audio on the server, ensuring that an e-book narrator sounds identical whether accessed via iOS, Android, or desktop.
This reliability supports automated notifications and voice assistants where brand voice must remain uniform. By controlling the output format and speed, developers can integrate voice features into web apps without worrying about local engine variations.
E-book narration
For indie developers building e-reader apps, consistent voice quality is crucial for immersion. Our API provides licensed voices like Luna for storytelling or Atlas for news, delivering clear audio files that play smoothly across all devices without relying on the user's operating system voice engine.
Since texts are split into 4096-character parts and joined, long books generate as a sequence of audio files. The inaudible watermark marks the file as synthetic speech.
- Supports 23 languages including English, Spanish, and Japanese
- Licensed voices from LibriTTS-R and LibriVox
- Consistent output across all platforms
Voice assistants
Voice assistants require predictable latency and tone. With speeds adjustable from 0.25x to 4.0x, you can tune the delivery to match your brand's personality, whether it's Felix for energetic prompts or Orion for deep, documentary-style responses.
Since the API returns standard audio formats like MP3 or WAV, integration is straightforward. You control the exact voice and language, avoiding the surprise of a system voice changing when a user updates their phone's OS.
- Adjustable speed for natural pacing
- 8 distinct voice presets
- Programmatic control over tone
Automated notifications
For transactional emails or app alerts, you need reliable audio generation that doesn't depend on the user's browser. Cloud TTS ensures the notification audio is generated instantly and delivered in the requested format.
Failed requests are free, so you can retry notifications without incurring extra costs. This makes it ideal for critical alerts where missing the audio cue due to a browser limitation is not an option.
- Reliable generation independent of client device
- Free retries on failure
- Supports urgent, clear voices like Sage
Use Cases for Web Speech API
The Web Speech API is built directly into modern browsers, allowing you to add read-aloud functionality without any external dependencies or network requests. It is ideal for simple pages where you just need to speak text to the user.
Since it uses the operating system’s default voices, it requires no setup code beyond a few lines of JavaScript. This makes it perfect for quick prototypes or lightweight demos where reliability and consistency are not critical.
Simple web page read-aloud
You can add a button that triggers speech synthesis using just a few lines of JavaScript. The browser handles the audio playback internally, so there is no need to manage audio files or wait for API responses.
This approach works well for short texts like menu items or brief instructions. Since the audio is generated on the client side, it feels instant to the user, even on slow connections.
- No network latency
- Zero additional cost
- Instant playback
Accessibility features
Browsers already provide built-in support for speech synthesis, which can help improve accessibility for users with visual impairments. You can enable text-to-speech for articles or documentation with minimal effort.
However, the voice quality depends on the user’s device. A Windows user might hear a different voice than a macOS user, which can be inconsistent but is free and always available.
Lightweight demos
When building a prototype or a demo for a client, you often want to show voice features without setting up a backend. The Web Speech API lets you do this in a single HTML file.
It is perfect for showcasing ideas quickly. You do not need to worry about API keys, rate limits, or character counts, making it the go-to choice for rapid development and testing.
Technical Comparison
Web Speech API operates client-side via JavaScript, leveraging the browser’s native engine. Cloud TTS uses standard HTTP POST requests to a remote endpoint, returning audio files in formats like MP3 or WAV.
Request method differences
The Web Speech API is invoked directly in the browser, while the cloud API requires sending a JSON payload to https://api.playv57.com/v1/audio/speech. The cloud method allows for precise control over voice selection and speed via headers.
- Client-side JS vs. Server-side HTTP POST
- JSON payload with
modelandvoicefields - Standard Bearer token authentication
Latency considerations
Browser synthesis is nearly instant but limited by device CPU. Cloud generation takes a few seconds for short phrases, processing requests sequentially. Under load, queueing may occur, with typical speed at roughly 25 characters per second.
- Instant playback vs. generation delay
- Sequential processing under load
- Real-time generation ratio
Resource usage
Web Speech API consumes device battery and memory for playback. Cloud TTS offloads processing to servers, sending small audio files to the client. This reduces client-side CPU usage but increases network data transfer.
- Device CPU load vs. server processing
- Network bandwidth for audio files
- Battery impact on mobile devices
Voice Quality
The Web Speech API relies on the operating system’s built-in engines, meaning voice quality shifts between Windows, macOS, and Android. A voice that sounds natural on Chrome may sound robotic or robotic on Safari, creating an inconsistent user experience that is hard to predict during development.
Cloud voices are licensed
Our API uses voices derived from licensed recordings and public-domain audiobook readings, ensuring a consistent, professional tone across all requests. Every generated file carries an inaudible watermark, marking it as synthetic speech without affecting audio fidelity.
- Voices include aria, nova, luna, sage, felix, milo, atlas, and orion.
Web voices vary by OS
Browser-based synthesis depends entirely on the client’s device. If the user switches platforms, the voice character changes, which can break immersion in e-books or consistent brand audio. There is no way to enforce a specific voice engine from your code.
Consistency matters
For production apps, consistent voice quality ensures your users hear exactly what you intended, regardless of their device. Cloud TTS eliminates the variability of local OS engines, providing uniform audio output for automated notifications or voice assistants.

Language Support
The Cloud TTS API supports 23 specific languages, including Arabic, Chinese, and Swahili, ensuring consistent synthesis regardless of the user's device. Unlike browser-based engines that depend on installed OS voices, our API guarantees the same voice quality for every request.
Cloud API supports 23 languages
Our API covers major global languages, from English and Spanish to Hindi and Turkish. This list is fixed; if a language is not listed, it is not supported. Every voice can speak any of these 23 languages, providing uniformity across your application.
Web Speech API varies by browser
Browser-based synthesis relies on the user's operating system and browser version. A feature working in Chrome on Windows may fail on Safari on macOS or Android. This variability makes it difficult to guarantee a consistent user experience across different devices.
Explicit language setting
For non-English Latin-script text, you must explicitly set the language parameter. Without it, the API guesses the language, defaulting to English for Latin script. This prevents mispronunciation and ensures accurate synthesis for mixed-language content.
- Supported: Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, Turkish
- Not supported: Vietnamese, Indonesian, Thai, Ukrainian, Romanian, Czech, Bengali
Cost Implications
Browser-based speech synthesis incurs no direct monetary cost, as the processing happens on the user’s device using existing OS resources. This makes it ideal for zero-budget prototypes or features where volume is negligible. However, the trade-off is a lack of format control and consistency, as output quality depends entirely on the visitor’s browser and operating system.
In contrast, our cloud API charges $0.01 per 1,000 characters, with a minimum top-up of $5 via USDT (TRC-20). Failed requests are free, and you only pay for what you generate. This predictable per-character model allows indie developers to forecast expenses accurately as user bases grow, avoiding the hidden costs of inconsistent quality or limited device compatibility found in free browser alternatives.
Cloud API has a per-character cost
We charge $10 per 1 million characters processed. This flat rate applies regardless of voice or speed, making budgeting straightforward. You receive $0.50 in trial credit for 7 days when signing in with Google, covering roughly 50,000 characters.
Top-ups are handled exclusively via USDT on the TRON network (TRC-20), with a minimum deposit of $5. Credits appear in your balance automatically within minutes. There are no monthly subscriptions, hidden fees, or VAT invoices to manage.
- $0.01 per 1,000 characters (including spaces and punctuation)
- Minimum top-up: $5 USDT (TRC-20)
- Failed requests are refunded in full
- No monthly plans or expiration
Web Speech API is free
The Web Speech API uses the device’s built-in synthesizer, so there is no per-request fee. Your server does not handle the audio generation, keeping infrastructure costs low.
This model works well for simple read-aloud buttons or accessibility overlays where audio quality variations between Chrome, Safari, or Firefox are acceptable. However, you lose control over audio formats and voice consistency.
- No monetary cost
- Processing occurs on the client device
- Quality varies by browser and OS
Scaling costs
As your user base grows, cloud API costs scale linearly with usage. With a rate limit of 60 requests per minute per key, high-volume applications may need to manage queuing.
For indie developers, the predictability of per-character billing often outweighs the variability of free browser solutions, especially when consistent brand voice and reliable audio formats like MP3 or WAV are required for production apps.
Integration Complexity
Integrating cloud TTS involves standard HTTP requests, while browser synthesis relies on native JavaScript APIs. The cloud approach requires handling authentication, parsing JSON responses, and managing audio file downloads or playback streams. This adds initial boilerplate but offers predictable behavior across all environments.
Web Speech API integration is immediate. Developers call a single function with text and voice parameters. There is no network overhead, no authentication headers, and no file management. The browser handles all processing locally, making it ideal for quick prototypes or simple UI enhancements where setup time is the primary constraint.
Cloud API requires HTTP calls
You must construct POST requests to the endpoint with your API key in the header. The response returns an audio file that you then decode and play. This requires managing network errors, retries, and potentially buffering large responses for longer texts.
Authentication is handled via a Bearer token. You need to store your key securely and handle potential rate limits or quota errors explicitly in your code logic.
- POST request to /v1/audio/speech
- Authorization: Bearer token required
- JSON response with audio data
- Manual error handling for network issues
Web Speech API uses JavaScript
The API is built into modern browsers. You instantiate a SpeechSynthesisUtterance object and pass it to the speechSynthesis object. It works out of the box without external libraries or network configuration.
Voice selection is done by filtering the available voices list provided by the browser. There is no network latency, but voice availability depends entirely on the user’s operating system and browser version.
- SpeechSynthesisUtterance object
- No network calls required
- Native browser support
- Immediate execution
Setup time comparison
Cloud API setup takes longer due to API key generation, base URL configuration, and request parsing logic. However, once configured, it provides consistent results across all user devices.
Web Speech API setup is nearly instant. You can have a working read-aloud feature in minutes. The trade-off is less control over voice selection and audio format options.
When to Choose Cloud
Web Speech API quality shifts with the user’s device and browser, making results unpredictable for end users. Cloud synthesis delivers identical audio files regardless of the client environment. This stability is vital when the voice is part of your product’s brand identity or when consistency affects user trust.
You control the output format, speed, and language explicitly. There is no guessing which browser engine renders the audio. The API returns standard files like mp3 or wav, ensuring compatibility across all web players and devices without relying on client-side capabilities.
When consistency is critical
Browser voices vary by OS, version, and hardware. A voice that sounds natural on Chrome may sound robotic on Safari. Cloud TTS generates audio server-side, delivering a uniform experience to every user. This eliminates the 'browser lottery' where quality depends on the client.
For applications like e-book narration or voice assistants, consistent tone and pacing are required. Cloud APIs ensure that the voice remains stable across thousands of different devices, preventing jarring changes in quality that distract users.
- Identical audio output for all users
- No dependency on client-side browser engines
- Stable brand voice across platforms
When format control is needed
Web Speech API outputs are tied to the browser’s internal decoder, limiting format options. Cloud APIs let you choose mp3, wav, opus, flac, or pcm. You can optimize file sizes or ensure compatibility with legacy players by selecting the exact format needed.
This control extends to speed and language. You can set precise speeds between 0.25x and 4.0x and explicitly define the language code. This prevents the browser from guessing incorrectly, especially for non-English Latin text.
- Choose from mp3, wav, opus, flac, or pcm
- Set exact speed and language parameters
- Optimize for storage or playback compatibility
When scaling is planned
Browser synthesis consumes client CPU and battery. As your user base grows, the load shifts to their devices. Cloud offloads this processing to your servers. Each request is processed in the cloud, keeping the client lightweight and responsive.
With a clear per-character pricing model ($0.01 per 1,000 characters), you can predict costs as usage grows. Failed requests are free, and you can manage limits via API keys. This transparent model supports predictable scaling without hidden browser resource costs.
- Offload processing to servers
- Predictable per-character pricing
- Free failed requests reduce waste
When to Choose Web Speech
The Web Speech API offers a straightforward, client-side solution for basic text-to-speech needs. It requires no backend infrastructure, making it ideal for simple read-aloud features where audio generation happens directly in the user’s browser. This approach minimizes latency for short texts and eliminates server costs entirely.
For developers building zero-cost prototypes or lightweight demos, the API provides immediate functionality with minimal code. It is particularly useful for accessibility features or simple web page enhancements where consistent voice quality across devices is not a primary concern. The lack of format control and variable voice quality across operating systems is an acceptable trade-off for its simplicity and zero marginal cost.
For simple read-aloud features
The Web Speech API allows you to implement read-aloud functionality with just a few lines of JavaScript. It integrates seamlessly into existing web pages without requiring API keys, authentication, or network requests to a server. This makes it perfect for adding basic accessibility features to blogs or documentation sites where voice consistency is secondary to ease of implementation.
For zero-cost prototypes
Since the Web Speech API is built into modern browsers, there are no per-character costs or monthly fees. This makes it an attractive option for prototyping voice features in web apps without incurring infrastructure expenses. Developers can test user interaction patterns with speech synthesis before committing to a more robust, paid cloud solution.
For broad compatibility
The API is supported by most major browsers, including Chrome, Firefox, Safari, and Edge. While voice quality and available voices may vary by operating system and browser version, the core functionality remains consistent. This broad compatibility ensures that your application works across different devices without needing to manage multiple backend services or handle complex audio format conversions.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Creating games alone is hard work but the freedom to follow your creative vision makes every late night worth it.
23 languages
Any voice speaks any of these languages.
