How to Read Bible Stories with TTS API? | Guide

By Good11 editorial team · Updated 2026-11-19

This guide shows indie developers how to use FableTongue’s TTS API to convert text into audio. We cover voice selection, text preparation, and API integration for children’s stories and educational content.

You will learn to split long texts, handle API responses, and optimize performance. This step-by-step walkthrough helps you build accessible audio apps efficiently, using concrete examples and real workflows tailored for indie projects.

How to Read Bible Stories with TTS API? | Guide

Frequently asked questions

What is a text-to-speech API?

A cloud API that converts text into audio files via a POST request. Send your Bible story text to the endpoint and receive an audio file. It works like the OpenAI speech endpoint, allowing you to use standard SDKs by adjusting the base URL for easy integration into your indie projects.

How do I choose a voice?

Select from eight presets based on your story’s tone. Use Luna for soft storytelling or Sage for calm instruction. Felix suits energetic promo-style readings, while Orion provides a deep, documentary feel. Each voice supports all 23 languages, ensuring consistent quality whether reading Genesis or Psalms in any supported language.

Can I use the API for commercial projects?

Yes. The API is designed for indie developers to integrate high-quality TTS into applications, from children's stories to educational materials. Generated audio files are returned in the response and not stored, making them safe for commercial distribution in your apps or content without ongoing royalty constraints.

What formats are supported?

You can request audio in mp3, wav, opus, flac, or pcm formats. Choose the format that best fits your application’s needs. MP3 offers compression, while WAV and FLAC provide lossless quality. PCM is available for raw audio processing. All formats are generated via the standard speech endpoint.

How do I handle long texts?

Split texts into parts of up to 4096 characters per request. Generate audio for each part, then join the resulting audio files. This workflow ensures compliance with character limits while allowing you to read entire Bible chapters or longer narratives seamlessly within your application’s logic.

Is the API reliable?

Requests are processed sequentially, so under load, a request may wait in a queue. Typical speed is roughly real-time, with short phrases taking a few seconds. Failed requests are free, ensuring you only pay for successful synthesis. There is no SLA or uptime guarantee provided.

What languages are supported?

The API supports 23 languages, including English, Spanish, French, German, Arabic, Chinese, Japanese, and Hindi. Any voice can speak any of these languages. If the language is not set, it is guessed from the script, so specify it explicitly for non-English Latin-script text to ensure accuracy.

How much does it cost?

Pricing is $10 per 1 million characters, or $0.01 per 1,000 characters. Spaces and punctuation count as characters. Failed requests are free. You can start with a $0.50 free trial credit valid for 7 days when signing in with Google. Top-ups are via USDT on TRON.

Do I need an account?

Yes, you need an account to obtain an API key. Sign up on the /get-api-key/ page using Google or email. Each account has one active key. You can issue a new key at any time, which immediately invalidates the old one. Accounts are per site.

Can I change the speed?

Yes, you can adjust the speed between 0.25 and 4.0. This allows you to slow down narration for clarity or speed up content for brevity. The speed parameter is part of the standard request body, making it easy to control pacing for different Bible story segments.

How do I install the SDK?

Use the official OpenAI SDKs by changing the base URL to https://api.good11.info/v1. Pass your API key in the Authorization header. No custom SDK is required. You can also use plain HTTP requests. This allows you to leverage existing libraries for seamless integration into your codebase.

What are the rate limits?

You are limited to 60 requests per minute per key. Before your first top-up, the limit is 10 requests per minute. This ensures fair usage. Monitor your usage via the dashboard. If you exceed limits, requests may be delayed or rejected until the window resets.

How do I troubleshoot errors?

Check your API key and request body for validity. Ensure text is under 4096 characters. Failed requests are free, so retry them if needed. Support is available via email only. There is no live chat or phone support. Review the documentation for specific error codes and solutions.

Is there a free tier?

Yes, signing in with Google grants a $0.50 trial credit valid for 7 days, covering about 50,000 characters. Email-based accounts start without trial credit. There is no monthly plan or free tier beyond this trial. Top-ups are required for continued use after the trial expires.

Choosing the right voice

Sound wave illustration for: Choosing the right voice

Selecting the right voice ensures your biblical narratives resonate with your audience. Aria provides a warm, clear narrator style ideal for precise scripture reading, while Luna offers a soft, storytelling tone perfect for parables. Felix adds energy for dynamic passages.

These presets are based on licensed recordings and work across all 23 supported languages. Choose based on the emotional weight of the text you are converting.

Aria for clear narration

Use Aria for straightforward scriptural readings where clarity is paramount. Her voice ensures every word is distinct, making it suitable for detailed verse-by-verse applications.

