How to Generate Voice Over from Text for Dubbing?

By DubSync editorial team · Updated 2026-11-18

This guide shows freelance localization agents and solo dubbers how to turn scripts into consistent voice-overs using the DubSync API. Instead of booking studio time, you generate audio directly from text with eight distinct preset voices, ensuring your projects have consistent narration without the overhead of studio booking or complex tools.

You will learn the exact workflow: setting up your API key, handling long scripts by splitting them into manageable chunks, and managing multi-language projects with specific ISO codes. We cover technical setup, cost estimation, and quality control so you can deliver high-quality dubbing assets efficiently, whether you are working alone or coordinating with a small team.

How to Generate Voice Over from Text for Dubbing?

Frequently asked questions

What is the first step in generating voice-over from text?

Send a POST request to https://api.56x.info/v1/audio/speech with your text and API key. You need a valid Bearer token from your account dashboard. The API accepts JSON bodies similar to the OpenAI speech endpoint, allowing you to specify the model, voice, and language parameters directly in the request payload.

Do I need technical skills to use the TTS API?

Basic API knowledge is helpful but not strictly required. You can use the official OpenAI SDKs by changing the base_url, or send simple HTTP requests. The /get-api-key/ page provides ready curl examples, making it easy to integrate into your localization workflow without building a custom interface from scratch.

How do I handle scripts longer than 4096 characters?

Split your script into parts of up to 4096 characters each. Generate audio for each part individually, then join the resulting audio files. This ensures each request stays within the character limit while allowing you to produce full-length voice-overs from longer source texts efficiently.

Can I adjust the speed of the voice-over?

Yes, you can set the speed parameter between 0.25 and 4.0. This allows you to adjust the pacing to match the timing of your video or audio project. The API accepts this parameter alongside the text and voice selection to customize the final output speed.

What is the difference between tts-1 and tts-1-hd?

Both models use the same engine and price. The only difference is the model identifier you send in the request. There is no price difference between tts-1 and tts-1-hd, so you can choose either based on your preference without affecting your billing or character costs.

How do I choose the best voice for a specific script?

Select from eight presets like Aria, Nova, or Atlas based on your tone needs. Use GET /v1/voices to list available options. Match the voice to your content: Aria for narration, Felix for promos, or Atlas for news. Each voice supports all 23 languages, so pick based on style.

Is the audio quality suitable for professional dubbing?

The audio is generated from licensed recordings and includes an inaudible watermark marking it as synthetic. There is no SLA or uptime guarantee. Use formats like WAV or FLAC for high-fidelity delivery to clients, ensuring clear and consistent voice-overs.

Can I use the same voice for multiple languages?

Yes, every voice can speak any of the 23 supported languages. You can use Aria for English and then switch to French in the same project. Just set the language parameter to the ISO code, or let the API guess it from the script script.

How do I ensure consistency across different projects?

Use the same voice preset and speed settings across your projects. Since accounts are per site, you can manage your API key and balance centrally. Reusing the same voice parameters helps maintain a consistent brand voice for your localization clients across different scripts and languages.

What if the generated audio has pronunciation errors?

The API does not offer custom pronunciation lexicons or SSML. You can adjust the input text slightly to guide pronunciation, such as using phonetic spelling. Since there is no SSML support, you must rely on standard text formatting to influence how the model reads specific words.

Do I need to download an app to use the API?

No, you interact with the API via HTTP requests or SDKs. You can use the official OpenAI SDKs or plain HTTP. There is no mobile app or browser extension required. Everything is managed through your account dashboard and code integration, keeping your workflow lightweight.

How long does it take to generate a 1-minute voice-over?

Generation takes roughly real time, about 25 characters per second. A 1-minute voice-over typically requires a few seconds of processing. Requests are processed sequentially, so under load, you might experience slight delays. Short phrases also take a few seconds to synthesize and return.

Can I use the API for commercial projects?

