How to Automate Podcast Production with TTS API?

By EchoCast editorial team · Updated 2026-11-18

This guide explains how to automate podcast production using the EchoCast TTS API, designed for developers who prefer code over drag-and-drop tools. You will learn to integrate synthetic voices into episodic content pipelines, ensuring consistent, broadcast-ready audio for long-form scripts.

Readers will discover how to handle language detection, split long texts into 4096-character chunks, and manage costs effectively. We cover technical implementation details, from JSON request structures to joining audio files, helping you build reliable workflows without external dependencies or complex infrastructure.

How to Automate Podcast Production with TTS API?

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

Sound wave illustration for: 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/speech endpoint
  • Include Authorization: Bearer tts-... header
  • Supports mp3, wav, opus, flac, and pcm

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

Sound wave illustration for: 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.

Selecting the Right Voice

Handling Long Scripts

Sound wave illustration for: 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

Sound wave illustration for: 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 language field
  • 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 language parameter 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 language code to each request

Cost Optimization

Sound wave illustration for: 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

Sound wave illustration for: 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.

Technical Requirements

Error Management

Sound wave illustration for: 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

Sound wave illustration for: 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

Sound wave illustration for: 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

Sound wave illustration for: 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.

Common Pitfalls

Support and Scaling

Sound wave illustration for: 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.

Avatar of the voice aria
ariafemale
Avatar of the voice nova
novafemale
Avatar of the voice luna
lunafemale
Avatar of the voice sage
sagefemale
Avatar of the voice felix
felixmale
Avatar of the voice milo
milomale
Avatar of the voice atlas
atlasmale
Avatar of the voice orion
orionmale

23 languages

Any voice speaks any of these languages.

Sources and further reading

  1. Wikipedia
  2. MDN: Web Speech API
  3. Node.js documentation
  4. TRON developer hub: TRC-20
  5. curl documentation
  6. LibriVox public-domain audiobooks
  7. FFmpeg documentation
  8. Creative Commons Attribution 4.0
  9. W3C WAI: making audio and video accessible
  10. openai-python on GitHub
  11. Tether (USDT)
  12. ISO 639 language codes

More on this site