Frequently asked questions
What is the best way to structure a podcast script for TTS?
Split scripts into segments of 4,096 characters or fewer, as the API processes one request at a time. Since the engine lacks SSML support, structure your text clearly and set the language parameter explicitly to ensure accurate pronunciation. Remember that spaces and punctuation count toward the character limit, so concise writing ensures efficient processing and consistent synthetic voice output.
Can I generate audio for multiple episodes at once?
Requests are processed sequentially, so under load a request may wait in a queue. You can generate multiple episodes by sending separate POST requests. Each request handles up to 4096 characters. Failed requests are free, ensuring you only pay for successfully generated audio files without wasting credits on errors.
How do I ensure consistent voice quality across episodes?
Select one of the eight preset voices, such as Aria or Atlas, and use the same voice parameter for all episodes. The engine uses the same model (tts-1 or tts-1-hd) for consistent synthesis. Since voices are based on licensed recordings, the audio remains uniform across all generated files in your episodic pipeline.
Does the API support SSML for emphasis?
No, the API does not support SSML. It accepts plain text input up to 4096 characters. You cannot use SSML tags for emphasis or custom pronunciation lexicons. The engine relies on standard punctuation and the specified language code to determine pacing and intonation for the synthetic speech output.
Can I change the speed of the audio after generation?
No, speed is set during generation using the speed parameter (0.25–4.0). The API does not offer post-processing or real-time speed adjustments. You must specify the desired speed in your request body. Once the audio file is returned, it is fixed; no editing or modification endpoints are available.
How do I handle punctuation in long scripts?
Punctuation counts as characters toward the 4096-character limit. The API does not support SSML, so use standard punctuation for natural pacing. For scripts longer than 4096 characters, split the text into parts, generate audio for each, and join the files. Proper punctuation ensures the engine guesses the language and pacing correctly.
Is it possible to merge multiple audio files automatically?
The API returns individual audio files per request. It does not automatically merge them. You must split long texts into parts of up to 4096 characters, generate each part, and join the resulting audio files in your own pipeline. This allows precise control over the final broadcast-ready audio structure.
What is the recommended chunk size for long texts?
The maximum input size is 4096 characters per request. For longer scripts, split the text into chunks of this size. Generate audio for each chunk and join the files. This approach ensures efficient processing and avoids exceeding the limit, maintaining consistent voice quality across the entire episode or document.
How does the API handle special characters?
Special characters count toward the 4096-character limit. The API treats them as standard text input. Since there is no custom pronunciation lexicon, unusual symbols may affect pacing or be ignored. Stick to standard punctuation and alphanumeric characters for reliable synthesis, especially when language detection is automatic.
Can I use the API with WordPress for podcast hosting?
No official WordPress plugin exists. Integrate via plain HTTP or the OpenAI SDK by setting base_url to https://api.playmm33.com/v1. Handle audio delivery and storage yourself; the API returns the file in the response. This approach suits podcasters who prefer code over drag-and-drop tools for episodic content pipelines.
Do I need a developer to integrate this API?
While you can use the OpenAI SDK, integration typically requires writing code to send POST requests and handle responses. There is no drag-and-drop tool or WordPress plugin. Developers can use the provided curl examples or SDKs to automate the workflow, making it suitable for code-first podcast production pipelines.
How long does it take to generate a 10-minute episode?
Synthesis runs at roughly real-time speed, generating about 25 characters per second. A 10-minute episode requires approximately 10 minutes of active processing time. Because requests are processed sequentially, heavy load may cause your request to wait in a queue before generation begins. Note that failed requests are free and do not incur charges.
Can I use the API to dub existing audio?
No, the API converts text to speech. It does not perform speech-to-text, translation, or dubbing. You must provide the text input. The API generates synthetic audio from your script. It does not analyze or modify existing audio files, nor does it offer a dubbing pipeline for existing content.
What happens if the API goes down?
We do not offer an SLA or uptime guarantee. Requests may fail or queue under load. Failed requests are free, so you are not charged for errors. Since there is no SLA, there is no compensation for downtime. Support is available via email if issues persist.
Workflow Overview
Automating podcast production requires a pipeline that converts raw scripts into broadcast-ready audio. The process begins with preparing text segments, sending them to the TTS API, and assembling the resulting audio files. This approach ensures consistent voice quality and predictable costs for episodic content.
Script Preparation
Split long scripts into segments of up to 4096 characters. Each segment becomes a separate API request. This ensures reliable synthesis and simplifies error handling. You must join the resulting audio files in the exact order of your script segments to maintain narrative continuity.
- Limit text to 4096 characters per request
- Preserve segment order for accurate audio joining
- Count spaces and punctuation as characters
API Integration Steps
Send a POST request to https://api.playmm33.com/v1/audio/speech with your Bearer token. Include the script text, voice preset, and desired audio format. The API returns the audio file directly in the response body. Use the standard OpenAI SDK structure for compatibility.
- Use
POST /v1/audio/speechendpoint - Include
Authorization: Bearer tts-...header - Supports
mp3,wav,opus,flac, andpcm
Audio Post-Processing
After receiving the audio files, concatenate them in sequence. Apply standard audio normalization to ensure consistent volume across episodes. Each file contains an inaudible watermark marking it as synthetic speech, which remains intact after joining. No additional metadata is required for basic playback.
- Concatenate files in segment order
- Apply volume normalization
- Watermark is embedded in each file
Selecting the Right Voice
Selecting the correct voice preset ensures your script’s intent matches the listener’s expectation. Each of the eight presets offers a distinct tone, from the warm clarity of Aria to the deep documentary feel of Orion. This standardization helps you build a recognizable auditory brand identity across all your episodes.
Matching Tone to Genre
Match the voice to your content style. Use Felix for energetic promos or Atlas for neutral news. Sage works well for instructional content, while Luna suits storytelling.
Consistency Across Episodes
Stick to one voice per series to maintain continuity. If you switch voices, listeners may notice the change in synthetic speech quality.
Testing Voice Presets
Generate short test clips for each voice using your API key. Verify that the watermark is present and the audio quality meets your standards before committing to a full episode.