Yes, you can use the generated audio for commercial projects. Input text is not used for training, and generated audio is returned in the response. There are no monthly plans or restrictions on usage, making it suitable for freelance localization agencies and solo dubbers delivering client work.

What is the best format for delivering audio to clients?

Choose WAV or FLAC for high-quality, uncompressed delivery. MP3 and OPUS are also available for smaller file sizes. PCM is supported for raw data. Select the format that matches your client’s requirements, keeping in mind that all formats are generated with the same underlying engine.

Understanding the Process

Sound wave illustration for: Understanding the Process

Text-to-audio conversion transforms written scripts into spoken audio files via a cloud API. You send text to an endpoint and receive an audio file, typically within seconds for short phrases. This method bypasses studio booking, allowing freelancers to generate voice-overs directly from scripts.

In localization, TTS enables rapid prototyping and consistent voice-overs across multiple languages. Instead of hiring separate voice actors for each language, you can generate high-quality audio using preset voices that maintain a uniform tone, streamlining the dubbing workflow for indie agencies.

Text to audio conversion

The process is simple: send a JSON POST request with your text and voice selection. The API returns an audio file in formats like MP3 or WAV. Texts up to 4,096 characters are processed in a single request, delivering synthetic speech with an inaudible watermark.

For longer scripts, split the text into parts, generate each, and join the files. This ensures reliable delivery even for lengthy dialogues, with costs calculated strictly by character count at $0.01 per 1,000 characters.

  • Send JSON body with text and voice ID
  • Receive MP3, WAV, OPUS, FLAC, or PCM
  • No streaming or WebSocket required

Role of TTS in localization

TTS allows dubbing agencies to produce consistent audio without managing multiple voice actors. With 23 supported languages, any voice can speak any language, ensuring tonal consistency across different linguistic versions of the same project.

You avoid scheduling conflicts and studio fees, focusing instead on script accuracy and voice selection. The API handles the synthesis, returning ready-to-use audio files for your dubbing pipeline.

  • 23 languages supported
  • Any voice can speak any language
  • Consistent tone across projects

Workflow automation

Automate your dubbing process by integrating the API into your existing tools. Use the OpenAI SDK or plain HTTP to send requests programmatically. This allows you to generate voice-overs for multiple scripts simultaneously, speeding up delivery for clients.

Monitor usage and costs directly through the API dashboard. Track characters used and balance remaining, ensuring you stay within budget. The API’s rate limits (60 requests per minute) handle standard workloads efficiently without manual intervention.

  • Use OpenAI SDK or cURL
  • Automate request sending
  • Monitor usage in real-time

Choosing the Right Voice

Sound wave illustration for: Choosing the Right Voice

Selecting the correct voice ensures your dubbed content resonates with the target audience. With eight distinct presets, you can align the vocal tone with the specific genre of your localization project, from documentary narration to upbeat promotional spots.

Each voice carries a unique character, allowing you to maintain brand consistency across different languages and regions without needing multiple voice actors.

Matching tone to content

Choose voices that complement your source material. For instance, use Atlas for neutral news reading or Orion for deep, documentary-style narration. Felix works well for energetic promos, while Luna suits soft storytelling.

The eight presets cover a wide range of styles, ensuring you find a match that fits the emotional context of your script without needing complex tuning.

  • Aria: warm, clear narrator
  • Nova: bright, upbeat
  • Luna: soft, storytelling
  • Sage: calm, instructional
  • Felix: energetic, promo
  • Milo: friendly, conversational

Gender and age options

The API offers four female and four male voices, providing balanced options for diverse casting needs. While age isn't explicitly labeled, the tonal qualities range from bright and energetic to deep and neutral.

These presets are based on licensed recordings from LibriTTS-R.

Consistency across projects

Stick to the same voice across multiple segments of a project to maintain audio continuity. This is crucial for long-form dubbing where listeners expect a single narrator.

Use the same voice parameter in your API requests for all related texts, ensuring the output sounds like it comes from the same source, even if recorded on different days.

Technical Requirements

