How to Read Kindergarten Books with TTS API?

By Lumivox editorial team · Updated 2026-11-18

This guide walks self-publishers and content creators through converting kindergarten books into readable audio files using the Lumivox TTS API. We cover the entire workflow, from preparing clean text and selecting appropriate voices to handling long narratives by automatically splitting and joining audio segments. You will learn how to manage character limits, optimize your budget, and ensure high-quality output for young listeners.

By following these steps, you can focus on your story while the API handles the technical details. This page provides practical, step-by-step instructions tailored to audiobook creation, helping you avoid common pitfalls and publish your audio book efficiently without needing specialized software or voice acting skills.

How to Read Kindergarten Books with TTS API?

Frequently asked questions

What is the best voice for kindergarten books?

Luna suits soft storytelling, while Aria offers a warm, clear narration style. Sage provides a calm, instructional tone for educational content, and Nova brings a bright, upbeat energy. All eight voices support every language, letting you match the narrative mood to your book’s target audience effectively.

How do I split a long book into parts?

Split your text into segments of up to 4096 characters per request. You must split the text into segments of up to 4096 characters and join the resulting audio files yourself. This ensures that long manuscripts are converted into coherent audio files without exceeding character limits for each individual synthesis call.

Can I use the same voice for all chapters?

Yes, you can use any of the eight preset voices for every chapter. Since voices are consistent presets, maintaining the same voice ensures narrative continuity across your entire kindergarten book. You simply specify the desired voice in each API request to keep the character consistent throughout.

How do I join multiple audio files?

The API returns separate audio files for each chunk; you must join them manually. You send the text in chunks, and the system returns separate audio files for each chunk. This eliminates the need for manual audio editing, allowing you to focus on the story content itself.

What is the maximum file size?

The API limits input text to 4096 characters per request. You must split the text into chunks of up to 4096 characters and join the audio files yourself. There is no explicit maximum output file size, but typical generation speed is roughly real-time, producing standard-sized audio files suitable for digital distribution.

Do I need to pay for each chapter separately?

You pay based on total characters processed, not per chapter. The rate is $10 per 1 million characters. Whether you process one chapter or a full book, the cost is calculated from the total character count, including spaces and punctuation, across all requests.

Can I change the speed of the audio?

Yes, you can adjust the speed between 0.25 and 4.0. This allows you to slow down narration for younger listeners or speed up content for older children. Simply include the speed parameter in your API request to customize the playback rate for your specific audience.

How do I handle punctuation in text?

Punctuation counts as characters in your usage billing. Standard punctuation is processed naturally by the TTS engine. Ensure your text is properly formatted before sending it to the API, as the system does not automatically correct grammatical errors or adjust punctuation for audio flow.

Is the audio quality high enough for kids?

The audio is generated using licensed recordings from LibriTTS-R and LibriVox. It includes an inaudible watermark marking it as synthetic speech. The quality is clear and suitable for children’s content.

Can I use the API for commercial books?

Yes, the API is suitable for commercial use. Input text is used only to produce audio and is not used for training. Generated audio is returned in the response and not stored, allowing you to distribute your audiobooks freely without ongoing licensing fees beyond the API usage.

What happens if a request fails?

If synthesis fails, the charge is returned in full. You are not billed for failed requests. This ensures you only pay for successfully generated audio files. You can retry the request or adjust parameters like text length or voice selection to resolve the issue.

How do I track my API usage?

Your account dashboard displays your balance, characters left, and usage history. You can view request metadata, including time, characters, and status, directly on the /get-api-key/ page. This allows you to monitor spending and character consumption accurately without needing external tools or third-party integrations.

Can I use the API on a website?

Yes, you can integrate the API into your website using standard HTTP requests or the OpenAI SDK. Change the base URL to https://api.getx99.com/v1 and use your API key. This allows you to generate audio dynamically for your users or content creators directly from your site.

Do I need to install any software?

No software installation is required. You can use the API via standard HTTP requests or the official OpenAI SDK. Simply install the SDK in your preferred programming language and configure the base URL. This works on any platform that supports standard web protocols and JSON.

Prepare Your Text

Sound wave illustration for: Prepare Your Text

Before sending text to the TTS API, verify your total character count. Each request accepts up to 4,096 characters, including spaces and punctuation. For typical kindergarten books, you will need to split the manuscript into manageable chunks to ensure smooth generation and accurate timing.

Check character count

Count every character in your source file. Since the API charges $0.01 per 1,000 characters, knowing your exact length helps you estimate costs and manage your $0.50 trial credit effectively. Remember that failed requests are free, but successful ones are billed immediately.

  • Include spaces and punctuation in your count
  • Limit each request payload to 4,096 characters
  • Track usage via the /get-api-key/ dashboard

