Frequently asked questions
What is the base URL for the API?
The base URL is https://api.playmm33.com/v1. You send POST requests to https://api.playmm33.com/v1/audio/speech. This endpoint accepts JSON bodies with model, input, voice, and other parameters. The structure mirrors the OpenAI speech endpoint, allowing you to integrate easily using standard HTTP clients or compatible SDKs without custom adapters.
Can I use the OpenAI Python SDK?
Yes. The API request shape matches the OpenAI speech endpoint. You can use the official OpenAI Python SDK by changing the base_url to https://api.playmm33.com/v1 and providing your EchoCast API key. This allows you to leverage familiar SDK methods for generating audio files directly in your Python applications.
How do I set the language in the request?
Include the optional language field in your JSON request body with an ISO code. If omitted, the system guesses the language from the script, defaulting to English for Latin text. Explicitly setting it ensures correct pronunciation for non-English Latin-script texts, as any voice can speak any of the 23 supported languages.
What happens if the API key is invalid?
The API will reject the request with an authentication error. You must provide a valid Authorization: Bearer tts-... header. Each account has one active key; if you issue a new key, the old one stops immediately. Ensure your key is active and correctly formatted in the request header to avoid service interruptions.
Does the API support streaming audio?
No. The API returns the complete audio file in the response body after synthesis finishes. There is no WebSocket or real-time partial audio streaming. You receive the final file in formats like mp3, wav, opus, flac, or pcm. This synchronous approach simplifies integration for batch processing and episodic content pipelines.
How do I handle text longer than 4096 characters?
Split your text into parts of up to 4096 characters each. Send each part as a separate request to the API. Then, join the resulting audio files in your application logic. This manual splitting ensures you stay within the character limit per request while maintaining the continuity of your longer scripts or documents.
What audio formats are available?
You can choose from mp3, wav, opus, flac, or pcm via the response_format field. These formats cover most podcasting and broadcasting needs. Each generated file carries an inaudible watermark marking it as synthetic speech. Select the format that best fits your downstream processing pipeline or distribution requirements.
What is the maximum speed setting?
The maximum speed setting is 4.0. You can adjust the speed parameter between 0.25 and 4.0 to control the playback rate. This allows you to fine-tune the voice output for your specific content style. The default speed is typically balanced for natural listening, but you can accelerate or decelerate as needed.
Do I need to send the language code explicitly?
Not always, but it is recommended for non-English Latin text. If you omit the language field, the system guesses the language from the script, defaulting to English for Latin characters. Explicitly setting the language ensures accurate pronunciation, especially when the script might be ambiguous or when using voices optimized for specific languages.
How do I rotate my API key?
Issue a new key from your account dashboard. The new key becomes active immediately, and the old one stops working at once. You can rotate keys anytime to maintain security. Update your applications to use the new key promptly to avoid authentication errors. This process is instant and does not require downtime.
What happens if I exceed the rate limit?
The hard cap is 60 requests per minute per key. Requests are processed sequentially, so under load, a request may wait in a queue regardless of whether you have exceeded your limit. This queuing behavior increases latency. Ensure your integration handles these delays gracefully to maintain smooth audio generation workflows without losing requests.
Is the API compatible with Node.js?
Yes. Since the API uses standard HTTP POST requests with JSON bodies, it works with any HTTP client. You can use the OpenAI Node.js SDK by setting the base_url to https://api.playmm33.com/v1. Alternatively, use any Node.js HTTP library like axios or node-fetch to send requests and receive audio files.
Can I use SSL with the API endpoint?
Yes. The API endpoint https://api.playmm33.com/v1 uses standard HTTPS, ensuring encrypted communication. All requests and responses are secured via SSL/TLS. This protects your API keys and input text during transmission. You can rely on standard SSL configurations in your client libraries without needing special certificates or additional setup steps.
How do I test the API with cURL?
Send a POST request to https://api.playmm33.com/v1/audio/speech. Include your Bearer token in the Authorization header. Set the JSON body with model, input, voice, and response_format. The API returns the audio file directly. You can find a ready cURL example on your /get-api-key/ page after signing in with Google or email.
First request
curl
curl https://api.playmm33.com/v1/audio/speech \
-H "Authorization: Bearer $TTS_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"tts-1","voice":"aria","input":"Hello from the API.","response_format":"mp3"}' \
--output hello.mp3Python (openai)
from openai import OpenAI
client = OpenAI(base_url="https://api.playmm33.com/v1", api_key="tts-...")
with client.audio.speech.with_streaming_response.create(
model="tts-1", voice="nova", input="Hello from Python.", response_format="mp3"
) as response:
response.stream_to_file("hello.mp3")Node.js (openai)
import OpenAI from "openai";
import fs from "node:fs";
const client = new OpenAI({ baseURL: "https://api.playmm33.com/v1", apiKey: process.env.TTS_API_KEY });
const res = await client.audio.speech.create({ model: "tts-1", voice: "milo", input: "Hello from Node.js." });
fs.writeFileSync("hello.mp3", Buffer.from(await res.arrayBuffer()));| voice | |
|---|---|
aria | female |
nova | female |
luna | female |
sage | female |
felix | male |
milo | male |
atlas | male |
orion | male |
| language | |
|---|---|
ar | العربية |
zh | 中文 |
da | Dansk |
nl | Nederlands |
en | English |
fi | Suomi |
fr | Français |
de | Deutsch |
el | Ελληνικά |
he | עברית |
hi | हिन्दी |
it | Italiano |
ja | 日本語 |
ko | 한국어 |
ms | Bahasa Melayu |
no | Norsk |
pl | Polski |
pt | Português |
ru | Русский |
es | Español |
sw | Kiswahili |
sv | Svenska |
tr | Türkçe |
Authentication
Access the EchoCast TTS API using a single active key issued per account. The key begins with the prefix tts- followed by a unique alphanumeric string. This key authenticates all requests to the API base URL, https://api.playmm33.com/v1.
Use the standard HTTP Authorization header to pass your credentials. Include the header Authorization: Bearer <your-key> with every request. Only one key is active per account; issuing a new key immediately invalidates the previous one.
API Key Format
Keys are generated upon account creation or via the dashboard. They follow the strict format tts- followed by a unique alphanumeric string. This prefix allows you to quickly identify API keys in your environment variables or configuration files.
Bearer Token Usage
Include the full key in the Authorization header as a Bearer token. Example: Authorization: Bearer tts-abc123.... The API validates this token against the account balance and rate limits before processing the speech request.
Key Rotation Policy
Each account holds one active key at a time. You can issue a new key from the dashboard at any time. When a new key is generated, the old key stops working immediately, ensuring tight control over access.
- Generate new keys via the /get-api-key/ dashboard.
- Old keys become invalid instantly upon new key creation.
- One active key per account simplifies security management.
Speech Endpoint
The core engine exposes a single endpoint for converting text into audio files. Send a JSON payload to generate broadcast-ready speech with consistent quality.
POST /v1/audio/speech
Send requests to POST https://api.playmm33.com/v1/audio/speech. The endpoint accepts a JSON body and returns an audio file directly.
Request Body Parameters
Required fields include model ("tts-1" or "tts-1-hd"), input (text up to 4096 characters), and voice (one of the 8 presets). Optional parameters allow response_format selection (mp3, wav, opus, flac, pcm), speed adjustment (0.25–4.0), and language specification (ISO code).
- model: "tts-1" or "tts-1-hd"
- input: string, max 4096 chars
- voice: one of 8 presets
- response_format: mp3, wav, opus, flac, pcm
- speed: 0.25–4.0
- language: optional ISO code
Response Format
The API returns the audio file in the requested format. If synthesis fails, the request is free with no charge applied. Successful requests return the binary audio data directly.

