Frequently asked questions
What is the best voice for fairy tales?
Luna is optimized for soft, storytelling narration, while Aria offers a warm, clear narrator style. Both are suitable for children’s stories. You can also use Sage for calm, instructional content or Orion for deep, documentary-style readings. Since any voice can speak any supported language, choose based on the specific tone of your manuscript rather than a single "best" option.
How do I split a long book into chunks?
Split your text into parts of up to 4096 characters per request. Send each part via POST to the speech endpoint. Receive the individual audio files, then join them sequentially. This ensures each request stays within the character limit while maintaining the full narrative flow of your book.
Can I change the speed of the narration?
Yes, adjust the speed parameter between 0.25 and 4.0. This allows you to slow down narration for younger listeners or speed up content for older audiences. The default speed is 1.0. Adjustments apply to the entire generated audio file for that specific request.
Do I need to know how to code?
Coding is helpful but not required. You can use the official OpenAI SDKs by changing the base_url to our API endpoint. Alternatively, use ready-made curl examples provided on the dashboard. Plain HTTP requests also work, making integration accessible for both developers and technical publishers.
How do I handle special characters in text?
Standard JSON encoding handles special characters automatically. Ensure your text input is properly escaped in your JSON body. The API processes up to 4096 characters per request, including spaces and punctuation. No special formatting like SSML is supported.
What format should I use for audiobooks?
Use MP3 for broad compatibility or WAV for high-quality lossless audio. FLAC is also available for lossless storage. Select your preferred format via the response_format parameter in your API request. MP3 is typically sufficient for digital distribution platforms serving children’s audio content.
Can I use this for educational materials?
Yes, Sage is designed for calm, instructional content, making it ideal for educational materials. You can generate audio for textbooks, guides, or learning modules. The API supports 23 languages, allowing you to create multilingual educational resources efficiently using the same text-to-speech infrastructure.
How do I detect the language automatically?
If you do not set the language field, the API guesses the language from the script. Latin script defaults to English. For non-English Latin text, you should explicitly set the language parameter to ensure accurate pronunciation and avoid incorrect language detection assumptions.
What if the text is in multiple languages?
The API supports 23 languages, but each request handles one language. If your text mixes languages, split the text by language and send separate requests. Specify the language parameter for each request to ensure correct pronunciation for each segment within your multi-language manuscript.
Is the audio watermark audible?
Every generated file carries an inaudible watermark marking it as synthetic speech. Listeners will not hear it during playback. This watermark helps identify the audio as synthetic speech.
Can I regenerate a specific chapter?
Yes, send a new POST request with the text for that specific chapter. You can adjust parameters like voice or speed for just that chapter. Each request is processed independently, allowing you to refine individual sections without regenerating the entire book from scratch.
How do I track my API usage?
The dashboard on /get-api-key/ shows your balance, characters left, and usage history. Request metadata including time, characters, and status is kept for billing. You can monitor your character consumption directly on the account page to manage your budget and top-ups effectively.
What happens if the internet cuts out?
If a request fails, the charge is returned in full. You can simply retry the request for the same text. Failed requests do not consume your character balance. Ensure your client handles retries gracefully to avoid duplicate charges if the network stabilizes quickly.
Can I use this for commercial books?
Yes, the API is designed for commercial use by publishers. Generated audio is returned in the response and not stored by us. Input text is used only to produce audio and not for training. You retain control over your generated audio files for distribution.
Prepare Your Text Manuscript
Before sending text to the API, ensure your manuscript is clean and properly formatted. Remove any markdown artifacts or stray symbols that might confuse the synthesis engine. The input field accepts plain text up to 4,096 characters per request, so you must manage your file structure accordingly.
Spaces and punctuation count as characters, so precise formatting helps avoid unexpected limits. Verify that your text is ready for processing before initiating the first API call to ensure a smooth production workflow for your children's book audio files.
Clean Your Text
Strip out non-essential formatting like bolding or italics unless they are represented in plain text. Ensure there are no hidden control characters that could interrupt the synthesis process.
Use standard English punctuation. The API guesses the language based on the script, so clear Latin text defaults to English. For non-English languages, explicitly set the language code to avoid mispronunciation.
- Remove markdown symbols
- Check for hidden characters
- Ensure standard punctuation
Check Character Limits
The API accepts a maximum of 4,096 characters per single request. This limit includes all spaces and punctuation marks within your input string.
Plan your chapter breaks to fit within this constraint. If your text exceeds this limit, you will need to split it manually before sending the request to the endpoint.
- Max 4,096 characters per request
- Include spaces in count
- Plan chapter breaks
Split Long Chapters
For chapters longer than 4,096 characters, divide the text into smaller segments. Generate audio for each segment individually.
Once all segments are generated, you can concatenate the resulting audio files to create a complete chapter. This ensures stable processing and avoids timeouts during synthesis.
- Divide text into 4,096-char chunks
- Generate segments individually
- Concatenate final audio files
Select the Right Narrator Voice
Choosing the right voice ensures your children's books engage young listeners without sounding artificial. Our API offers eight distinct presets, each derived from licensed recordings or public-domain audiobook readings. Selecting a voice that matches the tone of your manuscript is the first step toward professional-quality audio books.
Each voice carries specific characteristics suitable for different narrative styles. Whether you need a calm instructional tone or an energetic promo style, the system supports multiple languages and allows you to specify the language code to ensure accurate pronunciation for non-English texts.
Warm Narrator Aria
Aria provides a warm, clear narrator voice ideal for classic fairy tales and gentle storytelling. Her tone is consistent and easy to follow, making her suitable for young children listening to longer texts.
Use Aria when you want a steady, reassuring pace that keeps listeners engaged without overwhelming them with rapid speech.
- Ideal for bedtime stories
- Clear enunciation
- Consistent pacing
Upbeat Nova Voice
Nova offers a bright, upbeat tone perfect for energetic children's books or educational content. Her voice adds energy to repetitive texts or interactive stories where enthusiasm helps maintain attention.
Nova’s speed can be adjusted between 0.25 and 4.0 to suit the rhythm of your manuscript, ensuring the audio feels lively but not rushed.
- Bright and energetic
- Good for educational content
- Adjustable speed
Storytelling Luna Tone
Luna delivers a soft, storytelling tone that creates an immersive atmosphere for fantasy or adventure narratives. Her voice is designed to draw listeners into the world of the story without distracting from the text.
Pair Luna with slower speeds for dramatic effect or faster speeds for action sequences, allowing you to control the emotional tone of each scene.
- Soft and immersive
- Suitable for fantasy
- Emotional range
Configure API Settings
To ensure the narration matches your target audience, configure the speed and format before generating audio. Adjust the speed parameter between 0.25 and 4.0 to control pacing, keeping default speeds for natural storytelling. Choose between mp3, wav, opus, flac, or pcm formats based on your distribution platform's requirements.
Set Speed Parameters
Use the speed field in your request to adjust playback rate. Values range from 0.25 (slow) to 4.0 (fast). For children's stories, a speed near 1.0 is typically optimal for clarity.
Choose Audio Format
Select response_format from mp3, wav, opus, flac, or pcm. MP3 offers compression for web delivery, while WAV or FLAC provides lossless quality for archival audiobooks. PCM is raw data for custom processing pipelines.
- MP3: Standard for web and mobile apps
- WAV/FLAC: High fidelity for professional distribution
- OPUS: Efficient bandwidth usage for streaming
Define Language Code
Explicitly set the language ISO code (e.g., en, de, fr) to ensure accurate pronunciation, especially for non-English Latin scripts. If omitted, the system guesses the language, defaulting to English for Latin text.
- Supported: Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, Turkish
Send the Request
Once your manuscript is split into manageable chunks, you are ready to generate the audio. Each request must be sent individually to the API, respecting the 4096-character limit per segment. This ensures consistent quality and prevents truncation errors during synthesis.
You will construct a standard JSON payload containing the text, voice selection, and format preferences. The API processes these requests sequentially, so under high load, there may be a brief queue delay before synthesis begins.
Construct JSON Body
Create a JSON object with the required fields. Use model set to tts-1 or tts-1-hd. Provide your text in the input field, ensuring it does not exceed 4096 characters. Specify the voice preset, such as aria for a warm narrator tone. Include response_format like mp3 or wav and set speed between 0.25 and 4.0 if needed. Add an optional language ISO code if the text is not English.
The request body also requires your API key in the Authorization header. Ensure the key starts with tts-. If you are processing multiple chapters, prepare separate JSON objects for each segment to maintain clear boundaries between audio files.
- Use
tts-1ortts-1-hdfor the model - Limit
inputto 4096 characters - Set
voiceto one of the 8 presets - Choose
response_formatfrom mp3, wav, opus, flac, or pcm - Set
speedbetween 0.25 and 4.0 - Add optional
languageISO code
Execute Curl Command
Use curl to send the POST request to https://api.1996wc.net/v1/audio/speech. Include the JSON body and the authorization header. The command structure remains identical to OpenAI’s speech endpoint, making it easy to adapt existing code using the OpenAI SDKs or plain HTTP. Replace the base URL and API key with your specific credentials.
Example: `curl -X POST https://api.1996wc.net/v1/audio/speech -H "Authorization: Bearer tts-..." -H "Content-Type: application/json" -d '{"model":"tts-1","input":"...","voice":"aria","response_format":"mp3"}'`
- Use
POSTmethod - Set
Authorization: Bearer tts-... - Set
Content-Type: application/json - Point to
https://api.1996wc.net/v1/audio/speech
Validate Response
A successful request returns an audio file in the specified format. If the synthesis fails, the request is free, and you receive an error message. Check the HTTP status code to confirm success. For 200 OK, the response body contains the binary audio data or a link to the file.
If you receive a rate limit error, wait before retrying. The limit is 60 requests per minute per key. Monitor your response time to ensure the generation is proceeding as expected. Save the audio file immediately to avoid data loss.
- Check HTTP 200 status
- Verify audio file format
- Handle error responses
- Monitor rate limits
Process the Audio Output
After the API returns the audio blob, save the file locally. The response contains the binary audio data, which you should write directly to disk using your preferred HTTP library.
Once downloaded, verify the file integrity. Each segment corresponds to a specific text chunk, ensuring no data loss during the transfer process.
Download Audio File
Receive the binary audio data from the POST response. Save this stream to a temporary file on your server. Ensure your code handles large responses efficiently, especially when using high-bitrate formats like FLAC or WAV.
Validate the HTTP status code. A 200 OK confirms successful synthesis. If you receive an error, check your balance and key validity before retrying.
- Save binary data to a .mp3 or .wav file
- Check for HTTP 200 status
- Handle large file streams efficiently
Concatenate Segments
Since texts over 4096 characters are split, you must merge the resulting audio files. Use a library like FFmpeg to join the segments in the correct order. This ensures a seamless listening experience for the child.
Maintain the original sequence. The API returns files in the order of the input text chunks. Incorrect concatenation will scramble the story narrative.
Verify the total duration matches your expectations. Long texts should generate audio at roughly real-time speed, so the combined length should reflect the total character count.
- Use FFmpeg to join segments
- Maintain original text order
- Verify total audio duration
Add Watermark Note
Every generated file contains an inaudible watermark marking it as synthetic speech. You do not need to add this manually, but you should disclose it in your audiobook metadata or description.
This watermark helps listeners identify AI-generated narration. Include a note in your book’s credits or product page stating that the audio was created using synthetic voice technology.
- Watermark is inaudible and automatic
- Disclose synthetic nature in metadata
- Add credit to book description
Test the Audio Quality
Quality assurance ensures your audiobooks meet professional standards before distribution. Since synthesis is processed sequentially, verifying clarity and timing prevents costly re-issues. Use the free trial credit to test voices before committing to bulk production.
Focus on narrative flow and technical accuracy. Each generated file contains an inaudible watermark, confirming synthetic origin. Regular testing helps maintain consistency across long chapters and multiple narrator voices.
Listen for Clarity
Play the output through standard headphones or speakers to check for background noise or distortion. Ensure the voice remains clear even at higher speeds. Listen for smooth transitions between sentences to avoid abrupt cuts that disrupt the story's flow.
Verify that the audio level is consistent. If using the 'warm' Aria or 'soft' Luna voices, ensure the tone remains engaging without becoming muffled. Adjust the speed parameter if the narration feels too rushed for young listeners.
- Check for consistent volume levels across segments.
- Verify no distortion at high speeds (e.g., 2.0x).
- Ensure smooth sentence transitions without abrupt stops.
Check Pronunciation
Listen carefully for correct pronunciation of names, places, and special terms specific to your fairy tales. The API guesses language from script, but explicit language codes improve accuracy for mixed-text passages. Verify that non-English terms are pronounced correctly if included.
Test edge cases like abbreviations or numbers. If the model mispronounces a unique name, consider spelling it phonetically in the input text to ensure correct delivery without needing custom lexicons.
- Verify proper names and places are pronounced correctly.
- Test mixed-language sections with explicit language codes.
- Check numerical values and abbreviations for accuracy.
Verify Timing
Measure the duration of the audio against the text length. Typical generation is roughly real-time (25 characters per second). Ensure the pacing matches the intended reading speed for children's stories.
Check that the total duration aligns with your publishing platform's requirements. If segments are too short or long, adjust the speed parameter (0.25–4.0) to fit desired lengths without sacrificing clarity.
- Confirm audio length matches expected reading time.
- Adjust speed to fit platform duration limits.
- Ensure pacing suits the target age group.
Integrate into Your Workflow
Automating your TTS pipeline ensures consistent audiobook production. By integrating the API into your content management system, you can trigger audio generation directly from your manuscript drafts, reducing manual steps and ensuring that new stories are ready for publication immediately.
This integration minimizes human error in file naming and formatting, keeping your digital library organized.
Batch processing allows you to send multiple text segments simultaneously, leveraging the 60 requests per minute limit.
You can process multiple segments in parallel, leveraging the 60 requests per minute limit efficiently to keep your publishing schedule on track.
Quality assurance remains critical even with automation. Implement a checksum validation to ensure each audio segment matches its corresponding text segment, preventing silent failures or corrupted files from entering your final audiobook files.
Regularly review usage logs to verify that character counts match your manuscript lengths, ensuring accurate billing and predictable costs.
Automate Publishing
Automating your TTS pipeline ensures consistent audiobook production. By integrating the API into your content management system, you can trigger audio generation directly from your manuscript drafts, reducing manual steps and ensuring that new stories are ready for publication immediately.
This integration minimizes human error in file naming and formatting, keeping your digital library organized.
- Trigger API calls on manuscript draft updates
- Auto-tag audio files with chapter metadata
- Sync generated MP3s to your digital store
Batch Processing
Batch processing allows you to send multiple text segments simultaneously, significantly reducing total generation time compared to sequential requests.
You can process entire chapters in parallel, leveraging the 60 requests per minute limit efficiently to keep your publishing schedule on track.
- Split chapters into 4096-character segments
- Send concurrent requests to the API
- Reassemble segments using a simple script
Quality Assurance
Quality assurance remains critical even with automation. Implement a checksum validation to ensure each audio segment matches its corresponding text segment, preventing silent failures or corrupted files from entering your final audiobook files.
Regularly review usage logs to verify that character counts match your manuscript lengths, ensuring accurate billing and predictable costs.
- Validate audio file integrity post-generation
- Check pronunciation consistency across segments
- Review billing logs for anomalies
Handle Edge Cases
Children's manuscripts often contain unique elements that require careful handling to ensure accurate audio synthesis. Understanding how the API processes special formatting, punctuation nuances, and language transitions helps prevent unintended pauses or mispronunciations in the final output.
Special Characters
The API handles standard Latin script characters well. However, complex emojis or non-standard symbols may be ignored or cause slight pauses. Stick to standard text for reliable results.
- Standard punctuation is processed automatically.
- Emojis may introduce brief silences.
- Avoid excessive special symbols in dialogue.
Punctuation Handling
Punctuation marks directly influence pacing. Commas create short pauses, while periods signal full stops. The TTS engine respects these cues, so ensure your manuscript has correct punctuation for natural flow.
- Use commas for brief pauses.
- Periods create natural break points.
- Exclamation marks add emphasis.
Language Switching
If your story mixes languages, explicitly set the language parameter for each segment. Without it, the system guesses based on script, which may default to English for Latin text. This ensures accurate pronunciation for non-English segments.
- Set
languagecode explicitly. - Prevent incorrect language guessing.
- Ensure accurate multi-language delivery.
Scale Your Production
Scaling production for children’s books requires managing the API’s request limits and account balance effectively. Publishers should monitor their usage to ensure continuous generation without unexpected pauses during batch processing.
Rate Limits
Your API key allows 60 requests per minute once funded, but starts at a lower 10 requests per minute threshold before the first top-up. For long fairy tale collections, split texts into chunks of 4,000 characters or fewer to stay within single-request bounds and avoid queuing delays.
Manage Balance
Costs are $0.01 per 1,000 characters, so large manuscripts accumulate charges quickly. Top-ups via USDT on TRON (TRC-20) credit automatically within minutes, with no minimum spend or monthly fees. Unused balance never expires, allowing you to fund once and generate audio for multiple titles over time.
- Use the dashboard to view current balance and character usage.
Monitor Usage
Track character consumption and request status via the /get-api-key/ dashboard. Failed requests do not consume credit, ensuring you only pay for successful audio synthesis. Regular monitoring helps you predict costs for upcoming book releases and adjust split strategies accordingly.
Distribute the Audio
Once your audio segments are concatenated, you can distribute them through standard digital channels. Since the output is a standard audio file (mp3, wav, opus, flac, or pcm), it integrates seamlessly with most ebook platforms and audio streaming services without requiring proprietary converters.
Upload to Platforms
Upload your final audio files directly to distribution platforms. The generated files are self-contained and ready for immediate use. Ensure the file format matches the platform’s requirements, such as mp3 for broad compatibility or opus for efficient streaming.
Create Audiobook Files
Combine your segmented audio files into a single track for a cohesive listening experience. Use standard audio editing tools to join the parts. The inaudible watermark remains embedded, marking the file as synthetic speech without affecting playback quality.
- Ensure seamless transitions between chapters
- Maintain consistent volume levels
- Verify file integrity before upload
Share with Readers
Share the audio files via direct download links or embed them in your website’s child-friendly interface. Provide clear instructions for playback on various devices. Since the audio is standard format, readers can use any compatible media player.
Troubleshoot Common Issues
When generating audio for children's books, minor hiccups can interrupt your workflow. Silent audio usually indicates a failed request or empty input. Slow generation often results from queueing during high load or exceeding the 4096-character limit per request. Format errors typically stem from incorrect response_format values or network timeouts.
Understanding these common issues helps you maintain steady production without losing voice credits or wasting time on debugging.
Silent Audio
Check your response status code. If the request failed, the charge is returned in full, so no cost is incurred. Ensure the input text is not empty and within the 4096-character limit. Verify that your API key is active and not expired.
If the audio is silent but the status is 200, check the file integrity. The inaudible watermark should be present, confirming synthetic generation.
- Verify HTTP 200 status
- Check input text length
- Confirm API key validity
Slow Generation
Requests are processed sequentially. If many keys are active, your request may wait in a queue. For long texts, split into parts of up to 4096 characters to reduce individual processing time.
Typical speed is roughly real-time (25 characters per second). Short phrases may take a few seconds due to initialization overhead.
- Split long texts
- Monitor queue status
- Adjust speed parameter
Format Errors
Ensure response_format is one of: mp3, wav, opus, flac, or pcm. Incorrect values may cause the API to reject the request or return invalid data.
Verify that the voice parameter matches one of the 8 available presets. Mismatched voices can lead to unexpected audio characteristics or errors.
- Use valid format codes
- Check voice presets
- Validate JSON structure
Optimize for Cost Efficiency
Optimizing costs begins with precise text management. Since every character counts toward the $0.01 per 1,000 character rate, removing redundant spaces or unnecessary punctuation before submission can lower expenses. Ensure your manuscripts are clean to avoid paying for invisible overhead.
Leverage the speed parameter to balance generation time and cost efficiency. Faster speeds reduce processing queue time, though they do not change the per-character price. For long fairy tales, splitting text into 4,096-character chunks ensures consistent processing without timeout risks.
Reduce Unnecessary Chars
Review your text for repetitive filler words or excessive whitespace. Each space and punctuation mark is billed as a character. Cleaning your source text directly reduces the total character count, lowering the final invoice amount without affecting audio quality.
- Remove extra spaces between words.
- Eliminate redundant adjectives or adverbs.
- Strip unnecessary markdown formatting.
Use Speed Settings
Adjust the speed parameter between 0.25 and 4.0 to manage processing time. While speed does not alter the per-character cost, faster generation reduces queue wait times during high load, ensuring timely delivery for your publishing schedule.
- Set speed to 1.0 for standard narration.
- Increase speed for short, simple phrases.
- Decrease speed for complex storytelling sections.
Batch Requests
Split long texts into segments of up to 4,096 characters. This ensures each request is processed efficiently and allows you to join audio files seamlessly. Batch processing helps manage your 60 requests per minute limit effectively.
- Split text at logical chapter breaks.
- Process multiple segments concurrently.
- Join audio files using a standard editor.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. This ensures that the base audio data used to train the voice models is free from restrictive copyright claims.
23 languages
Any voice speaks any of these languages.
