How to Produce Audiobooks with Our TTS API

By AudioPilot editorial team · Updated 2026-11-19

This guide helps freelance narrators and self-publishing authors produce professional audiobooks using our reliable cloud TTS API. We focus on clear licensing, transparent character-based pricing, and voices that fit the storytelling workflow. You will learn how to match tone to genre, manage character limits, and generate high-quality audio files efficiently.

You will also discover how to prepare your manuscript, handle technical setup, and optimize your budget using our USDT top-up system. Whether you are generating short phrases or long chapters, this step-by-step guide covers everything from choosing the right voice to preparing files for distribution, ensuring a smooth production process.

How to Produce Audiobooks with Our TTS API

Frequently asked questions

Which voice is best for romance novels?

Luna is described as a soft, storytelling voice, making her particularly suitable for romance novels. Aria is another option, offering a warm, clear narrator tone. Since any of the eight presets can speak any language, you can test different voices to match your specific book’s mood. The API allows you to select any preset, so choose the one that fits your story’s voice.

How do I split a 100,000 word book?

The API accepts up to 4,096 characters per request. You must split your text into parts that fit this limit. After generating each part, join the resulting audio files. Since spaces count as characters, ensure your splits account for punctuation. Process requests sequentially, as they are handled one after another.

Can I use the same voice for multiple books?

Yes, you can reuse any of the eight voice presets across multiple projects. There is no restriction on reusing voices like Aria, Nova, or Atlas. Each generation is independent, so you can apply the same voice to different books without any technical limitations or additional setup requirements.

What happens if I exceed the rate limit?

You are limited to 60 requests per minute per key. If you exceed this, requests may wait in a queue or fail. Failed requests are free, so you will not be charged for audio that does not generate. Monitor your usage to stay within the 60 requests per minute limit.

Do I need to pay for each chapter separately?

No, you pay based on total characters generated, not per chapter. The rate is $10 per 1 million characters. Whether you generate one chapter or the entire book, the cost depends solely on the character count. Failed requests are free, so you only pay for successful audio generation.

Can I change the voice mid-chapter?

The API does not support changing voices mid-chapter in a single request. You must split the text at the point where you want the voice change. Generate the first part with one voice, then generate the next part with the new voice, and join the audio files afterward.

Is the audio format MP3 compatible with Audible?

The API supports MP3, WAV, OPUS, FLAC, and PCM formats. While MP3 is widely compatible, Audible has specific technical requirements for audiobooks. You can generate MP3 files, but you may need to verify their compliance with Audible’s upload standards before publishing your final audiobook production.

How do I handle special characters in text?

The API accepts standard text input up to 4,096 characters. Spaces and punctuation count toward the character limit. There is no mention of SSML or custom pronunciation lexicons, so special characters are treated as standard text. Ensure your input text fits within the character limit for each request.

Can I use the API for children's books?

Yes, you can use any of the eight voices for children's books. Voices like Luna (soft, storytelling) or Felix (energetic) may suit younger audiences. The API supports multiple languages and does not restrict content type. Generate audio for your text and join the files as needed for the final book.

Do I need a developer to use this?

A basic understanding of APIs is helpful but not strictly required. You can use the official OpenAI SDKs by changing the base URL. The /get-api-key/ page provides a ready curl example. However, handling character splitting and audio joining may require simple scripting or developer assistance for larger books.

How long does it take to generate a full book?

Generation is roughly real-time, about 25 characters of text per second of generation. A 100,000-word book (approx. 500,000 characters) would take several hours. Requests are processed sequentially, so under load, generation may take longer. Plan your production schedule accordingly, considering the queue time during high usage periods.

Can I edit the audio after generation?

The API returns generated audio files but does not store them. You receive the audio in the response, so you must save and edit it yourself. There is no built-in editing tool. You can use external audio software to trim, join, or adjust the generated files as needed.

Is there a limit on how many books I can produce?

There is no limit on the number of books you can produce. You pay per character generated, with no monthly plans or minimum spend. As long as you have sufficient balance, you can generate as many books as you need. Failed requests are free, so you only pay for successful output.

Do you offer bulk discounts?

No, there are no bulk discounts or volume-based pricing tiers. The rate is fixed at $10 per 1 million characters. Pricing is transparent and based solely on character count. There are no subscriptions, seats, or minimum spend requirements, so you pay exactly for what you use.