Aria’s neutral yet warm tone avoids distraction, allowing the text to remain the focus. This is ideal for educational or devotional apps requiring high intelligibility.

  • Best for: Direct scripture reading
  • Tone: Warm and clear
  • Language support: All 23 languages

Luna for soft storytelling

  • Best for: Parables and stories
  • Tone: Soft and storytelling
  • Use case: Bedtime readings

Felix for energetic readings

Felix brings an energetic, upbeat quality to your audio. He is excellent for dynamic sections, prophetic declarations, or children’s Bible stories that require engagement.

His clear, active tone helps maintain listener interest. Use him for shorter, punchy verses or when you want to convey excitement and clarity.

  • Best for: Energetic passages
  • Tone: Bright and upbeat
  • Use case: Children’s stories

Preparing your text

Sound wave illustration for: Preparing your text

Before sending your Bible stories to the TTS API, prepare the input text to ensure smooth synthesis and avoid request failures. The API accepts plain text up to 4096 characters per request, so long passages must be divided accordingly. This prevents truncation and keeps processing efficient for your indie app’s audio pipeline.

Split texts into 4096 char chunks

Each API call processes a maximum of 4096 characters, including spaces and punctuation. If your story exceeds this limit, split the text into smaller segments and concatenate the resulting audio files later. This ensures no narrative content is lost and keeps each request within the accepted size range.

  • Count every character, including spaces and punctuation marks.
  • Split at natural break points like sentence ends to avoid awkward audio cuts.
  • Concatenate the returned audio files in order to reconstruct the full story.

Remove special formatting

Strip out HTML tags, markdown, or other rich text formatting before sending the input. The TTS engine expects plain text, so special characters may be read aloud literally. Clean text ensures the voice reads your scripture clearly without distractions.

  • Remove tags like <b>, <i>, or <p>.
  • Convert symbols to their spoken equivalents if necessary.
  • Ensure consistent spacing between words.

Ensure correct language code

Explicitly set the language parameter in your request, especially for non-English texts. If omitted, the API guesses the language based on the script, which may default to English for Latin script. Setting the ISO code ensures accurate pronunciation and tone for your specific story.

  • Use ISO 639-1 codes (e.g., 'en', 'es', 'fr').
  • Check the /v1/voices endpoint for supported language codes.
  • Set the parameter even for Latin-script languages to avoid incorrect defaults.

Making API requests

Sound wave illustration for: Making API requests

To generate audio for your Bible stories, send a JSON payload to the POST /v1/audio/speech endpoint. The request body must include the model (tts-1 or tts-1-hd), your input text, and the desired voice preset like Aria for clear narration.

Use POST /v1/audio/speech

Send your request to https://api.good11.info/v1/audio/speech. Include the model, input (up to 4096 characters), voice, and response_format fields. The API processes the text and returns an audio file directly in the response body.

Include your API key

Authentication is handled via the Authorization: Bearer tts-... header. Ensure you include your active API key in every request to avoid rejection. You can generate or rotate keys from your dashboard at /get-api-key/.

Set response format to MP3

Specify mp3 in the response_format field for broad compatibility with most audio players and web frameworks. Other supported formats include wav, opus, flac, and pcm, depending on your quality and size requirements.

Handling responses

Sound wave illustration for: Handling responses

The API returns the generated audio file directly in the response body, allowing you to save or process it immediately without intermediate steps.

Since the service does not store generated audio after delivery, you must handle storage yourself to ensure you can access the files later.

Receive audio file directly

Upon successful synthesis, the endpoint returns the audio data in your chosen format (mp3, wav, opus, flac, or pcm). This direct delivery means you can pipe the output straight into your application’s media player or save it to a local directory without additional conversion steps.

Store the audio

The API does not retain the generated audio files after the response is sent. You are responsible for storing the audio files on your own servers or cloud storage to ensure they remain available for your users.

Track usage for billing

Each request consumes credits based on the character count of your input text. You can monitor your remaining balance and usage history directly from your dashboard to avoid unexpected charges.

Optimizing performance

Sound wave illustration for: Optimizing performance

Optimize your Bible story app by anticipating user needs. Pre-fetching audio for upcoming chapters reduces wait times, ensuring a smooth narrative flow. Since long texts are split into 4096-character chunks, pre-fetching allows you to assemble full chapters seamlessly in the background.

Pre-fetch audio for chapters

Load the next chapter’s audio segments in the background. This minimizes latency and keeps the listening experience uninterrupted, which is crucial for immersive storytelling.

  • Initiate requests for upcoming segments during playback of current audio.
  • Assemble segmented audio files into a continuous track for the user.

