Frequently asked questions
What is the difference between TTS and speech synthesis?
Text-to-Speech (TTS) and speech synthesis are synonymous terms for the same technology. Our API converts input text into audible audio files via a simple POST request. It processes your text and returns the synthesized speech without distinguishing between the two concepts in its documentation or pricing model.
Does the API store my text after generation?
No. Input text is used only to produce the audio and is not used for training. Generated audio is returned in the response and not stored. Only request metadata, such as time, character count, and status, is kept for billing purposes.
Can I use TTS for commercial apps?
Yes. The API is designed for integration into iOS and Android apps. Voices are based on licensed recordings from LibriTTS-R (CC BY 4.0) and LibriVox public-domain audiobook readings. You can generate audio for commercial use without additional licensing fees beyond the character-based pricing.
How is the audio generated?
Audio is generated via a cloud API. You send text via a POST request to the endpoint, and receive an audio file. Longer texts are split into parts of up to 4096 characters and joined. Each file carries an inaudible watermark marking it as synthetic speech.
Is the API real-time?
No. It is not real-time or streaming. Requests are processed one after another. Typical speed is roughly real-time on long texts, but short phrases take a few seconds. Under load, a request may wait in a queue before processing begins.
What languages are supported?
We support 23 languages: Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, and Turkish. Any voice can speak any of these languages. Vietnamese, Indonesian, and Thai are not supported.
Do I need a server to use the API?
No. It is a cloud API. You send text via HTTP requests and receive audio files. You do not need to manage infrastructure or run a server to use the service. Simply integrate the API call into your mobile app using the official OpenAI SDK or HTTP client.
Can I generate audio offline?
No. The API requires an internet connection to send requests to the cloud endpoint and receive the audio file. There is no offline mode or local engine. You must have network connectivity to generate speech, as the processing happens on our servers.
What is SSML?
SSML (Speech Synthesis Markup Language) is not supported by this API. We do not offer SSML tags for controlling pronunciation, pauses, or emphasis. You control speech characteristics using the voice, speed, and language parameters in the JSON request body.
Are the voices robotic?
Voices are based on licensed recordings from LibriTTS-R and LibriVox public-domain audiobook readings. They are natural-sounding but carry an inaudible watermark marking them as synthetic speech. They are not celebrity clones but professional, licensed presets designed for clear and natural audio output.
How accurate is the French pronunciation?
French is one of the 23 supported languages. Any of the 8 voices can speak French accurately. If the language field is not set, the API guesses the language from the script; for French, you should explicitly set language: "fr" for best results.
Can I change the speed of the voice?
Yes. You can adjust the speed parameter in the request body. The acceptable range is 0.25 to 4.0. This allows you to slow down or speed up the speech synthesis to fit your app’s user experience requirements without changing the voice preset.
What happens if the internet disconnects?
If the internet disconnects, the API request will fail. Failed requests are free, and the charge is returned in full. You can retry the request once connectivity is restored. There is no partial audio generation stored locally; you must resend the text.
Is the API secure?
The API uses standard Bearer token authentication via the Authorization header. Input text is not used for training, and generated audio is not stored. Request metadata is kept for billing. There is no SLA, uptime guarantee, or specific certification like SOC 2 or HIPAA.
Definition of a TTS API
A Text-to-Speech API is a cloud-based service that converts written text into audible audio files. For mobile developers, it eliminates the need to manage local speech synthesis engines or handle complex audio formats directly on the device.
The system processes input text through a synthesis engine and delivers the result via standard HTTP responses. This allows iOS and Android apps to generate high-quality narration on demand without storing large voice assets locally.
Text Input Processing
The API accepts plain text strings via a JSON body, with a limit of 4,096 characters per request. Developers send this data to the POST https://api.playk444.com/v1/audio/speech endpoint, optionally specifying a language ISO code to ensure accurate pronunciation for non-English Latin scripts.
- Max 4,096 characters per request
- JSON body format
- Optional language code support
Audio Synthesis Engine
The engine uses licensed recordings from LibriTTS-R (CC BY 4.0) and LibriVox public-domain audiobooks to generate speech. It supports eight distinct voice presets, such as Aria and Nova, across 23 languages. Each generated file includes an inaudible watermark to identify it as synthetic speech.
- LibriTTS-R and LibriVox sources
- 8 voice presets
- Inaudible watermark included
HTTP Response Delivery
The API returns the audio file directly in the HTTP response body, supporting formats like MP3, WAV, OPUS, FLAC, and PCM. Developers authenticate using a Bearer token (tts-...) and receive the audio synchronously, allowing immediate playback or storage in the app.
- Synchronous HTTP response
- Multiple audio formats
- Bearer token authentication
How Mobile Apps Use TTS
For freelance mobile developers, integrating VoiceScope into iOS or Android apps shifts voice synthesis from the device to the cloud. This approach offloads processing power, ensuring consistent audio quality across diverse hardware without bloating the app bundle.
Mobile apps typically trigger synthesis on demand, sending text via JSON to the API endpoint. The generated audio is then streamed or saved for playback, allowing dynamic content generation based on user actions or real-time data feeds.
On-Demand Generation
Apps send text to the API only when needed, such as when a user taps a "Listen" button. This conserves bandwidth and battery life compared to pre-downloading large audio files for every possible text string.
- Trigger synthesis during user interactions
- Send text via POST requests
- Receive audio in MP3 or WAV format
Caching Strategies
To minimize costs and latency, developers can cache frequently used audio responses locally on the device. Since the API returns audio files that are not stored server-side, caching ensures immediate playback for repeated phrases.
- Store generated audio locally
- Reduce API calls for static content
- Improve playback speed for common phrases
Real-Time User Interaction
With generation times of a few seconds for short phrases, apps can provide immediate audio feedback. For longer texts, the API processes requests sequentially, so queuing may occur under load, requiring careful UI design to manage user expectations.
- Provide instant audio feedback for short texts
- Handle queue delays for longer content
- Maintain responsive UI during synthesis
Technical Workflow Overview
The workflow begins when your mobile client constructs a JSON payload and sends it via HTTP POST to the API endpoint. This request includes the text to be synthesized, the chosen voice preset, and the desired audio format, adhering to the standard OpenAI-compatible request shape.
Once the server receives the request, it validates the authentication key and checks available balance. The synthesis engine then processes the text, generating the audio file according to the specified parameters before returning the result.
Client Sends JSON
Your app sends a POST request to https://api.playk444.com/v1/audio/speech with a JSON body. Essential fields include model ("tts-1" or "tts-1-hd"), input (the text string up to 4096 characters), voice (one of the 8 presets like 'aria' or 'nova'), and response_format (mp3, wav, opus, flac, or pcm).
- Endpoint: POST /v1/audio/speech
- Auth: Bearer <your-key>
- Max input: 4096 characters
Server Processes Request
The API validates your bearer token and checks that your account has sufficient balance. If the request is valid, the synthesis engine converts the text into speech using the selected voice and language settings. Requests are processed sequentially, so high load may introduce a queue delay.
- Rate limit: 60 req/min
- Processing: Sequential queue
- Validation: Auth & balance
Audio File Returned
The server returns the generated audio file in the specified format within the HTTP response. If synthesis fails, the request is free and no charge is applied. You can then play the audio directly in your app or cache it for later use.
- Response: Audio file data
- Failed requests: Free
- Formats: MP3, WAV, OPUS
Voice Selection in TTS Systems
Voice selection determines the auditory character of generated speech. Unlike custom voice cloning, which requires uploading recordings, our system uses eight fixed presets derived from licensed LibriTTS-R and LibriVox sources. These presets offer consistent quality without the need for training data or voice design workflows.
Presets vs Cloning
The API provides eight distinct voice presets rather than allowing users to clone their own voice. Each voice is based on licensed recordings, ensuring legal clarity and consistent tone. This approach eliminates the complexity of managing custom voice models while delivering high-quality, natural-sounding speech.
- No voice cloning required
- Licensed source material
- Consistent audio quality
Voice Attributes (Aria, Nova)
Voices are categorized by tone and use case. Aria offers a warm, clear narrator style ideal for long-form content. Nova provides a bright, upbeat delivery suitable for promotional material. Other presets like Luna (soft storytelling) and Atlas (neutral news) allow precise matching to app context.
- Aria: warm narrator
- Nova: bright upbeat
- Luna: soft storytelling
- Atlas: neutral news
Language Compatibility
Each of the eight voices can speak any of the 23 supported languages, including English, Spanish, Japanese, and Arabic. If the language parameter is omitted, the system guesses the language based on the script, defaulting to English for Latin text. Explicitly setting the language ensures accuracy for non-English Latin-script content.
- 23 supported languages
- Multi-lingual voice capability
- Automatic language detection
Audio Formats Explained
The API supports multiple output formats to balance file size, quality, and playback compatibility. Developers choose between lossy compression for efficiency or uncompressed quality for editing, depending on their app’s specific needs and device constraints.
MP3 Compression
MP3 is the most widely supported format across iOS and Android devices. It offers a good balance between audio quality and file size, making it ideal for general app usage where bandwidth conservation matters without sacrificing clarity.
- Universal playback support
- Small file sizes
- Standard for most mobile apps
WAV Uncompressed
WAV provides raw, uncompressed audio data. This format ensures maximum fidelity, which is useful for professional editing or when the app requires lossless playback. The trade-off is significantly larger file sizes compared to compressed options.
- Lossless quality
- Larger file size
- Ideal for post-production
OPUS Efficiency
OPUS delivers excellent compression efficiency, often resulting in smaller files than MP3 for similar perceived quality. It is useful when minimizing bandwidth consumption is a priority. Superior compression for long texts Supports high-quality audio at low bitrates.
- High compression ratio
- Low bandwidth usage
- High quality at low bitrates
Latency and Performance
Understanding latency is critical for mobile developers balancing user experience with generation costs. VoiceScope’s architecture processes requests sequentially, meaning performance depends on current load and text length. Knowing these mechanics helps you design smoother app interactions.
Generation Time
Synthesis typically runs at roughly real-time speed, generating about 25 characters of text per second of audio. Short phrases may take a few seconds, while longer texts scale linearly. This predictable rate allows developers to estimate processing duration accurately.
Network Transfer Speed
Audio files are returned directly in the HTTP response. The format choice (MP3, WAV, OPUS, FLAC, PCM) affects download size. MP3 and OPUS offer the best balance for mobile bandwidth, reducing data usage while maintaining acceptable quality.
Queue Impact
Requests are processed one after another, so high traffic can introduce wait times. During peak loads, your synthesis job may sit in a queue before processing begins. Implementing retry logic or background generation prevents UI blocking.
Cost Implications of TTS APIs
Understanding the financial model is critical for mobile app developers budgeting TTS features. VoiceScope uses a straightforward character-based billing system, eliminating complex tier ambiguities. This approach allows precise cost forecasting based on expected user interactions.
The pricing structure is transparent and predictable. With a flat rate, developers can easily calculate expenses for specific features like accessibility read-aloud buttons or content monetization, ensuring no surprise overages during peak usage periods.
Character-Based Billing
The standard rate is $10 per 1 million characters, equating to $0.01 per 1,000 characters. Spaces and punctuation count toward the total. Failed requests are free, with the charge returned in full if synthesis fails.
This model scales linearly with usage. For a mobile app generating 100,000 characters monthly, the cost is $1.00.
- $10 per 1,000,000 characters
- $0.01 per 1,000 characters
- Failed requests are free
Volume Discounts
VoiceScope does not offer tiered volume discounts; the per-character rate remains constant regardless of usage volume. This simplicity avoids the administrative overhead of negotiating custom contracts or managing tier transitions.
There are no monthly subscriptions, seats, or minimum spend requirements. You only pay for what you generate, making it ideal for apps with variable traffic patterns or seasonal usage spikes.
Trial Credits
New accounts signing in with Google receive $0.50 in trial credit, valid for 7 days. This allows approximately 50,000 characters of generation, sufficient for testing integration workflows without immediate payment setup.
Accounts created with email and password start without trial credit. Top-ups are available via USDT on the TRON network (TRC-20) with a minimum of $5, credited automatically within minutes.
- $0.50 trial credit (Google sign-in)
- ~50,000 characters valid 7 days
- Email sign-up starts at $0