Choosing the Right Voice

Sound wave illustration for: Choosing the Right Voice

Audiobooks often use distinct vocal styles to keep listeners engaged. Selecting a voice that matches your genre’s tone ensures the narration feels professional rather than robotic. Our eight presets cover everything from warm storytelling to neutral news delivery, allowing you to pair the right voice with your specific content style.

Matching tone to genre

Match your narrative style to the voice characteristics. Use Luna for soft, storytelling segments or Atlas for neutral, news-style readings. Felix works well for energetic promos, while Orion suits deep, documentary tones. Sage provides a calm, instructional feel ideal for educational content.

  • Luna: soft, storytelling
  • Atlas: neutral, news
  • Felix: energetic, promo
  • Orion: deep, documentary

Female vs male presets

We offer four female and four male voices. Aria offers a warm, clear narrator style, while Nova is bright and upbeat. Milo brings a friendly, conversational tone, and Sage remains calm and instructional. Each voice is based on licensed recordings from LibriVox, ensuring high-quality synthetic speech.

Mixing genders can add variety to long books, but consistency usually helps listener immersion. Choose based on the primary character voice or narrator persona you wish to establish for the project.

  • Aria: warm, clear narrator
  • Nova: bright, upbeat
  • Milo: friendly, conversational

Testing voices with samples

Before committing to a full book, generate short samples for each voice. Use the same text snippet to compare clarity, speed, and tone. This helps you identify which preset best suits your manuscript’s pacing.

Remember that voices are based on licensed recordings and carry an inaudible watermark. Test your specific text genre to ensure the voice handles the material naturally without sounding forced or overly dramatic.

Preparing Your Manuscript

Sound wave illustration for: Preparing Your Manuscript

Before sending text to the TTS API, ensure your manuscript is clean and structured. Remove markdown artifacts, stray symbols, and irregular whitespace that could disrupt synthesis. Standardize line breaks so the engine reads continuous prose without artificial pauses.

Cleaning up text formatting

Strip out headers, footers, and page numbers that do not belong in the spoken narrative. Use plain text or simple HTML to preserve paragraph structure. This ensures the AI interprets the rhythm correctly without reading out structural metadata.

  • Remove markdown symbols like # or *
  • Standardize paragraph breaks
  • Eliminate non-speech elements like page numbers

Handling punctuation

Punctuation directly controls pacing. Use commas for short pauses and periods for full stops. Avoid excessive ellipses or dashes, which the engine may interpret inconsistently. Proper punctuation ensures natural phrasing and prevents awkward audio artifacts in the final audiobook.

Splitting long chapters

The API limits input to 4,096 characters per request. Split chapters at logical sentence or paragraph boundaries before sending them. This prevents truncation and allows you to manage generation time more effectively. Keep each segment self-contained to maintain narrative flow.

  • Limit input to 4,096 characters
  • Split at paragraph breaks
  • Keep segments self-contained

Technical Setup

Sound wave illustration for: Technical Setup

Technical setup begins with account creation. Navigate to the /get-api-key/ page and sign in via Google or email. Your unique API key appears immediately. Note that one active key is issued per account; you can generate a new key anytime, which instantly invalidates the old one. This key authenticates all subsequent requests to the API.

For SDK users, install the OpenAI SDK. Since this is a compatible REST API, you simply point the SDK to our base URL. This allows you to use familiar methods while leveraging our specific pricing and voice presets. No proprietary SDK installation is required.

Getting your API key

Visit /get-api-key/ and authenticate via Google or email/password. The dashboard displays your active key, balance, and usage stats. Copy this key; it is the sole credential needed for authentication.

  • Accounts are per site (60w.info)
  • One active key per account
  • New keys instantly invalidate old ones

Installing the SDK

Install the OpenAI SDK for your preferred language (e.g., pip install openai). This works because our endpoint structure mirrors the OpenAI speech endpoint. No custom library is needed.

  • Use official OpenAI SDK
  • Compatible with standard HTTP libraries
  • No proprietary SDK required

Configuring the base URL

Set the API base URL to https://api.60w.info/v1 in your SDK configuration. This directs all requests to our infrastructure while maintaining standard request shapes. Ensure your Authorization header includes 'Bearer <your-key>'.

  • Base URL: https://api.60w.info/v1
  • Auth: Bearer <key>
  • Standard JSON request shape

Generating Audio Files