Voice Selection
Select from eight distinct voice presets optimized for broadcast workflows. Each voice is based on licensed recordings from LibriTTS-R (CC BY 4.0), derived from LibriVox public-domain audiobook readings. Every generated file carries an inaudible watermark marking it as synthetic speech, ensuring transparency for episodic content pipelines.
Available Voice Presets
Voices are categorized by gender and tone to match your script's narrative style. You can choose from warm narrators, upbeat broadcasters, or deep documentary voices. Any voice can speak any of the 23 supported languages, though setting the language parameter is recommended for non-English Latin-script text.
Gender and Tone Variations
Female voices include Aria (warm, clear narrator), Nova (bright, upbeat), Luna (soft, storytelling), and Sage (calm, instructional). Male options feature Felix (energetic, promo), Milo (friendly, conversational), Atlas (neutral, news), and Orion (deep, documentary).
Voice ID List
- Aria
- Nova
- Luna
- Sage
- Felix
- Milo
- Atlas
- Orion
Audio Formats
The API accepts mp3, wav, opus, flac, and pcm via the response_format field. Choose the container that matches your podcasting pipeline, whether you need compressed files for web delivery or raw samples for editing.
MP3 Compression
Select mp3 for widely compatible, compressed audio files. This format reduces bandwidth usage while maintaining acceptable quality for web playback and standard podcast directories.
WAV Lossless
Use wav to receive a Waveform Audio File Format container. Unlike pcm, which returns raw binary data, wav wraps the audio with a header structure, making it immediately playable by most standard audio editors and DAWs without manual parsing.
FLAC and OPUS Support
FLAC provides lossless compression, preserving all audio data in a smaller file size than WAV. OPUS is available as a supported format for efficient encoding. These options allow you to balance storage efficiency with fidelity based on your specific archival or distribution needs.
Rate Limits
Your API key allows 60 requests per minute once the account is funded. This limit applies uniformly across all endpoints and models, ensuring consistent throughput for your podcast production pipeline.
Before the first top-up, the rate is restricted to 10 requests per minute. This lower tier allows you to verify integration stability without requiring immediate payment.
60 Requests Per Minute
Authenticated accounts with a positive balance can process up to 60 requests per minute. This throughput is sufficient for most episodic content workflows, where batches of text are sent to generate audio files sequentially.
Pre-Topup Limits
Accounts that have not yet made their first USDT top-up are limited to 10 requests per minute. This constraint applies regardless of whether you are using the free trial credit or a paid balance. The limit increases to 60 RPM once the first top-up is processed.
Queue Behavior
Requests are processed one after another. If you exceed the per-minute threshold, the API does not immediately reject your request. Instead, the request enters a queue and waits for the next available slot. Under load, you may experience slight delays before synthesis begins, but the request will eventually be processed.

