Frequently asked questions
What is the difference between TTS and text-to-audio?
Text-to-speech (TTS) is a specific type of text-to-audio that converts written language into spoken words. Our API generates speech audio files from text input. It does not generate music or sound effects, only vocal speech synthesized from the provided text using selected voices and models.
Do I need a developer to use a TTS API?
While a developer is helpful for integration, you can use our API with simple HTTP requests. The endpoint accepts JSON bodies similar to OpenAI’s format. You can test it immediately using the ready curl example provided on the /get-api-key/ page, requiring no complex coding skills.
Can I use a TTS API for commercial projects?
Yes, you can use the generated audio for commercial projects. The input text is not used for training, and the audio is returned in the response without being stored. Each file carries an inaudible watermark marking it as synthetic speech, ensuring clear attribution for your commercial use cases.
Is a TTS API the same as a voice assistant?
No. A TTS API converts text into an audio file you receive via HTTP. A voice assistant is an interactive application that listens, processes commands, and responds in real-time. Our API provides static audio files; it does not handle conversation logic, voice recognition, or real-time interaction.
How does a TTS API handle accents?
The API uses eight preset voices, each with a distinct tone. You can also specify a language code (e.g., 'en', 'de', 'fr') to guide synthesis. If omitted, the API guesses the language from the script, defaulting to English for Latin text. This allows precise accent control.
Do I need to host the TTS API myself?
No, EchoServe is a cloud API. You send requests to https://api.playtk77.com/v1 and receive audio files directly. There is no on-premise install option, no data-center choice, and no need to manage servers. You simply pay per character used, with no monthly plans or minimum spend.
What is a base URL in the context of TTS?
The base URL is the root address for API requests. For EchoServe, it is https://api.playtk77.com/v1. By changing this base URL in the official OpenAI SDKs, you can use their libraries to send text and receive audio files from our service without writing custom HTTP code.
Can I generate audio from a JSON file?
You send JSON data containing the text to the API. The API does not read JSON files directly from your disk. You must extract the text string from your JSON file and include it in the input field of the JSON body sent to the speech endpoint.
Does the API support background music?
No, the API generates speech audio only. It does not support adding background music, sound effects, or mixing layers. You receive a raw audio file (mp3, wav, opus, flac, or pcm) containing only the synthesized voice. You must use external tools to add music during post-production.
Is the audio quality consistent across all voices?
All voices use the same underlying engine models (tts-1 or tts-1-hd). The difference lies in the preset voice characteristics, such as warmth, brightness, or depth. Quality remains consistent in terms of clarity and realism, but the tonal style varies significantly between the eight available voice presets.
Can I mix different voices in one audio file?
No, each request generates audio from a single voice. To mix voices, you must send separate requests for each segment, then join the resulting audio files. The API does not support multi-voice tracks or mixing within a single synthesis request. You handle the assembly yourself.
How does the API handle special characters?
Special characters and punctuation are processed as part of the input text. Spaces and punctuation count toward the character limit and billing. The API does not use SSML or custom pronunciation lexicons, so complex formatting may require standard text representation for accurate synthesis.
What is the difference between tts-1 and tts-1-hd?
Both models use the same engine and price ($10 per 1 million characters). The tts-1-hd model offers higher audio fidelity compared to tts-1. You can choose either model in your request based on your quality preferences, with no difference in cost or rate limits.
Can I use the API for podcast generation?
Yes, the API is suitable for generating podcast audio. You can split long texts into parts of up to 4096 characters and join the resulting audio files. With a speed of roughly real-time, it is efficient for producing full episodes, though you must manage the stitching process.
Definition
A text-to-speech API is a cloud-based synthesis service that converts written text into audible speech. It enables product teams in public services and NGOs to programmatically generate audio content without managing underlying infrastructure. The service operates entirely over HTTP, allowing seamless integration into existing digital workflows for accessibility and content distribution.
Cloud-based synthesis service
The service runs on remote servers, processing text inputs to synthesize natural-sounding speech. This cloud model eliminates the need for local hardware or software installations, ensuring consistent performance across different devices and platforms. Users simply send a request and receive the generated audio, making it ideal for scalable public service applications.
HTTP POST endpoint
Interaction with the API is standardized through a simple HTTP POST request. The endpoint, located at https://api.playtk77.com/v1/audio/speech, accepts a JSON body containing the text, voice selection, and format preferences. This structure mirrors common industry standards, allowing developers to use familiar tools and libraries for integration without custom protocol logic.
Returns audio file
Upon processing, the API returns the synthesized speech as an audio file. Supported formats include mp3, wav, opus, flac, and pcm, ensuring compatibility with various web and mobile applications. The response is immediate, delivering the complete audio asset ready for playback or further processing in the user’s digital ecosystem.
How It Works
The workflow begins when your application sends a POST request to the synthesis endpoint. You provide the text (up to 4096 characters) and specify parameters like voice, format, and speed in a JSON body. This input is dispatched to our cloud infrastructure for processing.
Our engine converts the text into audio using licensed voice models. The system processes requests sequentially, so under load, queues may form. Once synthesis is complete, the audio file is generated and returned to your application for immediate use or storage.
Send text input ['Send a POST request to the API endpoint with your text and configuration parameters in a JSON body.', 'Specify the desired voice, language, and output format (mp3, wav, opus, flac, or pcm) to match your accessibility needs.'] ['Text must not exceed 4096 characters per request', 'Use Bearer token authentication for secure access']
Process via TTS engine ['The cloud engine converts your text into speech using one of eight preset voices.', 'Requests are processed sequentially; long texts are split into parts and joined seamlessly.']
Receive audio response ['Receive the generated audio file directly in the API response.', 'Failed requests incur no charge, ensuring cost efficiency for testing and validation.']
Technical Structure
The API uses a standard JSON structure for requests, accepting text up to 4,096 characters alongside voice and format parameters. Authentication relies on a single Bearer token key, which can be rotated instantly to invalidate the previous credential. This design ensures simple integration for public service teams evaluating compliance and cost-efficiency.
Endpoints are standardized, mirroring OpenAI’s structure, allowing teams to use existing SDKs by simply adjusting the base URL. This reduces development overhead compared to proprietary solutions that require custom clients or specific library versions for basic text-to-speech functionality.
JSON request body
Requests include fields for model, input, voice, response_format, speed, and an optional language code. The system processes these parameters to generate audio, ensuring predictable output formats like MP3 or WAV without requiring complex configuration files.
The input text is limited to 4,096 characters per request. Longer content must be split into chunks and reassembled, a process easily handled by server-side logic.
model: tts-1 or tts-1-hdinput: text string (max 4096 chars)voice: one of 8 presetsresponse_format: mp3, wav, opus, flac, pcmspeed: 0.25–4.0language: optional ISO code
Bearer token auth
Each account holds one active API key, prefixed with tts-. This key is passed in the Authorization header as a Bearer token. If a new key is issued, the old one stops working immediately, simplifying security audits for NGOs.
Rate limits are applied per key: 60 requests per minute after the first top-up, or 10 per minute before the first top-up. This ensures fair usage without complex tier management.
Standardized endpoints
The API exposes POST /v1/audio/speech for synthesis, GET /v1/voices for listing available options, and GET /v1/models for engine details. This consistency allows teams to integrate quickly using familiar HTTP patterns.
Because the request shape matches the OpenAI speech endpoint, teams can switch providers by updating only the base_url configuration in their code, preserving existing integration logic.
Use Cases
Text-to-speech APIs enable public service platforms to convert static text into audible formats, ensuring compliance with accessibility standards like WCAG. By integrating an API endpoint, product teams can dynamically generate audio from government notices, forms, or help documentation without maintaining complex local infrastructure.
Web accessibility overlays
Organizations can embed an API-driven player that reads page content on demand. This approach supports 23 languages, allowing diverse user bases to access information in their native tongue. The service handles character limits up to 4096, splitting longer texts into parts and joining the resulting audio files.
- Dynamic audio generation for long-form public documents
- Multi-language support covering 23 languages
- No client-side storage required for generated audio
Audio content generation
NGOs and public institutions use the API to produce high-quality narration for digital campaigns. With eight distinct voice presets, teams can select tones ranging from calm instructional to energetic promo styles. The output formats include MP3, WAV, and FLAC, ensuring compatibility with various media players.
- 8 voice presets for varied tonal requirements
- Multiple audio formats for flexible deployment
- Fast generation suitable for time-sensitive announcements
Public service announcements
Critical updates, such as emergency alerts or policy changes, require immediate auditory distribution. The API processes requests at roughly real-time speed, allowing rapid creation of audio files from text inputs. This ensures that urgent information reaches citizens quickly via SMS, email, or web channels.
- Rapid synthesis for time-critical information
- Reliable processing with clear status feedback
- Cost-effective scaling for large user bases
Integration Methods
Integrating EchoServe requires minimal infrastructure changes. Teams can send standard JSON payloads via HTTP POST to the speech endpoint, authenticating with a Bearer token. This straightforward approach ensures compatibility with existing backend workflows without requiring specialized middleware.
For developers preferring structured clients, the OpenAI SDK offers a seamless wrapper. By simply updating the base_url to our API domain, existing code handles requests and response parsing automatically, reducing boilerplate code significantly.
Direct HTTP requests
Send a POST request to https://api.playtk77.com/v1/audio/speech with a JSON body containing model, input, voice, and response_format. Authenticate using Authorization: Bearer tts-.... This method provides full control over headers and retry logic.
Use tools like cURL or Postman for quick testing. The API returns raw audio data, allowing you to save the response directly to storage or playback systems without intermediate parsing.
- Endpoint:
POST /v1/audio/speech - Auth:
Authorization: Bearer <key> - Format: JSON body
- Response: Raw audio bytes
OpenAI SDK wrapper
Leverage the official OpenAI SDK for languages like Python or Node.js. Configure the client with base_url=https://api.playtk77.com/v1 to route requests correctly. This maintains familiar method signatures like client.audio.speech.create().
This approach simplifies error handling and type checking. Since the request shape matches the OpenAI standard, migration between providers or testing becomes trivial without rewriting core integration logic.
Server-side processing
Handle all API interactions on your server to keep API keys secure. Process texts up to 4096 characters, splitting longer inputs manually if needed, and join the resulting audio segments. This ensures consistent billing and avoids exposing credentials to client-side code.
Store generated audio temporarily if required for delivery, though the API does not retain it. Server-side processing allows you to manage rate limits (60 req/min) and implement queuing logic for high-volume public service announcements.
Data Handling
When you send text to our API, the input is processed solely to generate the audio response. We do not retain your source text for training or future analysis, ensuring that your specific content remains private and transient during the synthesis process.
Input text not stored
The raw text you submit is used exclusively for the immediate conversion to speech. Unlike some providers that build voice models from user data, we do not archive your input text after the audio is generated. This approach minimizes data retention risks for sensitive public service announcements or NGO communications.
Generated audio not stored
The resulting audio file is returned directly in the HTTP response and is not permanently stored on our servers. Once your application receives the file, our infrastructure does not keep a copy for later retrieval or reuse. This ensures that your audio assets remain under your direct control.
Metadata kept for billing
We retain request metadata—specifically the timestamp, character count, and status—for billing and usage verification purposes. This minimal data allows us to accurately calculate your costs based on the $0.01 per 1,000 characters rate and verify successful deliveries without storing the actual content.
Cost Model
EchoServe charges $0.01 per 1,000 characters, with a free trial of $0.50 for new Google sign-ups. Failed requests are free, ensuring you only pay for successful synthesis.
Pay per character
Billing is precise: every space and punctuation mark counts as one character. You receive detailed usage logs showing characters consumed per request, allowing exact budget forecasting for public service announcements or accessibility overlays.
- Rate: $10 per 1 million characters
- Failed requests are fully refunded
No monthly fees
There are no subscriptions, minimum spends, or seat limits. You do not pay for idle capacity. This model suits NGOs with fluctuating text volumes, avoiding wasted spend during low-activity periods.
Credit-based system
Top-ups are processed via USDT (TRC-20) with a $5 minimum. Credits appear within minutes and never expire. Accounts start with a 7-day, $0.50 trial when signing in with Google.