Sound wave illustration for: Generating Audio Files

Generating audio is straightforward: send your text to the speech endpoint and receive an audio file. You can use the official OpenAI SDKs by pointing them to our API base URL, or use plain HTTP requests. Each request accepts up to 4096 characters, so longer chapters must be split into manageable parts.

The API returns the audio file directly in the response body. You can specify the output format—MP3, WAV, OPUS, FLAC, or PCM—and set the playback speed between 0.25 and 4.0. Failed requests are free, ensuring you only pay for successful generations. This simplicity allows you to integrate audio production directly into your writing workflow.

Sending requests via API

To generate speech, send a POST request to https://api.60w.info/v1/audio/speech. Include your API key in the Authorization header as Bearer tts-.... The JSON body requires the model (tts-1 or tts-1-hd), the input text, and the voice preset. You can also optionally set the language code or adjust the speed.

Ensure your text does not exceed 4096 characters per request. If your chapter is longer, split it logically and send multiple requests. The API processes requests sequentially, so under heavy load, there may be a slight queue delay. Use the free trial credit of $0.50 to test your first few requests.

  • Use tts-1 or tts-1-hd for model selection.
  • Set voice to one of eight presets like 'aria' or 'atlas'.
  • Include input text with a maximum of 4096 characters.
  • Add Authorization: Bearer tts-... for authentication.

Handling response formats

The API returns the audio file directly in the response body. You can choose from MP3, WAV, OPUS, FLAC, or PCM formats by setting the response_format field. MP3 is efficient for web distribution, while WAV or FLAC offer lossless quality for professional mastering. OPUS and PCM are suitable for specific technical workflows.

Each generated file contains an inaudible watermark marking it as synthetic speech. Failed requests do not incur charges, so you can retry without worrying about costs. The response time varies; short phrases take a few seconds, while longer texts generate at roughly real-time speed.

  • Supported formats: mp3, wav, opus, flac, pcm.
  • Failed requests are free.
  • Audio includes a synthetic watermark.
  • No SSML or phoneme support available.

Saving audio locally

Once you receive the audio response, save the file to your local directory using your preferred programming language or HTTP client. Ensure you handle binary data correctly to avoid corruption. For long books, save each segment sequentially and then join them using audio editing software or command-line tools like FFmpeg.

Keep track of your character usage and balance in the dashboard. Since input text is used only for production and not for training, you can safely process proprietary manuscripts. Generated audio is returned in the response and not stored on our servers, giving you full control over your files.

  • Save binary response data to disk.
  • Join segments for full chapters.
  • Track usage in the dashboard.
  • Files are not stored on our servers.

Managing Character Limits

Sound wave illustration for: Managing Character Limits

Each API request accepts a maximum of 4,096 characters, including spaces and punctuation. To produce a full audiobook chapter, you must split the manuscript into smaller parts and join the resulting audio files. This ensures every segment is synthesized without truncation errors.

The API processes requests sequentially, so splitting your text into manageable chunks allows you to maintain a steady production flow. You can then concatenate the outputs to create a seamless listening experience for your audience.

Splitting at logical breaks

Identify natural boundaries such as paragraph endings or scene changes before dividing your text. Keep each chunk under the 4,096-character limit to ensure consistent audio quality and predictable generation times.

Avoid splitting mid-sentence to prevent awkward pauses between segments. Aim for breaks that align with the narrative structure, making the final join less noticeable to listeners.

  • Check character count before sending
  • Mark logical break points in your manuscript
  • Keep chunks under 4,096 characters

Joining audio segments

Once you receive the audio files for each chunk, concatenate them in the correct order. The API does not handle this merging automatically, so you will need a simple audio editor or script to combine the files.

Ensure there is no gap or overlap between segments. A clean join preserves the narrator’s pacing and prevents jarring transitions that distract from the story.

  • Order files sequentially
  • Use audio editing software
  • Check for seamless transitions

Avoiding cut-off sentences

A cut-off sentence occurs if you split text in the middle of a phrase, leaving the listener hanging. Always ensure each request contains complete grammatical units where possible.

If you must split a long sentence, leave enough context in each part so the TTS engine can maintain natural intonation. This minimizes the artificial feel of the generated audio.

  • Preserve sentence integrity
  • Maintain narrative flow
  • Review split points carefully

Quality Control

Sound wave illustration for: Quality Control