Use caching for repeated reads

Store generated MP3 files locally or on a CDN. Since Bible stories are often re-read, caching avoids redundant API calls and reduces costs. Generated audio is not stored by the API, so you must manage retention.

  • Cache MP3s for frequently accessed verses or chapters.
  • Implement cache invalidation for updated text versions.

Monitor rate limits

You have 60 requests per minute per key. Monitor your usage to avoid throttling. If you exceed limits, requests queue or fail, though failed ones are free. Track characters consumed to stay within budget.

  • Track request volume against the 60 req/min limit.
  • Implement exponential backoff if throttling occurs.

Accessibility considerations

Sound wave illustration for: Accessibility considerations

Clear audio quality ensures that biblical narratives are easily understood by listeners with varying hearing abilities. Our TTS engine delivers clear speech, making complex stories accessible to a broader audience.

Ensure clear audio quality

By selecting voices like Aria or Luna, developers can achieve a warm, clear narration style ideal for religious texts. The consistent audio output ensures that every word is distinct, aiding comprehension for users with cognitive or hearing challenges.

  • Select warm voices for better listener engagement
  • Maintain consistent volume and clarity across chapters
  • Use MP3 format for broad device compatibility

Support multiple languages

The API supports 23 languages, allowing developers to localize Bible stories for diverse communities. By specifying the language code, you ensure accurate pronunciation and intonation, making the content accessible to non-native speakers and preserving cultural nuances.

  • Support 23 languages including English, Spanish, and French
  • Explicitly set language codes for non-English Latin text
  • Avoid unsupported languages like Vietnamese or Thai

Provide playback controls

Users benefit from standard playback controls like play, pause, and speed adjustment. Since the API returns audio files, your app can implement these controls natively, allowing listeners to adjust speed between 0.25 and 4.0 for better comprehension.

  • Implement native play, pause, and seek controls
  • Allow users to adjust speech speed
  • Ensure audio files are playable in browsers

Testing your integration

Sound wave illustration for: Testing your integration

Start by signing up via Google to receive $0.50 in trial credit, valid for 7 days. This gives you approximately 50,000 characters to test the API without financial commitment.

Use this balance to verify your integration works before committing to larger volumes. The trial is perfect for validating your workflow with small datasets.

Use the free trial credit

Sign up on /get-api-key/ using your Google account to instantly receive $0.50. This credit covers about 50,000 characters, allowing you to test the full request cycle without payment details.

  • Google sign-up provides immediate trial credit.
  • Email/password accounts start with zero balance.
  • Credit expires after 7 days.

Test with short verses

Send short Bible verses to validate your JSON payload structure. Use the tts-1 model with a voice like Aria or Luna to ensure the audio generation pipeline responds correctly to your specific text input.

  • Validate JSON body structure.
  • Test tts-1 model response.
  • Check character counting accuracy.

Verify audio clarity

Listen to the generated MP3 files to confirm clarity and tone. Ensure the voice matches your intended narrative style, whether it is clear narration or soft storytelling. Check that the audio file is playable in your target environment.

  • Check MP3 playback compatibility.
  • Verify voice tone appropriateness.
  • Confirm file integrity.
Testing your integration

Common pitfalls

Sound wave illustration for: Common pitfalls

Avoiding common API mistakes saves time and prevents unexpected charges during your Bible story projects. Knowing the hard limits of the TTS endpoint ensures your integration runs smoothly without silent failures or wasted credits.

Exceeding character limits

Each API request accepts a maximum of 4096 characters, including spaces and punctuation. If your biblical passage exceeds this length, you must split the text into smaller chunks before sending them. The API does not automatically handle long texts; sending too much data will result in a request error.

  • Count characters precisely before every POST request.
  • Split long chapters into segments under 4096 chars.
  • Join the resulting audio files manually after synthesis.

Ignoring rate limits

Your API key allows only 60 requests per minute once funded, or 10 per minute during the free trial. Sending too many requests simultaneously causes your audio synthesis jobs to queue, slowing down generation. If you are processing many verses at once, ensure your application respects these limits to avoid delays.

  • Limit concurrent requests to 10/min for trial accounts.
  • Implement a queue system for batch processing.
  • Monitor usage via the dashboard to stay under limits.

Missing language codes

The API guesses the language based on the script if you do not set the language field. For Latin-script text that is not English, such as German or Dutch Bible translations, you must explicitly provide the ISO code. Without this, the system defaults to English, resulting in incorrect pronunciation.

  • Set language for non-English Latin-script texts.
  • Default language is English for Latin script.
  • Supported languages include German, French, and Spanish.

Scaling your app

Sound wave illustration for: Scaling your app