Handling Long Scripts
Long scripts exceed the 4096-character limit per request. Split your text into segments of up to 4096 characters. Process each part sequentially through the API. Join the resulting audio files to create a single episode file.
Splitting Text Segments
Ensure each segment stays within the 4096-character limit. Split at natural breaks to avoid cutting words mid-sentence. This prevents potential synthesis issues and maintains audio continuity.
- Max 4096 characters per request
- Split at sentence boundaries
- Count spaces and punctuation
Synchronizing Audio Files
Generate audio for each segment individually. The API returns audio files directly in the response. Store these files temporarily while processing other segments. This ensures all parts are ready before merging.
Automating Join Commands
Use command-line tools or scripts to concatenate audio files. For formats like WAV, simple concatenation works well. For MP3, ensure proper header handling to avoid playback gaps. Combine files in the correct order to match your script.
Language Management
When the language field is omitted, the API infers the language from the script’s script type. Latin-script text defaults to English, which simplifies integration for English-language podcasts but may misidentify non-English Latin text like French or German. For non-English Latin-script content, explicitly setting the language parameter ensures accurate voice synthesis.
Detecting Script Language
The API guesses the language based on the script used in the input text. While this works well for English, relying on detection for other Latin-based languages can lead to incorrect synthesis if the script is ambiguous. Explicitly defining the language removes this ambiguity.
- Latin scripts default to English if unspecified
- Non-English Latin text requires explicit
languagefield - Detection relies on visible script characters
Forcing Language Codes
Pass the ISO code in the language field to guarantee the correct voice output. This is critical for non-Latin scripts or when the input text contains mixed scripts. The system supports 23 specific languages, and any voice can speak any of them when explicitly directed.
- Use
languageparameter for precision - Supports 23 specific languages
- Any voice can speak any supported language
Mixed-Language Episodes
For episodes containing multiple languages, split the text into segments and send separate requests. Assign the correct language code to each segment. This ensures accurate pronunciation and tone for each linguistic part of the episode without relying on detection.
- Split text by language segment
- Send separate API requests per segment
- Assign specific
languagecode to each request
Cost Optimization
TTS billing charges $0.01 per 1,000 characters, including spaces and punctuation. Eliminating filler words and redundant transitions directly reduces your cost per episode. Since the engine processes requests sequentially, minimizing character count also lowers queue wait times during high load, ensuring faster delivery of your final audio files.
Reducing Character Count
Audit your scripts to remove conversational padding. Every character, including spaces, counts toward the 4096-character limit per request. Tighter scripts reduce both cost and processing latency.
- Remove filler words and redundant transitions
- Count all spaces and punctuation as billable characters
- Stay under 4096 characters to avoid splitting logic
Batching Requests
Split long scripts into 4096-character segments and process them sequentially. The server handles requests one after another, so parallel sending may cause queue delays. Join the resulting audio files to create the final episode.
- Split text into 4096-character chunks
- Send requests sequentially to avoid queue delays
- Join audio files programmatically after synthesis
Monitoring Usage
Track character consumption via your account dashboard. Failed requests are free, so monitor retry rates. Top-ups via USTR (TRC-20) are credited automatically, ensuring continuous production without service interruption.
- Check balance and character usage regularly
- Verify failed requests are free
- Use USDT on TRON network for instant top-ups
Technical Requirements
Automate podcast production by sending POST requests to https://api.playmm33.com/v1/audio/speech. Authentication requires a valid Authorization: Bearer header with your API key. Ensure your client handles standard HTTP status codes correctly.
The JSON body defines the synthesis parameters. Include the model, input text, voice preset, and desired audio format. The API returns the audio file directly in the response body, allowing seamless integration into your production pipeline.
Required HTTP Headers
Include Authorization: Bearer tts-your-api-key in every request. This authenticates your account against the API. No other headers are strictly required, though standard Content-Type: application/json is recommended for clarity.
- Authorization: Bearer tts-...
JSON Body Structure
Send a JSON object with model ("tts-1" or "tts-1-hd"), input (text up to 4096 characters), voice, and response_format. Optional fields include speed (0.25–4.0) and language (ISO code).
If synthesis fails, the request is free. No characters are deducted from your balance, and standard error codes indicate the issue.
- model: "tts-1" or "tts-1-hd"
- input: string, max 4096 chars
- voice: one of 8 presets
- response_format: mp3, wav, opus, flac, or pcm
- speed: 0.25–4.0
- language: optional ISO code
Response Parsing
The API returns the audio file directly in the response body. Parse the binary data or save it as the specified format. For long scripts, split text into segments, process each, and join the resulting files using your preferred audio tool.