Text Limits
The API accepts a maximum of 4096 characters per request, including spaces and punctuation. This limit applies to the input field in the JSON body. If your script exceeds this length, you must split it into smaller chunks before sending requests to the endpoint.
4096 Character Max
Each API call processes up to 4096 characters of text. This constraint ensures consistent generation performance and fits within the engine's processing window. Any text beyond this limit must be segmented by your application logic.
Splitting Long Texts
- Calculate character count including spaces and punctuation.
- Split at sentence or clause boundaries to avoid abrupt cuts.
- Send each segment as a separate
POSTrequest.
Joining Audio Files
The API returns the complete audio file directly in the response body for each request. This is not real-time streaming; you must receive the full file object before proceeding. Save each segment locally or in memory, then concatenate them in your preferred audio library to create the final broadcast-ready file.
- Receive full file in response body.
- Save each segment individually.
- Concatenate files after all requests complete.
SDK Integration
The API mirrors the OpenAI speech endpoint structure, allowing direct usage of official OpenAI SDKs with minimal configuration. This compatibility extends to Python, Node.js, and Go workflows without requiring custom wrappers or proprietary client libraries.
OpenAI SDK Compatibility
By matching the request shape, you can leverage existing SDKs directly. This ensures consistent behavior across different programming environments while maintaining the specific constraints of the EchoCast engine.
Base URL Configuration
Update your SDK client to point to https://api.playmm33.com/v1 instead of the default OpenAI endpoint. Ensure your API key is passed via the standard Authorization header.
Python Example
Initialize the client with the new base URL and pass your text input. The SDK handles JSON serialization and returns the audio file directly in the response body.
- Set base_url to https://api.playmm33.com/v1
- Pass model as tts-1 or tts-1-hd
- Provide voice preset ID and input text
- Receive binary audio data in response

Error Handling
The API returns standard HTTP status codes to indicate request outcomes. A 400 Bad Request typically indicates invalid parameters, such as exceeding the 4096-character limit or providing a malformed model string. These are client-side issues that do not consume synthesis resources.
For network or server-side issues (5xx), the request failed during processing. The system distinguishes between billing-eligible synthesis attempts and pure parameter validation errors, ensuring you are not charged for input that never reached the engine.
Common Error Codes
A 400 Bad Request signals invalid parameters, such as exceeding the 4096-character limit or using an unsupported voice ID. These are immediate validation failures that do not consume synthesis credits.
A 429 Too Many Requests indicates you have exceeded the 60 requests per minute limit per key. The response body includes retry-after timing. Wait before resuming your batch jobs.
- 400: Invalid parameters (bad JSON, unknown voice, limit exceeded).
- 401: Invalid or expired API key.
- 429: Rate limit exceeded (60 req/min).
- 500: Internal server error during synthesis.
Retry Logic
Implement exponential backoff for 429 and 5xx errors. Do not retry 400 errors, as they will fail identically without parameter correction.
For 500 errors, the synthesis may have partially completed or failed. The system ensures no double charge occurs if a retry is processed.
Refund Conditions
Failed synthesis requests are free. If the engine fails to generate audio due to an internal error (5xx), the charge is returned in full.
Client errors (4xx) typically do not incur a charge, but any erroneous deduction is automatically refunded to your balance.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Stop coding and start creating your dream app with just your voice and a few simple taps.
23 languages
Any voice speaks any of these languages.
