Frequently asked questions
What is the difference between TTS and SSML?
Our API is a text-to-speech service that converts input text into audio files. It does not support SSML, phoneme dictionaries, or custom pronunciation lexicons. You send plain text, and the engine generates the audio directly without markup tags for fine-grained control over pauses or emphasis.
How accurate is the language detection?
If the language field is omitted, the system guesses the language from the script. Latin script text defaults to English. For non-English Latin-script text, you should explicitly set the language parameter to ensure accuracy, as the system does not auto-detect all supported languages without this hint.
Can the API handle mixed-language text?
Yes, any voice can speak any of the 23 supported languages. However, you must specify the language parameter for each segment if it differs from the default. The API does not automatically switch languages within a single request; precise language codes ensure correct pronunciation.
Does the API support background noise?
The API generates clean synthetic speech without background noise. It does not support adding audio effects or background tracks. The output is a direct audio file containing only the synthesized voice, suitable for overlaying in your application’s interface or audio pipeline.
How is the audio quality measured?
Quality is determined by the model selected: tts-1 or tts-1-hd. Both use the same engine and price. The audio files are generated at standard sample rates for the chosen format (mp3, wav, opus, flac, or pcm) without additional quality tiers.
Can I adjust the pitch of the voice?
No, the API does not support pitch adjustment. You can only adjust the speed of speech between 0.25 and 4.0. The eight voice presets (e.g., aria, felix, atlas) provide distinct timbres, but their fundamental pitch remains fixed during synthesis.
What is the sample rate of the output?
The sample rate depends on the output format requested. You can choose mp3, wav, opus, flac, or pcm. The API returns the audio file directly in the response. Specific sample rates are determined by the codec and format you select in the request.
Is the API suitable for live conversations?
Yes, but with latency considerations. Typical speed is roughly real-time (25 characters per second). Short phrases take a few seconds. Requests are processed sequentially, so under load, a request may wait in a queue. It is not a streaming WebSocket solution.
How long does synthesis take for 1000 characters?
Synthesis takes roughly 40 seconds for 1000 characters, based on the typical speed of 25 characters per second. Short phrases may take a few seconds. Processing is sequential, so actual time may vary if the system is under heavy load.
Can I use the API for audiobook production?
Yes, the API supports long texts by splitting them into parts of up to 4096 characters and joining the audio files. Voices like luna are suited for storytelling. Note that generated files carry an inaudible watermark marking them as synthetic speech.
What codecs are supported for streaming?
The API supports mp3, wav, opus, flac, and pcm formats. It does not offer streaming or WebSocket endpoints; you receive the complete audio file in the response. For real-time needs, implement client-side buffering or polling with the standard HTTP endpoint.
Does the API support pausing and resuming?
The API does not support pausing and resuming mid-synthesis. You send a request, and the system processes it sequentially. If you need to pause, you must stop sending requests. The API returns the final audio file upon completion of the synthesis task.
How are emojis handled in the input text?
Emojis are treated as characters within the 4096-character limit. The system does not have a custom pronunciation lexicon, so emojis may be read aloud as their names or ignored depending on the voice engine’s internal handling. Explicit language setting helps ensure consistent behavior.
Is the audio file compressed by default?
Compression depends on the response_format you select. MP3 and Opus are compressed formats, while WAV, FLAC, and PCM are uncompressed or lossless. You choose the format in the request. The API does not apply default compression; it respects your specified output type.
The Synthesis Pipeline
VoiceStack’s text-to-speech API converts input strings into audio files through a streamlined two-step process. The system accepts standard UTF-8 text, validates character counts, and prepares the data for synthesis without requiring complex markup or preprocessing libraries.
Text preprocessing steps
The API receives raw text via a JSON payload, ensuring the input stays within the 4,096-character limit per request. Special characters and punctuation are treated as standard characters during billing, so no custom normalization is needed before sending the input field.
- UTF-8 encoded input text
- Character count validation (max 4,096 chars)
- No SSML or custom lexicon required
Audio waveform synthesis
Once validated, the text is processed by one of two models: tts-1 or tts-1-hd. The engine generates audio, which is then encoded into the requested format (mp3, wav, opus, flac, or pcm) and returned as a downloadable file in the response.
- Models: tts-1, tts-1-hd
- Formats: mp3, wav, opus, flac, pcm
- Inaudible synthetic watermark added
Integration with Chatbots
Since the API is non-streaming, chatbots must handle buffering. Retrieve the full audio file first, then play it to the user. This ensures smooth playback without choppy audio cuts, optimizing the user experience for voice interfaces.
Latency and Performance
Generation takes roughly 25 characters per second for long texts. Short phrases may take a few seconds due to queue processing. Requests are processed sequentially, so high volume can introduce slight delays.
- Speed: ~25 chars/sec
- Sequential processing
- Queue waiting times under load
Input Text Requirements
The API processes text in discrete chunks, enforcing a strict upper limit of 4096 characters per request. This constraint applies to the entire input string, including spaces and punctuation. For longer narratives or extensive dialogue logs, developers must implement client-side logic to split the content into valid segments before transmission.
Character limit constraints
Exceeding the 4096-character threshold results in a rejection. Since voice assistants often handle long-form instructions, splitting text into smaller, coherent segments ensures successful synthesis. The generated audio files are then joined on the client side to create a seamless listening experience.
- Maximum 4096 characters per request
- Includes spaces and punctuation in count
- Requires manual splitting for longer texts
Language script detection
The engine automatically infers the language from the script used. Latin script input defaults to English. For non-English text using Latin characters (e.g., French or German), explicitly setting the language parameter prevents mispronunciation and ensures accurate accentuation.
- Automatic script detection
- Latin script defaults to English
- Explicit language parameter recommended for Latin-script non-English text
Voice Selection Logic
VoiceStack offers eight distinct voice presets, each engineered for specific conversational contexts. Female options include Aria for warm narration, Nova for upbeat energy, Luna for storytelling, and Sage for clear instructions. Male selections feature Felix for promotional energy, Milo for friendly dialogue, Atlas for neutral news delivery, and Orion for deep documentary tones.
Preset voice characteristics
These voices are derived from licensed LibriTTS-R and LibriVox recordings, ensuring consistent quality without custom cloning. Each preset maintains a distinct tonal identity, allowing product teams to match the brand’s personality precisely, whether that requires a calm instructional tone or an energetic promotional voice.
- Aria: Warm, clear narrator
- Nova: Bright, upbeat energy
- Luna: Soft, storytelling tone
- Sage: Calm, instructional clarity
- Felix: Energetic, promotional style
- Milo: Friendly, conversational
Language-voice compatibility
All eight voices support 23 languages, including Arabic, Chinese, English, French, German, Japanese, and Spanish. A single voice can natively produce any supported language, eliminating the need for language-specific voice selection. For non-English Latin-script text, explicitly setting the language parameter ensures accurate pronunciation rather than relying on default English detection.
Speed adjustment effects
The speed parameter allows adjustment from 0.25x to 4.0x, enabling fine-tuned pacing for various use cases. Slower speeds enhance clarity for complex instructions, while higher speeds optimize efficiency for quick notifications. This range ensures the audio fits naturally within voice assistant workflows without distorting the synthetic speech quality.
Output Audio Formats
The API supports five distinct output formats, allowing product teams to balance audio fidelity against bandwidth constraints. You specify the desired format via the response_format parameter in your JSON request, ensuring the generated audio aligns with your application’s technical requirements.
MP3 compression benefits
MP3 is a common format, offering a compressed file size ideal for mobile chatbots and voice assistants where bandwidth efficiency matters. This format reduces data transfer costs while maintaining acceptable speech clarity for most conversational use cases.
WAV lossless quality
WAV provides uncompressed, lossless audio data, preserving the exact waveform generated by the TTS engine. This format is suitable for high-fidelity voice interfaces or when downstream processing requires raw audio data without compression artifacts.
Opus and FLAC options
Opus offers high-quality compression at lower bitrates than MP3, suitable for efficient data transfer. FLAC provides lossless compression, reducing file size compared to WAV while retaining all original audio data for archival or professional use.
- MP3: Default, compressed, bandwidth-efficient
- WAV: Uncompressed, lossless, high fidelity
- Opus: Efficient, high-quality compression
- FLAC: Lossless, reduced file size
- PCM: Raw, uncompressed data stream
Latency and Performance
Voice assistants require predictable audio generation times to maintain conversational flow. Our synthesis engine processes text at roughly one second of audio per 25 characters. Short phrases typically generate within a few seconds, while longer texts scale proportionally, allowing product teams to estimate response delays accurately for their specific use cases.
Generation time per character
Synthesis speed averages real-time performance, producing approximately 25 characters of text per second of audio. This consistent ratio helps developers predict latency for voice interfaces without complex calculations.
- ~25 characters per second of audio
- Short phrases take a few seconds
- Proportional scaling for longer texts
Queue waiting times
Requests are processed sequentially. Under heavy load, a request may wait in a queue before synthesis begins. This linear processing ensures consistent quality but can introduce slight delays during peak usage periods.
- Requests processed one after another
- Queuing occurs under high load
- No parallel burst processing
Impact of text length on speed
Longer texts must be split into chunks of up to 4096 characters. The system generates audio for each part and joins them. This chunking ensures stability but adds minor overhead for very long inputs.
- Max 4096 characters per request
- Audio parts are joined by the client
- Consistent quality regardless of length
Watermarking Synthetic Speech
Every generated audio file carries an inaudible watermark that marks it as synthetic speech. This digital signature is embedded during synthesis and remains intact across format conversions, ensuring that the origin of the audio can be verified without affecting playback quality or listener experience.
Inaudible watermark purpose
The watermark serves as a reliable indicator that the audio was generated by our text-to-speech API rather than recorded by a human voice actor. It provides a consistent method for identifying synthetic content across different languages and voice presets without altering the audible characteristics of the speech.
Detection of synthetic audio
Third-party tools can detect this specific watermark to distinguish our synthetic outputs from natural recordings. This capability helps platforms maintain transparency regarding automated voice interactions, which is increasingly important for user trust and regulatory compliance in voice assistant and chatbot applications.
Transparency in usage
By embedding this marker, we ensure that synthetic speech is distinguishable from human performance. This supports clear communication with end-users about whether they are interacting with an automated system or a recorded human voice, enhancing the overall integrity of voice-driven applications.