Sound wave illustration for: Technical Requirements

To start generating voice overs, you need an API key from your 56x.info account. Keys are issued on the /get-api-key/ page and work with standard OpenAI SDKs by changing the base URL. Each account holds one active key; generating a new one immediately invalidates the old one.

Your requests must target the correct endpoint with a valid JSON body. Ensure your network can reach https://api.56x.info/v1 without blocking outbound connections, as all audio synthesis happens remotely via HTTP POST.

API key setup

Sign up on 56x.info and retrieve your key from the dashboard. Use the format Bearer tts-... in your Authorization header. Remember that only one key is active per account at a time.

The key grants access to the API and tracks your usage against your balance. Keep it private, as anyone with the key can consume your credits.

  • Retrieve key from /get-api-key/ dashboard
  • Use Bearer tts-... header format
  • New key invalidates old one immediately

JSON body structure

Send a POST request to /v1/audio/speech with a JSON body. Required fields include model (tts-1 or tts-1-hd), input (your text), and voice (one of eight presets).

Optional parameters like response_format and speed allow customization. The API returns the audio file directly in the response body.

  • Endpoint: POST /v1/audio/speech
  • Required: model, input, voice
  • Optional: speed, response_format

Network connectivity

Ensure your client has outbound internet access to api.56x.info. All processing occurs in the cloud, so local compute power is minimal.

Rate limits apply (60 requests/minute). If you exceed this, requests may queue or fail, returning a 429 error until the window resets.

  • Outbound access to api.56x.info required
  • Rate limit: 60 requests/minute
  • Failed requests do not consume credits

Handling Long Scripts

Sound wave illustration for: Handling Long Scripts

When your script exceeds the API’s 4,000-character limit, you must split the text into smaller chunks. Each request generates a separate audio file, so you handle the segmentation logic in your code or preprocessing tool before sending data to the endpoint.

The API returns individual audio files for each chunk. You then concatenate these files in sequence to recreate the full voice-over. This ensures you never hit the character cap while maintaining the integrity of the original script.

### Splitting text into parts

Splitting text into parts ['Break your input text into segments of up to 4,096 characters. Since spaces and punctuation count toward this limit, precise splitting prevents truncation. Send each segment as a separate POST request to the v1/audio/speech endpoint.'] []

Joining audio files ['The API returns distinct audio files for each request. You must programmatically join these files in the exact order of the original text segments. Use audio concatenation software or a simple script to merge them into a single continuous voice-over track.', '### Managing character limits'] []

Managing character limits ['Each request is capped at 4,096 characters. If your script is longer, you must manually or automatically divide it. Texts up to 4,096 characters are processed in a single request. Remember that synthesis takes time, so queueing many chunks may increase total generation time.', 'bullets']

Language Considerations

Sound wave illustration for: Language Considerations

When dubbing scripts, assuming language based on script shape can cause mismatches. If your source text uses Latin characters but is in Dutch, the API defaults to English unless you specify otherwise. Always set the language parameter to ensure accurate pronunciation and prosody for non-English languages, even when the script looks familiar. Our API supports 23 languages, including Arabic, Chinese, French, German, Hindi, Japanese, Korean, Russian, Spanish, and Swahili. Any voice can speak any of these languages, giving you flexibility in casting while maintaining consistent audio quality across different projects.

Specifying language codes

["The language field accepts ISO codes to override automatic detection. For example, setting language: 'nl' ensures Dutch pronunciation even if the text contains English loanwords. This prevents the engine from guessing incorrectly and producing unnatural audio for localization work.", 'bullets']

Script detection limits

['If you omit the language field, the system guesses based on script. Latin script defaults to English, which breaks non-English projects using Latin letters. Always explicitly define the language for multi-ethnic or mixed-script projects to avoid mispronunciations.', 'bullets']

Multi-language projects

['For scripts switching between languages, call the API separately for each language segment. This ensures correct accent and intonation for each part. Supported languages include Malay, Norwegian, Polish, Portuguese, Swedish, and Turkish, covering most common localization needs.', 'bullets']