Error Management
API errors are typically immediate. A 400 Bad Request indicates invalid parameters, while 429 Too Many Requests signals rate limit exhaustion. Since requests queue sequentially, high load may cause delays, but true timeouts are rare unless the server is unreachable. Always check your Authorization header first; an invalid or expired key returns a 401 Unauthorized. Failed synthesis is free, so retrying a failed request does not incur extra charges. Use the GET /v1/voices endpoint to verify available voices, but note that it does not report real-time online/offline status for each voice. Only the eight presets listed in the documentation are valid. Do not assume status from the endpoint response. Stick to the documented presets to avoid errors. This ensures consistent audio generation across your pipeline without unexpected failures. Monitoring your balance and usage helps prevent service interruptions due to insufficient funds or rate limits.
Handling Timeouts
Timeouts occur if the server does not respond within your client’s configured window. Since requests are processed sequentially, under heavy load, your request may sit in a queue. If you exceed the 60 requests per minute limit, you receive a 429 error. Implement exponential backoff for retries. Check your network connection and ensure your API key is active. Failed requests are free, so you can retry without cost concerns. Monitor your balance to avoid service stops. Use logging to track response times and identify bottlenecks in your automation pipeline. This helps in adjusting retry strategies effectively. Consistent monitoring prevents unexpected downtime in your production workflow.
- Check 429 errors for rate limit issues
- Implement exponential backoff for retries
- Verify API key validity on 401 errors
- Log response times for optimization
Retrying Failed Synthesis
Failed requests are refunded automatically. Retry logic should handle transient errors like 500 Internal Server Error or 503 Service Unavailable. Do not retry 4xx errors (e.g., 400 Bad Request) unless you fix the input. Use the GET /v1/models endpoint to confirm available models. Ensure your retry mechanism respects the rate limits. Failed synthesis is free, so retrying is cost-effective. Monitor your balance to ensure sufficient funds. Use logging to track retry success rates. This helps in identifying persistent issues versus transient network problems. Consistent retry logic ensures robust automation.
- Retry 5xx errors only
- Fix 4xx errors before retrying
- Respect rate limits during retries
- Log retry success rates
Debugging Voice Errors
Voice errors usually stem from incorrect voice IDs. Ensure the voice matches one of the eight presets. Use GET /v1/voices to verify available voices. Do not rely on status indicators from this endpoint as they do not reflect real-time availability. Check for typos in voice names like 'aria' or 'nova'. Invalid voices return a 400 error. Correct the voice ID and retry. This ensures consistent audio generation. Monitor your logs to identify frequent voice errors. This helps in maintaining high-quality audio output. Consistent debugging prevents production delays. Use the documented presets for reliability.
- Verify voice ID against presets
- Check for typos in voice names
- Use GET /v1/voices for validation
- Log frequent voice errors
Deployment Strategies
Automating podcast production with the EchoCast API involves integrating synthesis into your existing CI/CD pipelines or serverless environments. By treating audio generation as a standard build artifact, you can ensure consistent delivery of broadcast-ready episodes directly from your script repositories.
CI/CD Integration
Integrate the TTS API into your build steps by passing script files directly to the POST /v1/audio/speech endpoint. Since requests are processed sequentially, long episodes may require splitting text into 4096-character segments and joining the resulting audio files in the pipeline.
- Use standard HTTP clients or the OpenAI SDK with a custom base URL.
Cloud Function Usage
Deploy lightweight functions to trigger synthesis upon script updates. This approach decouples content creation from audio generation, allowing you to handle rate limits (60 requests/minute) gracefully by queuing requests when necessary.
- Ensure keys are stored securely as environment variables.
Caching Responses
Store generated audio files locally or in object storage to avoid redundant API calls for unchanged scripts. While identical inputs do not guarantee identical outputs due to synthetic watermarks, caching remains efficient for static content.
- Clear cache when script text or voice parameters change.
Quality Assurance
Quality assurance ensures your automated podcast pipeline delivers consistent, broadcast-ready audio. Since requests are processed sequentially, longer scripts may experience queue delays, affecting real-time generation expectations. Verify that the final output meets your technical standards before publishing to avoid listener disruption.
Listening for Artifacts
The engine uses licensed recordings from LibriVox and LibriTTS-R. Every generated file carries an inaudible watermark that marks it as synthetic speech. This marker is inherent to the file and does not require manual verification during your editing workflow.
Speed Adjustment
Adjust the speed parameter between 0.25 and 4.0 to fit your episode runtime. Typical generation speed is roughly real time (about 25 characters per second), though short phrases may take a few seconds. Under load, requests process in queue order.
Format Verification
Select your preferred response_format (mp3, wav, opus, flac, or pcm) based on your hosting requirements. Ensure your automation script correctly parses the audio binary from the JSON response to prevent corruption in your CI/CD pipeline.
Common Pitfalls
Automation fails when scripts exceed the 4096-character limit per request or when language detection defaults incorrectly for non-English Latin text. These oversights cause silent truncation or mispronunciation in episodic pipelines.
Rate limits also disrupt batch jobs. Without monitoring, scripts may hit the 60 requests-per-minute threshold, queuing synthesis and delaying delivery.
Ignoring Character Limits
Each API call accepts a maximum of 4096 characters, including spaces and punctuation. Exceeding this limit causes the request to fail or truncate unexpectedly, breaking the audio chain for long-form episodes.
- Split text into chunks <4096 chars
- Join outputs sequentially
Missing Language Tags
If the language field is omitted, the system guesses based on script. Latin text defaults to English, causing errors for other languages. Always set the ISO code explicitly for non-English content.
Rate Limit Exceedance
Accounts are limited to 60 requests per minute per key. Under heavy load, requests queue, increasing latency. Monitor usage via the dashboard to prevent throttling during peak production windows.

Support and Scaling
Support is available exclusively via email; there is no phone number or live chat. For scaling, issue additional API keys since each key allows 60 requests per minute. This parallelism bypasses the queue during high-volume production runs.
Monitor your balance on the /get-api-key/ dashboard to prevent synthesis stops. Accounts start with $0.50 trial credit valid for 7 days, but long-term usage requires TRC-20 USDT top-ups. Track character consumption to maintain consistent episodic output without unexpected service interruptions.
Email Support Channels
All inquiries are handled via email. We do not offer phone support or live chat, ensuring detailed technical responses without wait times.
Scaling with Multiple Keys
Each API key supports 60 requests per minute. To increase throughput, generate multiple keys from your dashboard. Rotate keys to distribute load and avoid queuing delays during batch processing.
- Issue new keys instantly; old ones stop immediately.
- Rotate keys across parallel CI/CD jobs.
- No minimum spend or seat limits.
Monitoring Balance
View real-time balance and usage on /get-api-key/. Top-ups via TRON (TRC-20) credit automatically within minutes. Balance never expires.
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.