Integration Complexity
Integrating VoiceScope into iOS or Android applications is straightforward because the API follows the same request shape as the OpenAI speech endpoint. You can use the official OpenAI SDKs simply by changing the base_url to https://api.playk444.com/v1, avoiding the need to build custom HTTP clients for JSON serialization and multipart handling.
This approach reduces boilerplate code significantly, allowing freelance developers to focus on app logic rather than networking details. The consistent structure ensures that existing TTS knowledge transfers directly to VoiceScope’s infrastructure.
HTTP vs WebSocket
VoiceScope uses standard HTTP POST requests, not WebSocket streams. This simplifies integration for mobile apps that prefer synchronous, reliable request-response cycles over managing persistent connections.
Since streaming is not supported, you receive the complete audio file in the response body. This is suitable for most on-demand use cases where users trigger speech generation via button taps rather than continuous live transcription.
- - Synchronous POST requests for predictable delivery
- - No persistent WebSocket connection required
- - Full audio file returned in the response body
SDK Availability
There is no proprietary VoiceScope SDK; instead, the API is compatible with the official OpenAI SDKs. This means you can use well-documented libraries already available for Swift, Kotlin, and other mobile languages.
By setting the base_url to https://api.playk444.com/v1, you leverage existing authentication and serialization logic. This reduces development time and ensures compatibility with standard mobile networking stacks.
- - Compatible with official OpenAI SDKs
- - No proprietary SDK needed
- - Standard JSON request format
Error Handling
The API returns standard HTTP status codes to indicate success or failure. Failed synthesis requests are free, ensuring you are not charged for errors.
You should implement retry logic for transient network issues, but note that requests are processed sequentially, so high load may cause delays rather than immediate failures.
- - Standard HTTP status codes for errors
- - Failed requests are free
- - Sequential processing may cause queue delays
Data Privacy in TTS
VoiceScope’s architecture is designed for minimal data footprint. When you send text to our API, the input is processed solely to generate the audio response. We do not retain the original text beyond what is necessary for billing verification, ensuring your source content remains private.
Text Storage Policy
Input text is used exclusively for synthesis and is not stored long-term. Only request metadata—such as timestamp, character count, and status—is retained for billing and usage tracking. This ensures transparency without keeping your actual content.
Audio Retention
Generated audio files are streamed directly to your client in the HTTP response and are not stored on our servers. Once the transfer completes, the audio data is gone, reducing your dependency on external storage for immediate playback needs.
Training Data Usage
We do not use your input text or generated audio to train our models. Your content remains yours, free from being repurposed for improving our engine, which is critical for protecting proprietary app content or sensitive user data.
Common Use Cases
Text-to-Speech APIs enable mobile apps to convert static text into natural audio, enhancing user experience without requiring native device dependencies. By integrating a cloud API, developers offload the computational heavy lifting of audio synthesis to a reliable server, ensuring consistent quality across iOS and Android devices.
This approach is particularly valuable for content-heavy applications where audio augmentation increases engagement and accessibility. Developers can seamlessly embed audio generation into existing workflows, supporting diverse use cases from reading assistance to interactive learning modules.
Accessibility Features
Mobile apps can leverage TTS to support users with visual impairments or reading difficulties. By converting articles, menus, or notifications into speech, apps become more inclusive without requiring complex native implementations.
The API supports 23 languages, allowing apps to serve diverse user bases globally. With voices like Aria and Nova, developers can choose a tone that matches their app’s brand while ensuring clarity for listeners.
- Supports screen readers and audio navigation for visually impaired users
- Enables multilingual support across 23 languages without additional native code
- Reduces cognitive load for users who prefer listening over reading
Content Monetization
Developers can transform written content, such as blog posts or e-books, into audio formats, creating new revenue streams. Users may pay for premium audio content or access it via subscriptions, increasing the app’s value proposition.
The character-based pricing model ($10 per million characters) allows developers to scale costs directly with usage. This transparency helps in forecasting expenses for content-heavy apps without hidden fees or minimum commitments.
- Converts text articles into audio for premium subscription tiers
- Enables audio versions of e-books or newsletters for on-the-go consumption
- Transparent pricing aligns costs directly with content volume and user engagement
Language Learning
Language learning apps can provide instant pronunciation examples for vocabulary words or phrases. Users hear native-like speech in 23 languages, aiding in accent reduction and listening comprehension.
The API’s speed control (0.25–4.0) allows learners to adjust playback speed for better understanding. Combined with high-quality voices like Sage or Orion, it offers a realistic auditory reference for language practice.
- Provides instant pronunciation examples for vocabulary and phrases
- Adjustable speed (0.25–4.0) aids in listening comprehension and accent practice
- Supports 23 languages, enabling diverse language learning modules within a single app
Future of TTS APIs
The TTS landscape is rapidly evolving. Current systems prioritize stable, high-fidelity synthesis, but developers increasingly demand real-time streaming to eliminate buffering delays in interactive mobile apps. This shift would allow audio to play as it is generated, rather than waiting for the entire file to arrive.
Beyond basic text-to-audio conversion, the industry is moving toward nuanced emotional delivery and personalized voice models. These advancements aim to make synthetic speech feel less robotic and more tailored to specific brand identities or user preferences.
Real-Time Streaming
While our API currently returns complete audio files, the industry trend is toward WebSocket-based streaming. This allows partial audio chunks to be sent immediately, reducing perceived latency for users in voice-call or chat applications.
Currently, we do not offer streaming, but the underlying infrastructure supports high-throughput generation that minimizes wait times for short phrases.
- Current response is a complete file.
Emotion Control
Modern TTS systems are beginning to integrate emotion tags, allowing developers to specify 'happy,' 'sad,' or 'urgent' tones. This adds a layer of expressiveness that static voice presets cannot provide.
Our current 8 presets deliver distinct character tones (e.g., 'warm' for Aria, 'energetic' for Felix), but fine-grained emotion control is not yet supported.
Custom Voices
Voice cloning technology is becoming standard, enabling brands to replicate specific human voices. This allows for unique, branded audio experiences without recording new sessions.
VoiceScope uses licensed recordings from LibriVox. We do not offer custom voice cloning for customers; all voices are fixed presets available to all users.
- Custom cloning is not offered.
- Voices are licensed, not user-generated.
Why Choose a Cloud API?
Cloud APIs shift the burden of audio synthesis infrastructure from your mobile devices to dedicated servers. This eliminates the need to manage server capacity, storage, or compute resources for handling TTS workloads, allowing freelance developers to focus on app logic and user experience rather than backend maintenance.
No Infrastructure Management
You simply send text via HTTP and receive audio. There is no need to provision servers, configure environments, or handle scaling logic for sudden usage spikes. The API handles the heavy lifting, letting you integrate TTS with minimal code changes.
Scalability
As your app grows, the API handles increased request volume without requiring architectural changes. Whether you have ten users or ten thousand, the backend adjusts automatically. You only pay for the characters you consume, ensuring costs align directly with usage.
Regular Updates
Voice models and formats improve on the server side without requiring app updates on user devices. You automatically benefit from new voice presets, language support, and efficiency improvements as soon as they are deployed, keeping your app modern with minimal effort.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. The underlying voice models are trained on data from LibriTTS-R, which aggregates public-domain audiobook readings from LibriVox.
23 languages
Any voice speaks any of these languages.
Sources and further reading
- Wikipedia
- ISO 639 language codes
- openai-python on GitHub
- Creative Commons Attribution 4.0
- LibriVox public-domain audiobooks
- curl documentation
- W3C WAI: making audio and video accessible
- MDN: Web Speech API
- Python documentation
- LibriTTS-R corpus (OpenSLR 141)
- OpenAI API reference: create speech
- TRON developer hub: TRC-20