Split into 4096 char chunks

Divide your manuscript into segments not exceeding 4,096 characters. You can generate audio for each segment separately and join them later. This approach prevents truncation and allows you to handle long stories by splitting them into manageable chunks.

Use simple string splitting logic based on character length. If a sentence is cut off, ensure the next chunk begins with a capital letter to maintain natural speech flow during the final concatenation step.

  • Max 4,096 characters per POST request
  • Maintain word boundaries where possible
  • Keep a record of chunk order

Ensure clean formatting

  • Use plain text or simple JSON strings
  • Escape special characters properly
  • Verify UTF-8 encoding compatibility

Choose a Voice

Sound wave illustration for: Choose a Voice

Lumivox offers eight distinct voice presets designed to suit different narration styles for kindergarten content. Selecting the right voice is crucial for engaging young listeners, as the tone sets the emotional baseline for the story.

Select warm narrator voice

For a clear, professional narration style, aria provides a warm and clear delivery. This voice is ideal for straightforward reading where clarity is the priority. It ensures that every word is understood without distraction.

  • Best for clear, direct narration
  • Warm and approachable tone
  • High intelligibility for young listeners

Pick soft storytelling tone

If your book relies on atmosphere, luna offers a soft, storytelling quality. Her gentle delivery helps create a calming environment suitable for bedtime stories or imaginative tales. This tone keeps children engaged without being overstimulating.

  • Ideal for bedtime stories
  • Soft and gentle delivery
  • Enhances imaginative atmosphere

Test voice with short text

Before processing your entire manuscript, generate a short audio clip using the API. This allows you to verify that the voice matches your vision. You can adjust the speed parameter between 0.25 and 4.0 to find the perfect pacing.

  • Generate short sample clips
  • Adjust speed from 0.25x to 4.0x
  • Verify tone before bulk generation

Send Request

Sound wave illustration for: Send Request

To generate speech, send a JSON payload to the POST /v1/audio/speech endpoint. The request body requires the model, input text, voice preset, response_format, and optional speed or language parameters. This endpoint accepts texts up to 4096 characters, returning an audio file directly in the response for that chunk.

Use POST /v1/audio/speech

Construct your request with the required fields: model ("tts-1" or "tts-1-hd"), input containing your kindergarten story text, and voice selected from the eight presets. Specify response_format as mp3, wav, opus, flac, or pcm. The API processes requests sequentially, so under load, generation may take longer than real-time for short phrases.

  • Endpoint: POST https://api.getx99.com/v1/audio/speech
  • Supported formats: mp3, wav, opus, flac, pcm
  • Character limit: 4096 per request

Include API key in header

Authenticate your request by including the header Authorization: Bearer tts-... with your unique API key. You can retrieve this key from your account dashboard at /get-api-key/. Each account holds one active key; issuing a new one immediately invalidates the previous one.

  • Header: Authorization: Bearer tts-...
  • One active key per account
  • Manage keys via /get-api-key/

Set language code if needed

Include the language field with an ISO code (e.g., "en", "de", "ja") to ensure accurate pronunciation, especially for non-English Latin-script text. If omitted, the system guesses the language, defaulting to English for Latin scripts. This ensures your kindergarten book’s narration matches the target audience’s language.

  • Optional ISO code (e.g., "en", "de")
  • Defaults to English for Latin script
  • Supports 23 specific languages

Handle Response

Sound wave illustration for: Handle Response

After your API call succeeds, you receive the audio data directly in the response body. This binary or base64-encoded content must be immediately saved to your local storage or cloud bucket to preserve the generated kindergarten book narration.

Ensure your application handles the response stream efficiently to avoid memory issues, especially when processing long texts split into multiple chunks.

Save audio file

Write the response body to a file with the appropriate extension (mp3, wav, opus, flac, or pcm). Use the response_format you requested to ensure compatibility with your audiobook player or publishing platform.

Store the file with a clear naming convention that matches the text chunk sequence for easy later concatenation.

  • Save immediately to prevent data loss
  • Use the requested format (mp3, wav, etc.)
  • Name files sequentially for joining

Check status code

Verify that the HTTP status code is 200 OK. A 200 code confirms successful synthesis and no charge will be incurred for this request.

If you receive a 4xx or 5xx error, the request failed, and the character count will be returned to your balance.

  • 200 OK: Success, audio generated
  • 4xx/5xx: Failure, no charge
  • Retry failed requests if needed

Verify audio quality

Play the generated audio to ensure clarity and correct pacing. Listen for any artifacts or unexpected pauses in the narration.

Check that the voice matches your selection (e.g., Aria for a warm narrator) and that the language is correct.

  • Listen for clarity and tone
  • Verify voice selection
  • Check language accuracy

