How to Convert PDF to Audiobook Using TTS API

By ScribeRead editorial team · Updated 2026-11-18

This guide details the workflow for converting large PDF documents into high-quality audiobooks using the ScribeRead text-to-speech API. It is designed for self-publishers and no-code developers who require a reliable, character-based solution for long-form content without manual formatting overhead.

You will learn how to extract and clean text, split chunks for the 4096-character limit, and manage audio merging. The page covers voice selection, rate limits, cost estimation, and distribution standards, ensuring you can produce consistent, commercial-ready audio files efficiently.

How to Convert PDF to Audiobook Using TTS API

Frequently asked questions

Do I need to pay for each chapter separately?

No. You pay based on total characters processed, not per chapter. Each request handles up to 4096 characters. You split long texts into parts and join the resulting audio files. Failed requests are free. The rate is $10 per 1 million characters, with spaces and punctuation counting toward the total.

Can I pause the generation process?

No. The API processes requests sequentially in a queue. You cannot pause or resume a specific generation once submitted. Requests are processed one after another. Under load, a request may wait in the queue before synthesis begins. You must wait for the current audio file to be generated and returned.

What if the PDF has complex tables?

The API accepts plain text input, not PDF files directly. You must extract text from your PDF and split it into chunks of up to 4096 characters. Complex table structures must be flattened into readable text before sending the POST request. The API does not parse formatting, only the character count and content.

How do I handle footnotes in the text?

Include footnotes as plain text within your input string. The API does not support SSML or custom pronunciation lexicons. You must manually format footnote markers and text into the input string. Ensure the total character count, including footnotes, stays within the 4096-character limit per request.

Is the audio generated instantly?

No. Generation takes time, roughly real-time on long texts. Short phrases take a few seconds. Requests are processed sequentially, so under load, a request may wait in a queue. You receive the audio file only after synthesis completes. Typical speed is about 25 characters per second of generation.

Can I change the voice after generation?

No. Once the audio file is generated and returned, it is fixed. The API does not store the audio for later modification. To change the voice, you must submit a new POST request with the desired voice parameter. The generated file carries an inaudible watermark marking it as synthetic speech.

Do I need technical skills to use this?

Basic technical skills are required. You must send a JSON POST request to the API endpoint. You can use the official OpenAI SDK by changing the base URL to https://api.playjp77.com/v1. No-code users can use ready curl examples provided on the dashboard. You must handle text splitting and audio joining for long documents.

How long does a full book take to process?

Processing time depends on length and queue load. Speed is roughly real-time, about 25 characters per second. Requests are processed sequentially. A full book requires splitting text into 4096-character chunks. Each chunk generates audio independently. Total time includes queue wait times under load and individual synthesis durations.

Preparing Your PDF Document

Sound wave illustration for: Preparing Your PDF Document

Converting PDF documents into audiobooks begins with accurate text extraction. Most PDFs contain hidden formatting that disrupts speech synthesis, so raw text must be isolated before API submission. This ensures the TTS engine receives clean input, minimizing artifacts in the final audio file.

Extracting text from PDF files

Use dedicated extraction libraries or tools to pull plain text from your source files. Avoid copying directly from visual readers, as hidden metadata often interferes with the API’s character counting logic.

  • Use dedicated extraction libraries or tools to pull plain text from your source files.
  • Avoid copying directly from visual readers, as hidden metadata often interferes with the API’s character counting logic.

Cleaning formatting artifacts

Remove page numbers, headers, footers, and excessive line breaks. The API processes text sequentially, so structural noise can cause unnatural pauses or mispronunciations in the generated speech.

  • Remove page numbers, headers, footers, and excessive line breaks.
  • The API processes text sequentially, so structural noise can cause unnatural pauses or mispronunciations in the generated speech.

Estimating character count

Each API request supports up to 4096 characters. Calculate your total characters to determine how many requests are needed. Remember that spaces and punctuation count toward this limit, affecting both processing time and cost.

  • Each API request supports up to 4096 characters.
  • Calculate your total characters to determine how many requests are needed.
  • Remember that spaces and punctuation count toward this limit, affecting both processing time and cost.

Choosing the Right Voice

Sound wave illustration for: Choosing the Right Voice

Selecting a voice that aligns with your book’s genre ensures listener engagement. The API provides eight distinct presets, ranging from the warm, clear narration of Aria to the deep, documentary style of Orion. Each voice is optimized for specific tones, allowing you to match the emotional weight of self-published fiction or the instructional clarity of non-fiction.

Matching voice tone to genre