Voice Selection
The API offers eight distinct voice presets, allowing product teams to select the most appropriate audio tone for their specific public service or NGO context. Each voice is engineered for clarity and natural flow, ensuring high usability across diverse audience segments.
These voices are derived from licensed LibriTTS-R recordings (CC BY 4.0) and include an inaudible synthetic watermark. This ensures both legal compliance and content authenticity without requiring complex attribution workflows in your application layer.
8 preset voices
We provide eight curated voices, ranging from warm narrators to neutral news readers. This variety allows teams to match audio output to content type, whether it is a soft storytelling format or a direct instructional guide.
Each voice is distinct in timbre and pacing, enabling precise alignment with your brand’s accessibility standards without needing external voice direction.
- Aria: warm, clear narrator
- Nova: bright, upbeat
- Luna: soft, storytelling
- Sage: calm, instructional
- Felix: energetic, promo
- Milo: friendly, conversational
- Atlas: neutral, news
- Orion: deep, documentary
Gender and tone variants
The selection includes balanced male and female options, designed to avoid stereotypical audio tropes while maintaining professional clarity. Teams can choose between conversational tones for user guides or authoritative tones for public announcements.
Tone variants are inherent to the voice preset and cannot be dynamically adjusted via parameters, ensuring consistent audio quality across all generated files.
Multi-language support
All eight voices support 23 languages, including Arabic, Chinese, English, French, German, Hindi, Japanese, Korean, Spanish, and more. This allows a single API key to serve global public service deployments without managing separate voice models.
The system guesses the language from the script if not specified, but explicit language codes are recommended for non-English Latin text to ensure accurate pronunciation and intonation.
Limitations
Text-to-speech APIs offer reliability but have specific constraints that product teams must plan for. Understanding these boundaries ensures accurate implementation and avoids unexpected delays or workflow bottlenecks during deployment.
The service processes requests sequentially, meaning high volume can introduce queue wait times. While typical generation speed matches real-time audio, burst traffic may delay response delivery compared to synchronous local engines.
4096 char limit
Each API request accepts a maximum of 4,096 characters. Text exceeding this length must be split into smaller chunks by the client application. The audio files are then joined on the server side to produce a continuous output.
This constraint requires careful handling of long documents or transcripts. Developers should implement logic to detect sentence boundaries and manage the chunking process before sending requests to the endpoint.
- Maximum 4,096 characters per request
- Requires client-side splitting for longer texts
- Audio files are joined automatically
No streaming
The API returns the complete audio file upon request completion. There is no WebSocket support or real-time partial audio streaming. Clients must wait for the full synthesis to finish before playback can begin.
This approach simplifies error handling and integration but may increase perceived latency for very long inputs. It is suitable for most accessibility overlays and pre-generated audio content but not for live dialogue systems.
- Returns full audio file on completion
- No WebSocket or partial streaming support
- Suitable for pre-generated content
No custom cloning
The service uses eight preset voices derived from licensed recordings. Customers cannot upload their own voice samples to create custom clones. This ensures consistent quality and clear licensing terms for all generated audio.
While voice cloning exists in other marketplaces, this model prioritizes standardization and cost-efficiency. Teams needing specific brand voices must select from the available presets or generate audio manually using the API.
- Eight preset voices available
- No custom voice cloning for customers
- Consistent licensing across all voices
Licensing
EchoServe’s voice models are built on licensed recordings from the LibriTTS-R dataset, derived from public-domain audiobook readings on LibriVox. This foundation ensures a clear legal baseline for synthetic voice generation without the complexities of proprietary voice ownership disputes common in other cloud TTS providers.
LibriTTS-R source
The underlying audio data originates from the LibriTTS-R dataset, which aggregates readings from LibriVox. These are volunteer-narrated public domain books, providing a diverse and legally sound training set for our eight preset voices.
- Derived from LibriVox public-domain readings
- Used as the core training dataset for all 8 voice presets
- Ensures consistent acoustic quality across languages
CC BY 4.0 recordings
By leveraging data under the Creative Commons Attribution 4.0 license, we maintain transparency regarding our source material. This open licensing model allows for broad commercial and internal use within public service and NGO contexts, provided attribution norms are respected in your broader projects.
- Based on CC BY 4.0 licensed material
- Transparent origin for audit and compliance teams
- Reduces risk of third-party voice licensing claims
Inaudible watermark
Every audio file generated via our API contains an inaudible digital watermark. This marker identifies the output as synthetic speech, which is increasingly important for accessibility standards and content transparency in public communications.
- Embedded in all generated audio files
- Inaudible to human listeners
- Marks content as synthetic for transparency
Comparison
Cloud TTS APIs decouple synthesis from deployment, unlike traditional software that requires local installation or licensing. This separation allows public service teams to update voice quality without redistributing client software or managing server infrastructure.
Local engines offer low latency but lack scalability. Cloud APIs provide consistent performance across varying loads, making them suitable for public announcements with unpredictable traffic spikes.
Vs traditional TTS software
Traditional TTS often requires perpetual licenses and local hardware dependencies. Our API eliminates installation overhead, allowing immediate integration into web accessibility overlays or notification systems via standard HTTP requests.
Software-based solutions may struggle with character limits or require complex preprocessing. The API requires splitting long texts into 4,096-character segments, ensuring consistent audio output for lengthy public service announcements.
- No local installation required
- No perpetual license fees
- Automatic text segmentation
Vs local TTS engines
Local engines offer offline capability but lack the ease of scaling. Cloud processing ensures uniform voice quality regardless of the end-user’s device capabilities, crucial for accessible public service websites.
While local solutions reduce data transmission, our API’s metadata-only retention policy ensures input text is not stored, offering a distinct privacy profile for sensitive public records.
Vs other cloud APIs
Unlike proprietary ecosystems, our API uses the OpenAI request shape, allowing teams to switch SDKs easily without rewriting integration code. This reduces vendor lock-in for NGO tech stacks.
We offer transparent character-based pricing ($0.01 per 1,000 characters) without monthly subscriptions. Competitors often charge per minute of audio, which can be less predictable for short, high-volume public notices.
Future Proofing
The API uses standardized endpoints compatible with the OpenAI SDKs, allowing product teams to swap providers with minimal code changes. This reduces vendor lock-in risk and simplifies long-term maintenance for public service applications.
Requests are processed sequentially, ensuring predictable billing and clear audit trails. The architecture supports scaling through simple top-ups via USDT, avoiding complex subscription renewals or contract renegotiations as usage grows.
Standardized endpoints
The POST /v1/audio/speech endpoint mirrors the OpenAI speech format, enabling immediate adoption by teams already familiar with standard TTS workflows. This consistency extends to the GET /v1/voices and /v1/models endpoints, providing transparent data on available engines and pricing.
SDK compatibility
By changing the base_url to https://api.playtk77.com/v1, developers can use official OpenAI SDKs without rewriting integration logic. This ensures that existing codebases for accessibility overlays or audio content generation remain functional with minimal adjustment.
Scalable architecture
The credit-based system scales linearly with usage. There are no monthly caps or seat limits, allowing NGOs and public services to increase volume during campaigns without administrative overhead. Balances do not expire, providing long-term cost predictability.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Our platform empowers public service teams to deliver seamless, inclusive digital experiences for every citizen, everywhere.
23 languages
Any voice speaks any of these languages.
Sources and further reading
- Wikipedia
- LibriTTS-R paper (arXiv 2305.18802)
- LibriTTS-R corpus (OpenSLR 141)
- FFmpeg documentation
- OpenAI API reference: create speech
- TRON developer hub: TRC-20
- openai-python on GitHub
- W3C WAI: making audio and video accessible
- curl documentation
- ISO 639 language codes
- Node.js documentation
- Creative Commons Attribution 4.0