Quality control ensures your audiobook sounds polished before distribution. Since the TTS engine generates synthetic speech with an inaudible watermark, you must verify that the narrative flow matches your manuscript’s intent. Listen for unnatural pauses or mispronounced names, which are common in self-published texts.

Small adjustments can significantly improve the final product. Use speed settings to fine-tune pacing, ensuring the narration remains engaging without rushing through complex passages. This step is crucial for maintaining listener retention in long-form content.

Listening for errors

Review each segment for clarity. The API does not support SSML, so you cannot add emphasis tags. Instead, adjust the text itself—add commas for pauses or rewrite awkward sentences before generation. Listen for the characteristic synthetic tone to ensure it fits your genre.

Check that the language code matches the text. If the API guesses English for non-English Latin text, you may hear an accent. Set the language field explicitly to avoid this issue.

  • Verify pronunciation of proper nouns
  • Check for unnatural pause patterns
  • Ensure consistent tone across chapters

Adjusting speed settings

The speed parameter ranges from 0.25 to 4.0. For audiobooks, a speed between 0.9 and 1.1 usually provides the most natural listening experience. Faster speeds can make the voice sound rushed, while slower speeds may drag.

Experiment with different voices. Some voices, like Luna for storytelling or Atlas for news, may perform better at specific speeds. Test a 500-character segment with varying speeds to find the optimal balance for your specific manuscript style.

  • Use 0.9-1.1 for natural pacing
  • Test 0.75 for slower, detailed passages
  • Avoid speeds below 0.5 for clarity

Re-generating failed parts

If a request fails, the charge is returned in full. Simply re-send the same text. However, if the audio sounds incorrect, do not re-generate the exact same input. Modify the text or voice parameter to get a different result.

Check your rate limits if you are re-generating many segments. You have 60 requests per minute. If you exceed this, wait a minute before retrying to avoid delays in your production workflow.

  • Re-send failed requests immediately
  • Modify input if audio is incorrect
  • Monitor rate limits (60 req/min)

Pricing and Budgeting

Sound wave illustration for: Pricing and Budgeting

AudioPilot uses a transparent, character-based pricing model: $10 per 1,000,000 characters. Since spaces and punctuation count, a 50,000-character manuscript costs $0.50. This predictable structure helps freelancers budget accurately without hidden fees or monthly commitments.

Calculating costs per book

Estimate your total characters before generating. Divide the count by 100,000 to get the cost in dollars. For example, a 100,000-character novel requires only $1.00. This simplicity allows precise cost forecasting for self-publishing projects.

Using the free trial

Sign in with Google to receive $0.50 in trial credit, valid for 7 days. This covers approximately 50,000 characters, enough to test multiple voices or generate a short chapter. Email-based accounts start without this credit.

Top-up strategies

Fund your account via USDT on the TRON network (TRC-20). The minimum top-up is $5. Credits appear automatically within minutes, ensuring you never pause production due to balance issues. Balance does not expire.

  • Use TRC-20 only
  • Minimum $5 top-up
  • Automatic credit within minutes
  • No expiration on balance
Pricing and Budgeting

Payment with USDT

Sound wave illustration for: Payment with USDT

To add funds, send USDT on the TRON network (TRC-20) to your dashboard address. The minimum top-up is $5, with no subscriptions or invoices involved. Credits appear automatically within minutes of transfer confirmation, ensuring your workflow stays uninterrupted.

Sending TRC-20 transactions

Ensure you select the TRC-20 network when transferring. Send at least $5 worth of USDT to avoid fees exceeding your deposit. There are no monthly plans or minimum spend requirements, so you only pay for what you use.

  • Use the TRON network (TRC-20) only
  • Minimum deposit amount is $5
  • No expiration on your balance

Waiting for confirmation

Once the blockchain confirms your transaction, your balance updates automatically. You do not need to wait for manual approval or invoice processing. This system allows for immediate usage of your new credit for audiobook generation.

Checking balance

Log in to your account dashboard to view your current balance and usage statistics. The interface displays your remaining characters and transaction history clearly. This transparency helps you budget accurately for long-form narration projects.

Distribution Preparation

Sound wave illustration for: Distribution Preparation

Before distributing your audiobook, ensure your generated audio files meet platform requirements. The API returns standard formats like MP3 or WAV, which are widely compatible with major distributors.