For thriller novels, Felix offers an energetic, promo-style delivery that keeps tension high. In contrast, Luna’s soft, storytelling cadence suits fantasy or romance. For business or self-help books, Sage provides a calm, instructional tone, while Milo’s friendly, conversational style works well for memoirs. Atlas remains neutral for news-style content, and Nova brings a bright, upbeat energy suitable for light reads.

  • Aria: Warm, clear narrator for general fiction
  • Nova: Bright, upbeat for light reads
  • Luna: Soft, storytelling for fantasy/romance
  • Sage: Calm, instructional for non-fiction
  • Felix: Energetic, promo for thrillers
  • Milo: Friendly, conversational for memoirs
  • Atlas: Neutral, news-style for reports
  • Orion: Deep, documentary for serious topics

Testing samples before bulk generation

Before processing entire chapters, generate short samples using the API’s 4096-character limit. This allows you to verify that the voice captures the intended nuance without wasting credits on large batches. Use the speed parameter (0.25–4.0) to adjust pacing for natural listening. Since requests are processed sequentially, short tests remain quick even under load.

Consistency across chapters

Maintain the same voice and speed settings across all chapters to ensure a uniform listening experience. Since voices are based on licensed recordings from LibriVox, the acoustic quality remains consistent, but the API does not support custom voice cloning. If switching voices, note the change in metadata so listeners are aware of the shift. The API does not support custom voice cloning, so consistency relies on preset selection.

Configuring the API Request

Sound wave illustration for: Configuring the API Request

Configuring the API request requires precise parameter selection to ensure high-quality audio output. The endpoint accepts a JSON body containing the text input, voice selection, and format specifications, allowing no-code developers to automate the conversion process efficiently.

Setting the model parameter

Select between "tts-1" or "tts-1-hd" for your synthesis engine. Both models use the same underlying engine and pricing structure, offering no cost or quality distinction for standard use cases.

Defining the response format

Specify the output format using mp3, wav, opus, flac, or pcm. MP3 is recommended for general distribution due to its balance of file size and compatibility, while WAV or FLAC suits archival needs.

Adjusting speed for narration

Set the speed parameter between 0.25 and 4.0 to control narration pace. Adjusting speed can help fit specific word counts into time constraints, but values outside the standard range may affect voice clarity.

Processing Long Text Chunks

Sound wave illustration for: Processing Long Text Chunks

The API enforces a strict 4096-character limit per request. Your automation script must parse the extracted text and split it into chunks that do not exceed this threshold. Spaces and punctuation are counted toward the total. This ensures each request is valid and prevents silent truncation or errors during synthesis.

Since the API processes requests sequentially, your workflow must wait for the audio file of one chunk to complete before submitting the next. This prevents queue congestion and ensures predictable processing times. Do not send parallel requests for the same book chapter unless you have sufficient rate limit capacity.

Splitting logic for 4096 characters

Divide the text at natural boundaries, such as sentence ends or paragraph breaks, to avoid cutting mid-thought. Each chunk must be a complete request payload. If a single sentence exceeds 4096 characters, it must be split regardless of grammar, as the API does not handle overflow.

Use your programming language’s string slicing methods to enforce the limit. Ensure the split logic accounts for UTF-8 encoding if your PDF contains non-Latin scripts. Accurate splitting is critical for maintaining the continuity of the final audio file.

  • Count every character, including spaces and punctuation.
  • Split at sentence boundaries when possible.
  • Ensure each chunk is ≤ 4096 characters.

Sequential processing workflow

The API processes requests one after another. Your script should submit a chunk, wait for the response, save the audio file, and then submit the next chunk. This sequential approach minimizes the risk of exceeding the 60 requests per minute rate limit.

For long books, this process may take time. The typical speed is roughly real-time, but short phrases may take a few seconds. Plan your automation to run during off-peak hours if you are generating large volumes of content.

Handling network timeouts

Network interruptions can disrupt the sequential workflow. Implement retry logic with exponential backoff for failed requests. If a request fails, the character count is not charged, so you can safely retry without incurring extra costs.

Monitor your API key’s rate limit status. If you hit the 60 requests per minute limit, your script should pause and resume once the window resets. This prevents unnecessary errors and ensures smooth processing of your entire document.

Merging Audio Files

Sound wave illustration for: Merging Audio Files

After splitting your PDF text into 4096-character chunks, the API returns sequential audio files. You must concatenate these segments to reconstruct the full audiobook. This step ensures the narrative flows continuously without gaps between chapters or sections.

Concatenating MP3 segments

