How I Automate ElevenLabs Voiceovers Using Make
The Weekend Workflow That Prompted My Automation Pipeline
I spent three hours every Sunday doing the exact same manual task: copying script paragraphs from my Notion workspace, pasting them into the ElevenLabs web interface, tweaking the voice stability slider, downloading the rendered MP3, renaming it to match my video draft, and re-uploading it to Google Drive. When you run multiple faceless channels and audio-enabled blogs from a home office, manual tasks like that don’t just waste time—they kill your consistency.
If you produce content daily or in large batches, manual file management becomes a bottleneck fast. That was the primary reason I decided to automate ElevenLabs voiceovers with Make. By setting up a scenario that connects your content database directly to ElevenLabs’ API, you can drop a finished script into a database, turn on a toggle, and receive a perfectly rendered audio file in your cloud storage seconds later without ever opening the browser tab for voice synthesis.
This step-by-step guide walks through building a reliable pipeline to automate ElevenLabs voiceovers using Make, avoiding common API character limit pitfalls, and keeping your audio rendering costs under control.
What You Need Before Setting Up Your Make Scenario
Before building the automation scenario, you need a few core components configured in advance so data passes cleanly between services.
- An ElevenLabs Account: You will need an API key from your profile settings. Note that API access is available across various tiers, including free and starter options, though higher volume rendering requires paid allocation. Always verify current usage limits on the official ElevenLabs pricing page before kicking off large jobs.
- A Make Account: Make (formerly Integromat) offers a free plan with a generous monthly operation limit, while paid plans generally start around the $10 to $20/month range depending on your execution frequency. Check Make’s pricing page to choose the right tier for your run volume.
- A Structured Script Database: You need a central database where your script text lives. Notion, Google Sheets, or Airtable work best because they allow you to set clear trigger conditions (such as a status dropdown set to “Ready for Audio”).
- A Cloud Storage Destination: Google Drive or Dropbox will hold the generated audio output for your editor or publishing queue.
Architecture of the Voiceover Automation Workflow
The core pipeline consists of four distinct modules in Make. Understanding how data flows through each stage helps you troubleshoot if a run fails.
| Stage | Module Type | Primary Function |
|---|---|---|
| 1. Trigger | Notion / Google Sheets | Watches for database entries marked ready for processing. |
| 2. Synthesis | ElevenLabs (HTTP or Native) | Sends script text and parameters to generate audio binary data. |
| 3. Storage | Google Drive / Cloud Drive | Creates an MP3 file from binary data and saves it with a structured name. |
| 4. Update | Notion / Google Sheets | Updates original record with the audio URL and changes status to done. |
Step-by-Step Setup Guide to Automate ElevenLabs Voiceovers with Make
Step 1: Configure Your Script Database Trigger
Start by setting up your source database. If you use Notion, create a database with four basic properties: Title (Text), Script Content (Text/Rich Text), Status (Select tag with options like Draft, Ready for Voiceover, Done), and Audio File (URL or File attachment).
In Make, create a new scenario and select the Notion module titled “Watch Database Items” (or the equivalent trigger for Google Sheets). Connect your account, select your database ID, and set the filter condition so the scenario only processes items where Status equals “Ready for Voiceover”. Set your scenario execution schedule to run at specific intervals or on demand.
Step 2: Add the ElevenLabs Generation Module
Add a new module immediately after your trigger. Make includes a native ElevenLabs module, though you can also use the generic HTTP “Make a Request” module if you want custom endpoint control over raw API payload parameters.
When using the native ElevenLabs module, select the action “Generate Speech” (or “Text to Speech”). Authenticate by pasting your ElevenLabs API Key, which you can copy directly from your ElevenLabs account profile. Once connected, configure the key fields:
- Voice ID: Select your preferred custom or pre-made voice from the dropdown list. If using custom cloned voices from your voice lab, copy the unique Voice ID string from ElevenLabs and paste it into the field.
- Text Content: Map the database property holding your script body from the initial trigger step.
- Model ID: Select the active synthesis model (such as Multilingual v2 or Turbo v2.5 depending on your language needs and speed preferences).
Step 3: Fine-Tune Voice Stability and Expressiveness Settings
Default voice settings don’t always yield the best output for long-form narration. In your ElevenLabs module configuration, expand the advanced settings or parameters section to customize output dynamics:
Set Stability around 0.50 to 0.65. Setting stability too low causes erratic emotional shifts across long paragraphs, while setting it too high makes the voice sound monotonic and robotic. Set Similarity / Clarity between 0.75 and 0.85 to preserve voice identity without introducing audio artifacting. If you notice strange breath sounds or awkward pauses, tweak the style exaggeration slider downward.
Step 4: Save the Rendered Audio Binary to Cloud Storage
The ElevenLabs module outputs binary audio data upon successful synthesis. To convert this raw output into an accessible file, connect a storage module like Google Drive (“Upload a File”).
Select your target folder. In the File Name field, construct a dynamic string using data from Step 1—for instance, mapping the script title alongside a time tag (e.g., Title_Voiceover.mp3). In the File Content field, select the output data string returned directly by the ElevenLabs module.
Step 5: Write Back to Your Database and Update Status
To prevent your scenario from processing the exact same script twice on its next schedule, add a final database update step. Choose the Notion module “Update a Page” or Google Sheets “Update a Row”.
Map the ID from your trigger step. Change the Status field from “Ready for Voiceover” to “Completed”, and map the newly created Google Drive file URL into your database link property. Turn on the scenario and perform a test run with a short test script.
Handling Long Scripts and API Limits
One major issue I ran into when building this pipeline for my own YouTube scripts was handling single API request character limits. ElevenLabs imposes character caps per single request depending on the endpoint used.
If your script exceeds the character limit for a single payload, sending the text straight through will trigger an HTTP 400 error in Make and halt execution. Here is how to fix it:
- Text Chunking with Make Functions: Use Make’s text parsing modules or split formulas to break long scripts at sentence boundaries (using period delimiters) into smaller chunks under 2,000 characters.
- Iterator Loop: Pass those chunks through an Iterator module so Make sends each paragraph as a separate request to ElevenLabs.
- Merging Audio Files: While you can store chunks individually, merging them into a single audio file directly in Make requires specialized third-party tools like CloudConvert. Alternatively, save the numbered sequence (Part1.mp3, Part2.mp3) to a folder and let your video editing software assemble them on your timeline.
My Take
Automating your voice synthesis pipeline completely changes how fast you can execute content, but it isn’t a magical solution for every format. Here is my honest assessment after generating hundreds of voice tracks through API pipelines:
Where this setup excels is speed, consistency, and scale. For daily news recaps, faceless informational videos, educational shorts, and audio versions of long-form blog posts, automating ElevenLabs voiceovers with Make saves hours of tedious manual work every week. Once the setup is tested, it works quietly in the background without needing supervision.
Where it falls short is nuanced narrative content requiring fine emotional control. When you synthesize audio manually in the ElevenLabs dashboard, you can tweak specific lines, change word emphasis, and re-generate individual sentences until the inflection sounds right. In an automated API setup, you trade granular emotional control for production speed. If a line renders with an awkward inflection, you either live with it or re-render that specific snippet manually later.
Keep an eye on character consumption too. API calls burn through your monthly quota quickly during batch runs. I recommend adding a script character length validation filter in Make before the ElevenLabs call so you don’t accidentally burn thousands of characters on incomplete drafts or improperly formatted text templates.
FAQ
How much does it cost to automate ElevenLabs voiceovers with Make?
Costs depend entirely on your production volume across both platforms. ElevenLabs offers tiered plans starting from free and low-cost starter plans up through higher usage tiers, charged based on character counts. Make has a free plan that includes 1,000 operations per month, with paid tiers starting around $10 to $20/month range for higher operational capacity. Check official pricing pages for both platforms regularly to calculate costs based on your monthly character usage.
Can I automatically generate voiceovers directly from new WordPress posts?
Yes. You can swap the database trigger step in Make with a WordPress “Watch Posts” module. Whenever a new post is published, Make grabs the post body text, strips out HTML tags using Make’s native string manipulation tools, sends the clean text to ElevenLabs, and attaches the resulting MP3 back to the WordPress media library or post header automatically.
What happens if ElevenLabs fails to render during an automated run?
If ElevenLabs returns an error (such as hitting rate limits or running out of subscription characters), Make will stop execution by default. To prevent scenario failure, right-click the ElevenLabs module in Make, select “Add error handler”, and attach a “Break” or “Commit” directive. You can also configure an alert module (like Slack or email notifications) so you get notified immediately if a render fails.