Join Audio Files

Sound wave illustration for: Join Audio Files

After generating individual audio segments, you need to merge them into a single file. Since the API returns separate audio files for each 4096-character chunk, manual concatenation ensures your kindergarten book plays as one continuous story.

Concatenate MP3 files

Use a command-line tool like ffmpeg to merge MP3 files sequentially. This method is fast and preserves the original quality without re-encoding, making it ideal for processing multiple chapters or long stories efficiently.

  • Use ffmpeg -f concat for seamless merging
  • Preserves original bitrate and quality
  • Fast processing for batch jobs

Use audio editing software

For more control, import the files into a digital audio workstation (DAW). This allows you to visually inspect waveforms, remove any unexpected silences, and adjust volume levels to ensure consistent listening experience for young audiences.

  • Visual waveform inspection
  • Manual silence removal
  • Volume normalization

Ensure smooth transitions

Check that the end of one clip blends naturally into the next. Since the API splits text at character limits rather than narrative pauses, you may need to add brief crossfades or slight pauses to maintain storytelling flow.

  • Add crossfades between clips
  • Maintain narrative pacing
  • Prevent jarring audio cuts

Test the Output

Sound wave illustration for: Test the Output

After generating your kindergarten book audio, verify that the synthetic speech matches your story’s intent. Listen closely to ensure the narration is clear and the chosen voice conveys the appropriate tone for young listeners.

Listen for clarity

Play the generated audio to check if the voice sounds natural and easy to understand. Ensure the tone fits the narrative style, whether it is a warm narrator or a soft storytelling voice. Verify that the audio does not contain unexpected artifacts or distortion that might distract young listeners.

  • Listen for consistent volume and tone
  • Check for natural pacing and breaths
  • Ensure no audio distortion or glitches

Check for errors

Review the audio file for any missing words, incorrect pronunciations, or strange pauses. Compare the audio against your original text to ensure all parts of the story are included. If any errors are found, regenerate the specific segment using the API.

  • Verify text-to-audio alignment
  • Check for missing or extra words
  • Ensure correct pronunciation of names

Validate timing

Confirm that the audio duration aligns with the expected length based on the character count. Long texts should take roughly 25 characters per second to generate, ensuring a realistic reading pace. Adjust the speed parameter if the audio is too fast or slow for your audience.

  • Check audio duration vs. text length
  • Adjust speed parameter if needed
  • Ensure consistent pacing throughout

Optimize Workflow

Sound wave illustration for: Optimize Workflow

Automate your text splitting logic to handle long kindergarten stories efficiently. Since each request supports up to 4,096 characters, use a script to divide your manuscript into manageable chunks before sending them to the API. This ensures consistent processing and prevents errors from oversized inputs.

Automate splitting process

Write a simple script to split your text into 4,096-character segments. This prepares your content for batch submission, ensuring no story segment is lost or truncated. Clean formatting helps maintain audio continuity when the files are later joined.

  • Split text into 4,096-character chunks
  • Preserve paragraph breaks for natural pauses
  • Use UTF-8 encoding for all scripts

Batch request processing

Send multiple synthesis requests in parallel to reduce total generation time. The API processes requests sequentially, so under load a request may wait in a queue. Monitor your key’s usage to avoid unnecessary delays.

  • Queue chunks for parallel submission
  • Track request IDs for each chunk
  • Handle retries for failed requests

Monitor rate limits

You are limited to 60 requests per minute per key. If your book has many chunks, pace your submissions to stay within this limit. Exceeding the limit may result in delayed processing or errors, so implement a simple throttling mechanism in your workflow.

  • Limit: 60 requests per minute
  • Use exponential backoff on errors
  • Check status codes for throttling
Optimize Workflow

Manage Costs

Sound wave illustration for: Manage Costs

Understanding your character consumption helps you plan long kindergarten stories without unexpected charges. The API charges $10 per 1 million characters, meaning every space and punctuation mark counts toward your total. Failed requests are free, so you can experiment without risk.

Track character usage

Monitor your balance and character count directly on the dashboard. This transparency allows you to estimate how many books you can process before needing a top-up.

  • Spaces and punctuation count as characters.
  • Failed requests incur no charge.
  • Balance never expires.

Use trial credit wisely

New Google sign-ins receive $0.50 in credit, covering roughly 50,000 characters for seven days. Email accounts start without this trial, so plan your first batch accordingly. Use this time to test voice selection and audio quality.

Top up USDT as needed

Add funds via USDT on the TRON network (TRC-20). The minimum deposit is $5, and credits appear automatically within minutes. This method avoids credit cards and monthly subscriptions.

  • Minimum top-up: $5.
  • Network: TRC-20 (TRON).
  • No VAT or invoices.