Use a reliable audio library to join the MP3 files in the exact order of your text chunks. Since the API processes requests sequentially, the output files will arrive in sequence. Ensure your merging tool supports standard MP3 concatenation without re-encoding, preserving the original synthetic speech quality.

  • Maintain original file order from the API response
  • Use lossless concatenation to avoid quality loss
  • Verify segment boundaries match character splits

Maintaining audio quality

Choose WAV or FLAC for high-fidelity masters before final distribution. MP3 is suitable for web delivery but may introduce compression artifacts. Ensure your merging software does not add silence or alter sample rates, which can disrupt listening experience for self-publishers.

Automating the merge process

Integrate the merge step into your workflow using tools like Zapier or Make. Trigger the automation after the last API request completes. This reduces manual effort and ensures consistent output for multiple books or series.

Quality Control and Review

Sound wave illustration for: Quality Control and Review

After generating audio segments, verify pacing by listening to the final concatenated file. Adjust the speed parameter (0.25–4.0) if narration feels too rushed or slow for your audience's expectations.

Listening for pacing errors

Use the speed adjustment to fine-tune delivery. Standard speed is 1.0; higher values accelerate narration, while lower values enhance clarity for complex text.

  • Test speed adjustments on sample chapters before bulk generation.
  • Adjust speed between 0.25 and 4.0 for optimal listener engagement.

Checking for missing segments

Ensure all 4096-character chunks were processed successfully. Check for gaps in the audio timeline where a request may have failed or timed out.

Verify that all segments are present and correctly ordered before distribution.

  • Confirm all chunks were generated without errors.
  • Check for gaps in the final audio file.

Validating language detection

Review audio for correct language pronunciation, especially in mixed-script documents. If the API guessed incorrectly, explicitly set the language parameter.

Ensure voices match the intended language, as any voice can speak any supported language.

  • Explicitly set the language parameter for non-English Latin-script text.
  • Verify pronunciation accuracy for all 23 supported languages.

Distribution Ready Formats

Sound wave illustration for: Distribution Ready Formats

Converting PDF text via TTS requires careful format selection to ensure compatibility with various distribution channels. By leveraging the API’s support for MP3, WAV, Opus, FLAC, and PCM, you can tailor the output to specific platform requirements, balancing quality and file size efficiently.

Understanding the technical specifications of each format helps avoid rejection during upload. While MP3 offers universal compatibility, lossless formats like FLAC preserve audio fidelity for archival purposes. Selecting the right format early streamlines the publishing workflow and reduces post-processing time.

Optimizing for podcast platforms

Most podcast hosting services accept MP3 files as the standard audio format. The API generates MP3 files. Using the response_format parameter set to mp3 ensures compatibility with major directories like Apple Podcasts and Spotify.

This format provides a good balance between file size and audio clarity. It allows for efficient bandwidth usage during playback, which is crucial for listener retention. No additional conversion steps are typically required before uploading your episode.

  • Use MP3 for universal streaming compatibility
  • Verify bitrate settings match platform guidelines
  • No extra conversion needed for most hosts

Preparing for Audible standards

Audible requires specific audio standards for audiobook submissions. Ensure your generated audio meets their bitrate and noise floor requirements. Checking the final output against Audible’s technical specifications is recommended before submission.

Consistency in voice and pacing across chapters is vital for Audible’s acceptance. Use the same voice parameter for all chapters to maintain a uniform listening experience. This prevents jarring transitions that could lead to customer complaints or rejection.

  • Meet Audible’s MP3/AAC technical specs
  • Maintain consistent voice across all chapters
  • Check noise floor and peak levels

File size considerations

File size impacts storage costs and download speeds. MP3 files are significantly smaller than WAV or FLAC, making them ideal for web distribution. For long-form content, consider the total size of all merged segments to ensure smooth user experiences.

Larger files may take longer to upload and process. If storage is a concern, use compressed formats like Opus or MP3. Balance the need for high fidelity with practical constraints to optimize your distribution strategy effectively.

  • MP3 reduces storage and bandwidth needs
  • WAV/FLAC are larger but lossless
  • Monitor total size for large books

Troubleshooting Common Issues

Sound wave illustration for: Troubleshooting Common Issues

When converting PDFs to audiobooks, special characters, footnotes, and page numbers often appear in the final audio. Since the API processes raw text, these artifacts can disrupt narration flow. You must clean the extracted text before sending it to the endpoint to ensure consistent playback quality across all chapters.