Quality Control

Sound wave illustration for: Quality Control

Quality control ensures your dubbing sounds natural and accurate before delivery. Since the API processes requests sequentially, short phrases may take a few seconds to generate, allowing you to review audio without significant delay. Failed requests are free, so you can safely experiment with different settings without penalty.

Listening to outputs

Listen to the generated audio for pacing and tone consistency. The API processes requests one after another, so under load, generation might queue. Use the free trial credit or small top-ups to test voice choices.

  • Check for unnatural pauses or rushed speech.
  • Verify tone matches the script's intent.
  • Use free failed requests to test variations.

Checking for errors

Verify that the text was converted exactly as intended. The API does not support SSML or custom pronunciation lexicons, so standard punctuation is crucial. If the language is not set, it guesses from the script, which may default to English for Latin text. Always specify the language ISO code for non-English projects.

  • Ensure no extra characters were added.
  • Confirm correct language detection.
  • Check audio format compatibility (mp3, wav, opus, flac, pcm).

Iterating on prompts

Refine your text input to improve clarity. Use punctuation to control pacing, as the engine relies on standard text cues. If pronunciation is off, rephrase the text or adjust the speed parameter between 0.25 and 4.0. You can issue a new API key at any time, but the old one stops instantly.

  • Adjust speed for better pacing.
  • Rephrase ambiguous text.
  • Test different voices for fit.

Cost Management

Sound wave illustration for: Cost Management

Predicting costs is straightforward because pricing is linear: $0.01 per 1,000 characters, including spaces and punctuation. You can estimate project budgets by counting characters in your source scripts before sending them to the API.

Since failed requests are free, you only pay for successful synthesis. This makes the API safe for testing different voice models or speeds without financial risk before committing to full dubbing runs.

Estimating character counts

Count every character, including spaces, in your input text. The API charges based on the exact length sent, so accurate counting prevents surprise bills. For long scripts, split the text into 4,096-character chunks to stay within limits and simplify cost tracking per segment.

  • Space and punctuation count as characters
  • 4,096 characters max per request
  • Failed requests cost $0

Budgeting for large projects

Calculate your total character volume and multiply by $0.01 / 1,000. Use the free trial credit ($0.50) to test your workflow first. Top-ups via USDT (TRC-20) are processed within minutes, so you can scale up instantly without waiting for invoices or VAT paperwork.

  • Minimum top-up is $5
  • Balance never expires
  • No monthly subscription fees

Monitoring usage

Check your dashboard on /get-api-key/ to see real-time balance and characters used. Since requests are processed sequentially, high volume may queue, but costs remain strictly proportional to successful outputs. Track your usage to ensure you stay within your project budget.

Cost Management

Integration Tips

Sound wave illustration for: Integration Tips

Getting the audio generation pipeline running smoothly requires a reliable connection to the API. Freelancers often start with simple command-line tests before integrating into their dubbing workflow.

This section covers the practical steps to connect your scripts or tools to DubSync, ensuring your localization projects run without unnecessary friction or downtime.

Using cURL for testing

The fastest way to verify your key works is via a cURL command. Send a POST request to https://api.56x.info/v1/audio/speech with your JSON body containing the model, input, and voice fields. This confirms connectivity and syntax before building complex integrations.

Check the response headers for the audio file or error details. If the request succeeds, you receive the audio data directly, allowing you to save it locally for immediate review in your dubbing software.

  • Include Authorization: Bearer YOUR_KEY in headers.
  • Set response_format to mp3 for easy playback.
  • Test with short texts first to verify speed.

SDK implementation

Use the official OpenAI SDK by changing the base_url to https://api.56x.info/v1. This allows you to reuse existing code structures without learning a new client library. Pass your DubSync API key as the bearer token.

This approach simplifies integration for developers already familiar with standard TTS workflows. It ensures that your automation scripts for batch dubbing remain lightweight and maintainable.