Publish Your Audiobook

Sound wave illustration for: Publish Your Audiobook

Once your audio files are stitched together, you have a complete audiobook ready for distribution. This format is widely accepted by major self-publishing platforms, allowing you to reach listeners who prefer audio over text. The process is straightforward: prepare your final MP3 file and ensure it matches the metadata of your book.

Pairing your audio with professional cover art ensures your title stands out in digital stores. Consistency between your book’s visual design and audio presentation builds trust with your audience, making it easier for parents and educators to identify your content.

Upload to platforms

Select a self-publishing platform that supports audiobook distribution. Upload your concatenated MP3 file along with the corresponding book metadata. Ensure the audio file name matches your title for easy identification.

  • Choose platforms like ACX or iTunes Connect
  • Verify audio format compatibility (MP3)
  • Match metadata with your printed book

Add cover art

Design cover art that reflects the tone of your kindergarten book. Use bright, engaging visuals that appeal to children and parents. Ensure the image meets the platform’s resolution and size requirements.

  • Use high-resolution images (300 DPI)
  • Maintain consistent branding across formats
  • Include title and author name clearly

Share with listeners

Promote your audiobook through social media, email newsletters, and parenting blogs. Highlight the convenience of listening on-the-go. Encourage reviews to boost visibility and credibility in the self-publishing community.

  • Leverage social media channels
  • Send newsletters to existing subscribers
  • Engage with parenting communities

Troubleshoot Issues

Sound wave illustration for: Troubleshoot Issues

Even with a working setup, small details can interrupt the generation process. Most issues stem from authentication errors or unexpected text characters that confuse the synthesis engine.

Check API key validity

Ensure your key starts with tts- and is active. If you issued a new key, the old one stops immediately. Verify the key in the /get-api-key/ dashboard matches the Authorization: Bearer header.

  • Keys expire instantly upon regeneration
  • Only one active key per account

Verify text encoding

Send clean UTF-8 text. The API handles standard Latin and non-Latin scripts but may fail on complex formatting. Keep input under 4096 characters per request to avoid split errors.

  • Use plain text or simple HTML
  • Limit input to 4096 characters

Contact support by email

If issues persist, email us. We do not offer phone support or live chat. Provide your account email and request details for the fastest resolution.

Best Practices

Sound wave illustration for: Best Practices

Following these guidelines ensures your kindergarten audiobooks sound clear and professional. Consistent voice selection and proper text formatting reduce artifacts and make the listening experience smoother for young readers.

Avoid special characters

Strip non-standard symbols, emojis, or complex punctuation before sending text to the API. These characters can cause synthesis errors or produce unnatural pauses in the audio output.

Use consistent voice

Stick to one voice preset per book to maintain narrative continuity. Switching between voices mid-story can confuse listeners and break the immersive experience for children.

Keep texts under limit

Ensure each API request input field stays within the 4096 character limit. The API does not handle splitting automatically; knowing this limit helps you structure your chapters effectively.

Future Updates

Sound wave illustration for: Future Updates

Since we do not maintain a proprietary SDK, updates primarily involve monitoring the standard OpenAI-compatible endpoint behavior. We recommend checking the /v1/models endpoint regularly to ensure your integration remains compatible with any engine adjustments.

Feature additions will be communicated via our contact page. As we are an independent API without a fixed release schedule, staying informed helps you adapt your automation scripts promptly.

Monitor API changes

Check the /v1/models endpoint to verify current engine status. Since the API mimics the OpenAI structure, standard compatibility checks remain your primary tool for ensuring smooth operation.

  • Verify model availability via GET /v1/models
  • Check for any endpoint deprecations

Update SDK if needed

We do not provide a dedicated Lumivox SDK. You rely on the official OpenAI SDK or plain HTTP. Ensure your base_url points to https://api.getx99.com/v1 and update your library versions as needed.

Stay informed on features

Feature updates are announced via email support. Since we lack a public changelog, contacting us at [email protected] is the best way to learn about new voice presets or format options.

  • Email support for feature announcements
  • No public changelog available

Listen to the 8 voices

Each sample below was generated by this API from the same sentence. Male voices offer distinct tonal qualities for different narrative needs.

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. OpenAI API reference: create speech
  3. LibriTTS-R paper (arXiv 2305.18802)
  4. curl documentation
  5. ISO 639 language codes
  6. MDN: Web Speech API
  7. Creative Commons Attribution 4.0
  8. openai-node on GitHub
  9. FFmpeg documentation
  10. TRON developer hub: TRC-20
  11. Tether (USDT)
  12. Python documentation

More on this site