Language detection relies on script analysis. If the API misidentifies the language, the voice may sound unnatural or pause incorrectly. Explicitly setting the ISO language code in the request body overrides this guess, ensuring the correct pronunciation rules are applied regardless of the input text's appearance.

Handling special characters

PDF extraction tools often retain formatting symbols like asterisks, em dashes, or citation brackets. These characters are processed as spoken text or cause silence. Use a simple regex script to remove non-essential punctuation before calculating character counts. This prevents the API from reading unnecessary symbols, saving characters and improving audio clarity.

Ensure that your cleaning script handles ellipses and hyphenated words correctly, as these affect pacing. Removing them entirely may alter the meaning, so test a sample chapter to verify that the narrative flow remains intact after cleanup.

  • Remove page numbers and headers before API submission.
  • Replace em dashes with commas or periods for smoother listening.
  • Strip citation brackets (e.g., [1], [2]) to avoid reading them aloud.
  • Validate that ellipses (...) are converted to appropriate pauses or commas.

Resolving language guess errors

The API guesses language from script, defaulting to English for Latin text. For mixed-language documents or non-English Latin scripts, explicitly set the language field. This ensures the voice engine applies the correct phonetic rules. Without this, narration may sound like an English speaker with a foreign accent.

If you notice incorrect pronunciation, check the input text for mixed scripts. For example, technical terms in English within a German document might trigger English pronunciation rules. Setting the language parameter to the primary language of the document resolves this inconsistency.

  • Set language explicitly for non-English Latin text.
  • Use ISO codes (e.g., 'de', 'fr', 'es') to override detection.
  • Check for mixed scripts that might confuse the detector.
  • Verify pronunciation of technical terms in the target language.

Dealing with rate limits

The API allows 60 requests per minute per key. If you exceed this, requests are queued or rejected. For large PDFs, split the text into chunks of 4096 characters and process them sequentially. This ensures you stay within the limit while maintaining order. Use a simple script to batch requests with small delays between them.

Failed requests are free, but successful ones consume credit. Monitor your usage dashboard to avoid unexpected charges. If you need higher throughput, consider using multiple keys. However, for most self-publishers, sequential processing with a 60-request limit is sufficient for standard book lengths.

  • Split text into 4096-character chunks.
  • Process chunks sequentially to avoid rate limit errors.
  • Use a script to add small delays between requests.
  • Monitor usage dashboard to track character consumption.

Cost Management Strategies

Sound wave illustration for: Cost Management Strategies

Managing costs in self-publishing requires precise control over character consumption, as the API charges $0.01 per 1,000 characters. Since spaces and punctuation count toward this total, understanding your document’s exact length is the first step in budgeting for your audiobook project.

By tracking usage and optimizing text, you can predict expenses accurately. This section outlines how to monitor consumption, streamline your source text, and leverage the free trial to test workflows without financial risk.

Monitoring character usage

The dashboard on /get-api-key/ displays your current balance, characters remaining, and usage history. Each request consumes characters equal to the input text length, including spaces. You can see the exact character count in your API logs to verify charges.

Failed requests are free, so you can retry without penalty if synthesis errors occur. This ensures you only pay for successfully generated audio segments.

  • Check the /get-api-key/ dashboard for real-time balance and character counts.
  • Review API logs to correlate requests with character consumption.
  • Note that failed requests incur no charge.

Optimizing text for brevity

Since pricing is based on character count, reducing unnecessary whitespace or redundant phrasing directly lowers costs. For long-form content like novels, cleaning up PDF extraction artifacts (e.g., double spaces, page numbers) prevents paying for non-narrative text.

Ensure your text is within the 4096-character limit per request to avoid unnecessary splits, which can add overhead if not handled efficiently.

  • Remove extra spaces and formatting artifacts from extracted PDF text.
  • Eliminate redundant phrases or repeated headers.
  • Keep input text concise to minimize character count.

Using the free trial effectively

New accounts signed in with Google receive $0.50 in trial credit, valid for 7 days. This equals approximately 50,000 characters, enough to test voice selection, speed settings, and format outputs.

Use this trial to validate your workflow before committing to USDT top-ups. Email-based accounts do not receive this credit, so plan your initial testing accordingly.

  • Sign in with Google to activate the $0.50 trial credit.
  • Use the 7-day window to test voices and formats.
  • Note: Email-based accounts start without trial credit.

No-Code Integration Tools

Sound wave illustration for: No-Code Integration Tools

We provide a character-based API. For self-publishers and no-code developers, integrating this infrastructure into existing workflows requires minimal engineering effort. By leveraging visual automation platforms, you can connect your PDF ingestion pipeline directly to audio generation without writing custom code.