Error handling strategies

Monitor your rate limits (60 requests per minute). If you exceed this, the API returns an error code. Implement exponential backoff in your scripts to retry automatically without overwhelming the server.

Always check the HTTP status code. A 4xx error usually indicates an invalid key or format, while 5xx suggests a temporary server issue. Failed synthesis requests are free, so retrying is safe if the input was valid.

Common Challenges

Sound wave illustration for: Common Challenges

Dubbing requires precise synchronization between voice and visual cues. While TTS handles text conversion efficiently, small mismatches in timing or emphasis can disrupt the final product.

Addressing these common hurdles ensures your localized audio tracks remain professional and engaging for end audiences.

Pronunciation issues

The engine guesses language from script, but Latin text defaults to English. If your source text contains proper nouns or mixed languages, the AI may mispronounce names.

Set the language field explicitly (e.g., es for Spanish) to ensure accurate articulation. This avoids awkward misreadings in multi-language scenes.

  • Use explicit language codes for mixed-script texts
  • Pre-check proper nouns in your source script
  • Avoid ambiguous homographs where possible

Pacing adjustments

Standard speed (1.0) may feel too fast for emotional scenes or too slow for action sequences. You can adjust the speed parameter between 0.25 and 4.0.

For dubbing, slightly slower speeds often better match lip-sync requirements. Test short phrases first to find the optimal rhythm for each voice preset.

  • Adjust speed for lip-sync accuracy
  • Test 0.8–0.9 speed for dramatic dialogue
  • Use higher speeds for rapid-fire narration

Audio format compatibility

Choose mp3 for web delivery or wav/flac for high-quality editing. The API returns a single audio file per request.

Ensure your video editor supports the chosen format. For complex projects, you may need to concatenate multiple audio segments manually.

  • Use mp3 for quick web uploads
  • Select wav or flac for editing
  • Verify editor compatibility before bulk generation

Best Practices

Sound wave illustration for: Best Practices

Generating consistent voice-overs for dubbing requires disciplined input management. Cleaning your source text ensures the TTS engine processes characters efficiently, reducing costs and avoiding unexpected pauses. Since spaces and punctuation count toward the 4,096-character limit per request, stripping unnecessary markup or notes before submission keeps your audio clean and your budget predictable.

Proper punctuation directly influences pacing and intonation. Commas create brief pauses, while ellipses (...) indicate trailing thoughts. Without explicit cues, the engine guesses rhythm, which can break immersion in localized dialogue. Standardizing these markers across scripts helps maintain a natural flow, crucial for freelance dubbing projects where consistency defines quality.

Cleaning up source text

Remove non-speech elements like stage directions or metadata before sending text to the API. This prevents the engine from reading out brackets or numbers that don’t belong in the final audio. Since input text is used only to produce the audio and is not used for training, you can safely preprocess large scripts.

Ensure character counts stay well below the 4,096 limit per request to avoid splitting audio unnecessarily. Consolidate repetitive phrases if possible, as each request incurs a processing step. Clean text also reduces the risk of misinterpretation, ensuring the voice renders exactly what the director intended.

  • Strip HTML tags and brackets before submission.
  • Remove non-speech metadata or stage directions.
  • Verify character count stays under 4,096 per request.

Using punctuation effectively

Use commas for short pauses and periods for full stops. The engine respects these cues to determine natural breathing points. Avoid overusing exclamation marks or question marks, as they can artificially exaggerate emotion beyond the voice preset’s designed tone.

For trailing thoughts or hesitation, use three dots (...). This signals a slower, trailing pace rather than a hard stop. Consistent punctuation usage across multiple episodes or projects ensures the voice sounds uniform, even if different freelancers prepare the scripts.

  • Use commas for brief pauses.
  • Use periods for clear stops.
  • Use ellipses (...) for trailing thoughts.

Standardizing voice choices

Assign specific voices to character types or segments early in the workflow. For example, use 'aria' for narration and 'milo' for conversational dialogue. This consistency helps listeners distinguish between speakers and maintains brand or project identity across localized content.