As your Bible story app grows, monitoring API usage ensures you stay within your 60 requests per minute limit. The dashboard on your account page provides real-time visibility into your character consumption and request status, helping you avoid unexpected throttling during high-traffic periods.

Monitor API usage

Track your character count closely, as each request costs $0.01 per 1,000 characters. Use the usage metrics to predict when your free trial credit ($0.50) will expire and when a top-up is needed for sustained operation.

  • Check balance and usage on /get-api-key/
  • Monitor request success rates to avoid wasted credits

Plan for peak loads

Since requests are processed sequentially, long texts may queue during high demand. Plan your generation strategy by splitting large chapters into 4,096-character chunks to keep individual requests fast and predictable. This ensures consistent audio delivery even when the queue is busy.

Use batch processing

Generate multiple audio files in parallel by sending concurrent POST requests to /v1/audio/speech. This reduces total wait time for a full book, though you must manage the concurrency to stay under the 60 RPM limit per key.

Support and resources

Sound wave illustration for: Support and resources

Documentation is your primary reference for API endpoints, voice presets, and integration workflows. The /docs/ page provides detailed specifications for the speech endpoint, including required fields like model, input, and voice. It also covers rate limits and response formats to help you build robust integrations for your Bible story applications.

Check the documentation

Start with the official API documentation to understand request structures and response codes. The docs detail the 4096-character limit per request and explain how to handle failures. This ensures your app correctly splits long chapters and manages audio generation efficiently.

  • API endpoint specifications
  • Rate limit details (60 req/min)
  • Voice and language parameters

Contact support by email

For technical issues or billing questions, reach out via email. We do not offer phone support or live chat, so email is the single channel for assistance. Include your API key and request details in your message for faster resolution.

  • Email support only
  • No live chat or phone
  • Include API key in queries

View code examples

Use the provided cURL examples to accelerate your integration. The /get-api-key/ page includes a ready-to-use cURL example for generating speech. These resources help indie developers quickly implement TTS into their children's story apps or educational platforms.

  • cURL examples
  • OpenAI SDK compatibility
  • Ready-to-use snippets

Future updates

Sound wave illustration for: Future updates

We continuously refine the engine to support more narratives. While we currently offer eight fixed voices, future updates will focus on enhancing audio quality and expanding language support to include additional dialects for richer storytelling.

Stay tuned for new voices

We do not promise new voice releases on a fixed schedule. Updates will be deployed as infrastructure improvements allow, ensuring stability remains the priority. Existing voices will receive periodic quality enhancements without disrupting current integrations.

Watch for API changes

The API structure remains stable, but we may introduce new parameters for advanced audio control. Major changes will include a deprecation period, allowing you to update your integration without breaking existing Bible story applications.

Follow our blog

Our blog documents technical updates and integration tips for indie developers. Subscribe to receive notifications about rate limit adjustments, new response formats, or best practices for handling long-form biblical texts via the TTS API.

Conclusion

Sound wave illustration for: Conclusion

Integrating Bible stories with FableTongue is straightforward. You send text via a simple POST request and receive an audio file. The process supports standard formats like MP3 and requires you to handle character limits.

At $0.01 per 1,000 characters, costs remain predictable. Failed requests incur no charge, and your balance never expires. This model fits tight budgets without monthly subscriptions or hidden fees.

Easy integration process

Use the same JSON structure as OpenAI’s speech endpoint. Change the base URL to https://api.good11.info/v1 and provide your Bearer token. Most developers can adapt existing code in minutes.

  • Standard JSON request body
  • Works with official OpenAI SDKs
  • No custom SDK required

Cost-effective solution

Pricing is flat: $10 per million characters. There are no per-seat fees or minimum spend requirements. You only pay for what you generate, making it ideal for variable usage patterns.

  • $0.01 per 1,000 characters
  • No monthly plans
  • Free trial credit available

Great for indie developers

FableTongue is built for small teams and solo creators. Start with a $0.50 trial credit or top up via USDT (TRC-20). No enterprise contracts or complex billing cycles to manage.

  • Low barrier to entry
  • Simple USDT top-ups
  • No VAT invoices

Listen to the 8 voices

Each sample below was generated by this API from the same sentence. This foundation allows each preset to maintain consistent tonal integrity, whether delivering a soft bedtime narrative or an energetic children’s tale.

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. LibriVox public-domain audiobooks
  5. openai-python on GitHub
  6. ISO 639 language codes
  7. FFmpeg documentation
  8. TRON developer hub: TRC-20
  9. Tether (USDT)
  10. W3C WAI: making audio and video accessible
  11. curl documentation
  12. Python documentation

More on this site