Proper metadata embedding ensures your book is categorized correctly. Include title, author, and narrator details in your metadata files or upload forms to streamline the upload process.

File format conversion

Convert your generated WAV or FLAC files to MP3 if required by your distributor. Use standard tools to ensure consistent bitrate and sample rates, avoiding quality loss during compression.

Metadata embedding

Embed ID3 tags into your audio files. Include essential fields like title, artist (narrator), and album (book title). This helps platforms organize your content correctly without manual entry.

  • Title: Audiobook name
  • Artist: Narrator voice name
  • Album: Book title

Uploading to platforms

Upload your prepared files to platforms like Audible. Verify file size limits and chapter markers before submission to avoid rejection. Use the platform’s dashboard to track progress.

Common Mistakes to Avoid

Sound wave illustration for: Common Mistakes to Avoid

Freelance narrators often rush into production without verifying technical constraints or voice capabilities, leading to wasted time and unexpected costs. Avoiding these common pitfalls ensures a smoother workflow from manuscript to final audiobook file.

Ignoring character limits

The API accepts up to 4,096 characters per request. Texts exceeding this limit must be split into logical segments and joined later; sending a large block at once will fail or truncate.

  • Split long chapters into parts under 4,096 characters.
  • Join generated audio files sequentially after generation.

Not testing voices first

Each voice has a distinct tone, from Aria’s warm narration to Atlas’s neutral news style. Testing samples before committing to a full book prevents mismatched audio and ensures the voice fits your genre.

Assuming voice cloning is included

Our service provides eight preset voices based on licensed recordings. It does not offer custom voice cloning, uploading your own voice, or creating new voices. If you need a specific voice, select from the available presets.

Optimizing for Speed

Sound wave illustration for: Optimizing for Speed

The API processes requests sequentially, meaning under load, a single long chapter may queue behind other users. To maintain steady progress, you can send multiple requests in rapid succession. The system handles this queue efficiently, ensuring your audio generation pipeline remains active without manual intervention for each segment.

Batching requests

Group your text into logical chunks (e.g., paragraphs or scenes) and submit them as a batch. Since the rate limit is 60 requests per minute, you can safely send up to 60 segments per minute. This maximizes throughput compared to sending one request at a time with pauses.

  • Split text into segments under 4096 characters.
  • Send requests consecutively without delay.
  • Stay within the 60 requests/minute limit.

Parallel generation

While the core synthesis queue is sequential, you can optimize your local workflow by preparing multiple segments simultaneously. Use a script to trigger requests for different chapters or voices in parallel. This reduces idle time between segments, ensuring the API is constantly processing data as soon as a slot opens.

Reducing latency

For short phrases, generation takes a few seconds; for long texts, it is roughly real-time. To minimize perceived latency, start processing your first segment immediately after manuscript preparation. Avoid unnecessary validation steps before sending the request. If a request waits in queue, it will complete once a slot is available, so prioritize sending early.

Support and Troubleshooting

Sound wave illustration for: Support and Troubleshooting

Support is email-only; there is no live chat, phone number, or SLA. When issues arise, describe the error and include your API key prefix. Responses are provided as capacity allows, without guaranteed uptime or enterprise contracts.

Contacting support via email

Send details to the contact page. Include the request ID if available. We do not offer priority queues or dedicated account managers.

Common error messages

Errors usually stem from invalid keys, exceeded character limits, or temporary queue delays. Check your balance and key validity first.

  • 401: Invalid or expired API key.
  • 429: Rate limit exceeded; wait or upgrade.
  • 400: Input text exceeds 4096 characters.

Rate limit management

New accounts start at 10 requests per minute. After the first top-up, the limit increases to 60 requests per minute. Requests process sequentially, so high volumes may queue.

  • Monitor usage via the dashboard.
  • Split large texts to avoid limits.
  • Retry after brief delays on 429 errors.

Listen to the 8 voices

Each sample below was generated by this API from the same sentence. Once you receive the audio files for each chunk, concatenate them in the correct order.

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. LibriTTS-R paper (arXiv 2305.18802)
  3. openai-python on GitHub
  4. W3C WAI: making audio and video accessible
  5. Tether (USDT)
  6. MDN: Web Speech API
  7. curl documentation
  8. openai-node on GitHub
  9. IETF RFC 7845: Ogg Opus
  10. OpenAI API reference: create speech
  11. Python documentation
  12. TRON developer hub: TRC-20

More on this site