Error Handling in Synthesis
When a synthesis request fails, the API returns a clear error code without charging your balance. This ensures that billing remains accurate even when the engine encounters unexpected conditions during the generation process.
Understanding these failure modes allows product teams to implement robust retry mechanisms, ensuring seamless voice assistant experiences without unexpected charges for incomplete audio files.
Common synthesis failures
Synthesis failures typically occur when the input text exceeds the 4096-character limit per request or when the server is under heavy load. Failed requests are fully refunded, so you do not lose credit for these attempts.
Other failures may arise from malformed JSON bodies or invalid voice IDs. The API provides specific error messages to help identify the root cause quickly.
- Input text exceeds 4096 characters
- Invalid voice ID specified
- Malformed JSON request body
- Server under heavy load
Retry logic recommendations
Implement exponential backoff for failed requests to handle transient errors gracefully. Since requests are processed sequentially, a brief pause between retries can prevent overwhelming the queue.
Always check the error response to determine if the issue is recoverable. For example, if the error indicates a temporary server issue, a retry is appropriate; if it is a format error, retrying will not help.
Character encoding issues
Ensure your input text uses UTF-8 encoding to avoid silent failures or garbled audio. Special characters or unsupported scripts may cause synthesis to fail silently if not properly encoded.
Test your integration with edge-case characters like emojis or non-Latin scripts to ensure they are handled correctly by the TTS engine.
Language Detection Accuracy
Accurate language handling is critical for voice assistant clarity. The API automatically detects the script of your input text, defaulting to English for Latin characters. This simplifies integration but requires awareness for non-English languages using Latin scripts.
Latin script default behavior
If you do not specify a language, the system assumes English for any Latin-based input. This works well for standard English queries but may mispronounce French, Spanish, or Portuguese text if sent without explicit instruction.
Explicit language setting
To ensure correct pronunciation, always include the ISO language code in your request. This overrides the automatic detection and guarantees the engine uses the appropriate phonetic rules for the target voice.
- Set the
languagefield for non-English Latin text. - Supports 23 specific languages including Arabic, Chinese, and Hindi.
- Ensures consistent accent and intonation across your assistant.
Multi-language text limits
The engine handles single-language texts best. While any voice can speak any supported language, mixing languages in one request may lead to unnatural transitions. For complex multilingual content, consider splitting the text into separate requests.
Integration with Chatbots
Chatbots using VoiceStack receive complete audio files rather than streaming chunks, requiring a simple POST request to the speech endpoint. This synchronous model ensures reliable delivery of natural-sounding synthetic speech without the complexity of WebSocket connections or real-time partial audio streams.
Streaming vs non-streaming
Our API returns the full audio file upon completion, meaning your bot must wait for synthesis to finish before playing sound. This approach simplifies integration using standard HTTP libraries or the OpenAI SDK, avoiding the need to manage streaming state or handle interrupted audio chunks.
Buffering audio responses
Implement a brief buffer before playback begins to prevent the first few milliseconds of audio from cutting off abruptly. Since short phrases take a few seconds to generate, consider queuing the next response while the current audio plays to maintain a seamless conversational flow.
- Wait for the full audio file before initiating playback.
- Queue the next synthesis request during current audio playback.
- Handle network delays by pre-loading responses when idle.
User experience optimization
Use the speed parameter (0.25–4.0) to adjust playback tempo, ensuring the voice assistant sounds natural without rushing or dragging. For longer texts, split input into 4,096-character segments to keep generation times reasonable, preventing users from waiting too long for a single response.
- Adjust speed between 0.25 and 4.0 for better fit.
- Split long texts into 4,096-character chunks.
- Use buffer zones to mask generation latency.
Data Processing Privacy
VoiceStack prioritizes data privacy by strictly limiting how your input data is used. When you send text for synthesis, the input is processed solely to generate the requested audio file and is not retained for model training or other purposes. This ensures that your specific content remains isolated to the immediate generation task.
Input text retention policy
The raw text you submit is used exclusively for the synthesis process. Once the audio is generated and returned in the response, the input text is not stored long-term. This approach minimizes data exposure and ensures your content is not repurposed for improving the underlying engine.
Audio file storage duration
Generated audio files are returned directly in the API response and are not stored on our servers after delivery. This transient handling means your audio assets remain under your control, reducing the risk of unauthorized access or retention of your voice outputs.
Metadata billing records
We retain request metadata, including timestamp, character count, and status, primarily for accurate billing and usage tracking. This limited data ensures you are charged correctly for the characters processed and helps troubleshoot any issues with your account without retaining the actual content.
Technical Limitations
VoiceStack delivers natural-sounding speech through a straightforward API, but understanding its boundaries ensures smoother integration. Our model prioritizes reliability and clear pricing over complex markup, meaning developers must handle formatting in their own code rather than relying on the TTS engine for fine-grained control.
No SSML support impact
We do not support SSML, phoneme dictionaries, or custom pronunciation lexicons. This simplifies the request payload but requires your application to manage prosody, pauses, and emphasis externally. If precise timing or custom pronunciation is critical, you will need to split text or adjust inputs before sending them to the API.
Fixed voice presets only
The API offers eight distinct preset voices, including options like Aria, Nova, and Felix, rather than allowing custom voice cloning or design. Each voice is based on licensed recordings from LibriTTS-R and LibriVox. You cannot upload your own audio samples to create a unique voice profile; you must choose from the available presets to match your brand’s tone.
Standard speed range limits
Audio playback speed can be adjusted between 0.25x and 4.0x using the speed parameter. While this allows for significant acceleration or deceleration, extreme speeds may affect clarity. The engine processes requests sequentially, so under load, longer texts may experience queue delays, but the speed range remains consistent across all voices.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Your voice assistant must understand context, not just commands, to feel truly conversational to the user.
23 languages
Any voice speaks any of these languages.