This approach ensures that text extraction, preprocessing, and voice synthesis occur in a synchronized sequence. The following tools facilitate seamless data movement between your document storage and our API endpoint, allowing you to scale audiobook production alongside your writing output.

Using Zapier for automation

Zapier enables the creation of triggers that initiate audio synthesis when a new PDF file is detected in your cloud storage. By configuring a Zap, you can automatically send the extracted text to the API endpoint, receive the audio file, and store it in a designated folder. This reduces manual intervention and ensures consistent processing for each chapter.

  • Trigger: New file in Google Drive or Dropbox
  • Action: Send POST request to API with text payload
  • Result: Save generated MP3 to cloud storage

Connecting to Google Sheets

Google Sheets can serve as a central dashboard for managing your audiobook project data. You can use Add-ons or simple scripts to send text snippets to the API and log the results back into the sheet. This allows you to track character counts, status, and file URLs in one place, providing a clear overview of your production pipeline.

  • Log API responses directly into spreadsheet columns
  • Track character usage per chapter for cost estimation
  • Monitor status of pending or completed generations

Building simple UIs with Make

Make (formerly Integromat) offers more complex routing capabilities for nuanced workflows. You can build scenarios that handle rate limits by queuing requests when the 60 requests per minute threshold is approached. This ensures that your automation remains stable even during bulk generation, preventing data loss and maintaining the integrity of your audio files.

  • Handle rate limits with automatic queuing
  • Retry failed requests with exponential backoff
  • Visualize workflow steps for easier debugging

Licensing and Commercial Use

Sound wave illustration for: Licensing and Commercial Use

Generated audio files are synthetic, allowing direct commercial use in your published works. The API output is yours to distribute without ongoing royalty obligations to voice actors, provided you adhere to the platform’s terms of service.

Rights to generated audio

You retain full commercial rights to the generated MP3, WAV, or FLAC files. You do not need to pay additional royalties per download or stream.

  • Full commercial ownership of output files
  • No per-unit royalty fees
  • Use in paid audiobooks, podcasts, or courses

Attribution requirements

Attribution is not mandatory for commercial distribution. However, including a note that the audio was generated by ScribeRead TTS API is recommended for transparency with your audience.

Commercial distribution rights

You may sell the audio on platforms like Audible, Spotify, or Apple Books. The audio includes an inaudible synthetic watermark, which does not restrict commercial use but serves as a marker of origin. No additional licenses are required for global distribution.

  • Compatible with major audiobook platforms
  • Inaudible watermark does not hinder sales
  • Global commercial rights included

Future Proofing Your Workflow

Sound wave illustration for: Future Proofing Your Workflow

Ensure your workflow scales efficiently by processing multiple titles in parallel. Since requests are handled sequentially per key, monitor your 60 requests-per-minute limit to prevent bottlenecks during bulk generation phases.

Scalability for multiple books

Design your integration to handle varying text volumes without manual intervention. Use the character-based pricing model ($0.01 per 1,000 characters) to predict costs accurately as your library grows. Automate the splitting of long texts into 4096-character chunks to maintain consistent processing speed.

  • Parallelize requests across multiple keys if volume exceeds 60 requests/minute.
  • Use automated scripts to manage chunking and merging logic.

Voice selection

Currently, eight preset voices are available for all genres. As your catalog expands, assign specific voices to different genres (e.g., Atlas for news, Luna for storytelling) to maintain brand consistency across titles. Test each voice with representative text samples before committing to a bulk generation run.

  • Aria for warm narration.
  • Felix for energetic promos.
  • Milos for conversational styles.

Updating language support

Language support is fixed at 23 languages. Verify that your source PDFs contain text in supported languages before generation. If new languages are added to the API, update your validation logic to ensure the language parameter is correctly set for non-English Latin-script texts to avoid incorrect language guessing.

  • Check for new language additions periodically.
  • Update validation scripts to include new ISO codes.

Listen to the 8 voices

Each sample below was generated by this API from the same sentence. His style keeps long-form non-fiction engaging without sacrificing clarity.

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-python on GitHub
  3. curl documentation
  4. Creative Commons Attribution 4.0
  5. LibriTTS-R corpus (OpenSLR 141)
  6. MDN: Web Speech API
  7. Python documentation
  8. FFmpeg documentation
  9. ISO 639 language codes
  10. openai-node on GitHub
  11. IETF RFC 7845: Ogg Opus
  12. OpenAI API reference: create speech

More on this site