Document your voice choices in a shared style guide. Since you can issue a new API key at any time, ensure your team uses the same key. Standardizing voices reduces decision fatigue and speeds up the production pipeline for freelance teams.

  • Assign voices to character types.
  • Document choices in a style guide.
  • Use the same API key for tracking.

Tools for Freelancers

Sound wave illustration for: Tools for Freelancers

Freelance dubbers rely on a lightweight stack to convert scripts into audio efficiently. While the DubSync API handles the synthesis, selecting the right companion tools for input and output streamlines the entire localization workflow without adding unnecessary complexity.

API clients

Use Postman or Insomnia to craft and test JSON payloads before integrating them into your pipeline. These tools help you verify voice selection, speed, and format settings, ensuring the request body matches the required structure for the speech endpoint.

  • Postman for visual request building
  • Insomnia for lightweight testing
  • cURL for quick terminal checks

Text preprocessing tools

Clean source text before sending it to the API. Remove unnecessary metadata or formatting that might interfere with character counts. Simple scripts in editors like VS Code or Sublime Text work well for this preparation step.

  • VS Code for text cleaning
  • Sublime Text for lightweight editing
  • Basic regex for formatting removal

Audio concatenation software

Since the API returns separate audio files for long texts, you need a tool to join them. Use FFmpeg or Audacity to merge the generated clips into a single, continuous voice-over file ready for your dubbing project.

  • FFmpeg for command-line merging
  • Audacity for visual editing
  • Sox for simple concatenation

Future Scalability

Sound wave illustration for: Future Scalability

As your dubbing workload grows, the API’s straightforward character-based pricing and 60 requests-per-minute limit provide a predictable foundation. You can handle larger volumes by splitting long scripts into manageable chunks, ensuring consistent audio quality without unexpected bottlenecks during peak production periods.

Automation becomes key when scaling. By integrating the TTS endpoint into your existing localization pipeline, you can generate voice-overs for multiple languages simultaneously. This reduces manual coordination time, allowing you to focus on creative direction rather than file management.

Increasing project volume

The API handles up to 4096 characters per request, making it easy to batch longer scripts. With a minimum top-up of $5 and transparent per-character billing, you can scale from small indie projects to larger agency contracts without renegotiating complex contracts or paying for idle capacity.

Since generated audio is not stored, you only pay for what you produce. This model supports high-volume output efficiently, allowing you to generate hundreds of voice-overs daily while maintaining control over your spending through the TRON network top-ups.

  • No minimum spend requirements
  • Transparent character-based billing
  • Efficient handling of large text batches

Automating workflows

You can integrate the API into scripts using cURL or any standard HTTP client. This allows you to automatically convert localized text files into audio files, streamlining the transition from translation to final audio delivery for dubbing projects.

By standardizing the API call structure, you can build custom tools that pre-process text, handle language detection, and manage voice selection. This reduces human error and ensures consistent output quality across all your dubbing projects, regardless of volume.

  • Simple cURL integration
  • HTTP-based automation
  • Custom script compatibility

Team collaboration

Since the API is accessed via a single key per account, you can share access with team members for smaller teams. Each member can generate audio using the same voice presets, ensuring consistency across different projects and translators.

As your team grows, you can issue a new API key to rotate access without losing your balance. This allows for secure sharing of credentials while maintaining a clear audit trail of usage and costs for billing purposes.

  • Shared API key access
  • Easy key rotation
  • Consistent voice presets

Listen to the 8 voices

Each sample below was generated by this API from the same sentence.

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. TRON developer hub: TRC-20
  5. LibriTTS-R corpus (OpenSLR 141)
  6. Tether (USDT)
  7. ISO 639 language codes
  8. Creative Commons Attribution 4.0
  9. MDN: Web Speech API
  10. LibriVox public-domain audiobooks
  11. OpenAI API reference: create speech
  12. openai-node on GitHub

More on this site