How to Automatically Repurpose Blog Posts into Videos Using Pictory and Make.com

A blog post can become a captioned vertical video about fifteen minutes after it enters a queue, with nobody opening a video editor at any point. That is what this guide builds. If you searched for how to repurpose blog posts into videos automatically, this is the setup: Make.com picks up the post, an AI step condenses it into a 60 to 90 second script, Pictory turns that script into a narrated, captioned video with matched stock footage, and the finished file lands in Google Drive with a Slack ping. Once it is running, the human work per video is a few minutes of watching the preview.

This is a workflow guide, not a review and not a case study. Both tools already have their own reviews on this site: the Pictory review covers what it does and does not do, and the Make.com review covers the automation platform and its learning curve. This post is the part neither review has room for: the wiring. It walks through every module, the prompt that makes the scripts usable, what it costs per month, the mistakes that trip people up, and the honest quality ceiling of what comes out. Every module, field, and price below was checked against Make's and Pictory's own documentation in September 2026. The time and quality figures are realistic estimates based on typical usage, not measurements from a specific batch.

Use code BLAZE for 20% off your first Pictory subscription on an annual plan (expires October 15, 2026). The Professional Annual Plan drops from $420 to $336 for your first year.

How I Tested This

What this workflow actually does

Here is the chain, end to end, so you can decide in thirty seconds whether it fits how you publish:

1. A new post enters a queue. In this guide that is a row in a Google Sheet with the post title and URL. For WordPress users it can be the post itself. For everyone else, an RSS feed works.
2. Make fetches the article and strips it to plain text. No copy and paste.
3. An AI model condenses the article into a short script. One sentence per line, 130 to 170 words, with a hook at the top and a "read the full review" line at the bottom. This step is the difference between a usable video and a twelve-minute slideshow.
4. Pictory builds a storyboard from that script. Each line becomes a scene with matched stock footage, an ElevenLabs voice reads it, captions are burned in, and your brand kit is applied.
5. Pictory renders the final video once the storyboard is ready.
6. Make delivers the file to Google Drive, updates the sheet, and pings Slack so you know there is something to review.

Two things worth being clear about before you spend a weekend on this. First, Pictory assembles video from stock footage; it does not generate original shots. If you want footage that does not exist yet, this is the wrong workflow and the best AI video generator roundup is the right page. Second, there are two levels of automation here, and they need different Pictory plans:

• Level 1, semi-automatic. Make fetches the post, writes the script, and drops it in your sheet. You paste the script into Pictory's app and click generate. This works on any standard Pictory plan and cuts the manual job from roughly half an hour to about ten minutes.
• Level 2, fully automatic. Make talks to Pictory directly through its API and nothing is pasted anywhere. This needs Pictory API access, which is a separate subscription from the app plans. The rest of this post builds Level 2, but every step up to the Pictory module is the same for both.

What You Need Before Starting

Six things. Get them all in place before you open the scenario editor, because the Pictory connection in particular is the step people hit a wall on.

1. A Pictory account with API access. Make's Pictory module authenticates with an OAuth2 client ID and client secret, which you copy from the API Subscription page inside your Pictory account. As of September 2026, API access is sold separately from the Starter, Professional, and Team app plans. The self-serve API plan is $79 per month billed annually or $99 month to month, with 600 video minutes and 120 ElevenLabs voiceover minutes per month, and top-ups of 120 credits for $49. If you only want Level 1, a standard app plan is enough: Starter at $25 a month or Professional at $35 a month on annual billing, and code BLAZE takes 20% off your first annual subscription until October 15, 2026. The code is advertised for the app plans; whether it applies to the API plan is not confirmed, so treat it as a discount on the app subscription.
2. A Make.com account. The free plan gives you 1,000 operations a month with a 15-minute minimum polling interval, which is enough to build and run this at a weekly cadence. Core at $9 a month on annual billing gets you scheduling down to the minute and a 10,000-operation bundle. Sign up for Make and build on the free plan first.
3. A content source Make can read. Make runs in the cloud and cannot see files on your computer. This guide uses a Google Sheet as the queue because it works for any site, including one with no WordPress and no RSS feed (this site is Next.js on Vercel, and a sheet is the same pattern that runs its LinkedIn posting). If you are on WordPress, Make has a native WordPress module. If you have an RSS feed, Make's RSS module works too.
4. An AI model connection. Make has native OpenAI and Anthropic Claude modules. You need an API key from one of them. The summarization step costs a fraction of a cent per post on any current mid-tier model, so this is the cheapest line in the budget by a wide margin.
5. Somewhere to put the videos. This guide uses Google Drive. Dropbox and OneDrive work the same way. Slack is optional but useful for knowing when a video is waiting.
6. A brand kit set up inside Pictory. Logo, colors, fonts, and your default caption style. Do this in the Pictory app once, before automating anything, or every video will come out in Pictory's default look and you will end up re-rendering the first batch.

Step 1: Build the queue

Create a Google Sheet called something like Blog to Video Queue with these columns in row 1:

The Status column is doing real work. It is the reason a post never gets processed twice, it is what lets you pause everything by simply not adding rows, and it is where you will look when something breaks. Add three or four posts with Status set to Ready before building anything else, so you have real data to test against.

WordPress alternative. Replace the Google Sheets trigger in Scenario 1 with WordPress > Watch Posts, filtered to published posts. You lose the review gate, so every new post becomes a video whether you wanted one or not. Keep the sheet as a log even if the trigger is WordPress.

RSS alternative. Use RSS > Watch RSS feed items pointed at your feed. Same trade-off as WordPress, and RSS feeds often truncate the article body, so keep the HTTP fetch step below rather than relying on the feed's description field.

Step 2: Connect Pictory to Make

1. In your Pictory account, open the API Subscription page and copy your client ID and client secret. If you do not see that page, you do not have API access yet and you are looking at the Level 1 workflow until you do.
2. In Make, go to Connections in the left sidebar, click Add, search for Pictory, give the connection a name, and paste in the client ID and client secret.
3. While you are there, add connections for Google Sheets, Google Drive, and either OpenAI or Anthropic Claude. Each is an OAuth popup or an API key field. Five minutes total.

One thing to know before you get stuck: Pictory's newer API documentation describes an API key that starts with pictai_, while Make's connection dialog asks for the OAuth2 client credentials. Use whatever your Pictory API Subscription page shows you. If the Make connection refuses your credentials, Pictory's Make an API call module lets you hit the raw endpoints with whichever key format your account uses, and it is a fallback that leaves the rest of the scenario unchanged.

Step 3: Scenario 1, from queue to storyboard

Create a new scenario and add these six modules left to right. Every module is one operation per run.

Module 1: Google Sheets > Search Rows. Select your sheet, set Table contains headers to yes, filter on Status equal to Ready, sort by ID ascending, and set Maximum number of returned rows to 1. This is the trigger. If no row is Ready, the run stops here and costs a single operation.

Module 2: HTTP > Make a request. Method GET, URL mapped from the URL column. Leave Parse response off; you want the raw HTML.

Module 3: Text parser > HTML to text. Map the HTTP module's data into it. This strips tags, navigation, and scripts and leaves you with article text. It is not perfect (footer links sometimes survive), which is one more reason the AI step below is told to ignore anything that is not the article body.

Module 4: Anthropic Claude > Create a Message (or OpenAI > Create a Completion, the setup is identical). Pick a current mid-tier model, set max tokens to around 400, and paste the prompt from the section below into the user message with the plain text from Module 3 mapped in at the end. The output is the script.

Module 5: Pictory > Create a storyboard. This is the module that matters, and the fields mirror Pictory's storyboard API, so if a label in your version of the module differs slightly from what is listed here, match it to the same API field.

• Video name: map the Title column.
• Scenes > Story: map the script text from Module 4.
• Create scene on new line: yes. This is what turns each line of the script into its own scene with its own footage.
• Create scene on end of sentence: no. Otherwise a two-sentence line becomes two scenes and your pacing falls apart.
• AI storyboard: enabled. Pictory picks the layout and styling.
• Voice over: enabled, with an ElevenLabs speaker chosen from the list. Voice names are case-sensitive in the API, so pick from the dropdown rather than typing.
• Aspect ratio: 9:16 for Shorts, Reels, and TikTok. 16:9 if the videos are for YouTube proper or a blog embed.
• Background music: optional. Low volume works for vertical social clips; turn it off for anything built around a screen recording.

The module returns a job ID. That is all you get at this stage; the storyboard is built asynchronously.

Module 6: Google Sheets > Update a Row. Map the row number from Module 1, set Status to Storyboarding, and write the job ID from Module 5 into StoryboardJobId. Do this immediately, in the same run. If the scenario runs again before this row is updated, you get two storyboards for one post and you pay Pictory quota for both.

Click Run once with a real row marked Ready. If the Pictory module goes green and the sheet updates, Scenario 1 is done.

Step 4: Scenario 2, render the storyboard

In Make, a Watch module is a trigger and has to be the first module in its own scenario, so rendering lives in a second, tiny scenario.

Module 1: Pictory > Watch storyboard jobs. Fires when Pictory finishes building a storyboard and its preview.

Module 2: Filter. Only continue if the job status is a success. Failed storyboards should not be rendered; they should be logged.

Module 3: Pictory > Generate video from storyboard. Map the job ID from the trigger. This returns a second job ID for the render.

Module 4: Google Sheets > Search Rows, filtering StoryboardJobId equal to the trigger's job ID, then Google Sheets > Update a Row to set Status to Rendering and write VideoJobId.

The optional approval gate. If you want to check the preview before spending render quota, replace Module 3 with a Slack > Create a Message that posts the preview link, and move the render into Scenario 1's pattern: a Search Rows trigger that looks for Status equal to Approved. You then flip the status by hand after watching the preview. A sensible pattern is to run with the gate for the first few videos and turn it off once you trust the prompt, because a quick review at the end of the pipeline is faster than one in the middle.

Step 5: Scenario 3, deliver and log

Module 1: Pictory > Watch video jobs. Fires when a render completes successfully and gives you the video URL.

Module 2: HTTP > Get a file. Map the video URL. This pulls the MP4 as binary data.

Module 3: Google Drive > Upload a File. Choose the folder, map the file data from Module 2, and name the file from the sheet's Title (fetch it with a Search Rows on VideoJobId first, or just use the Pictory video name, which is the title anyway).

Module 4: Google Sheets > Update a Row. Status to Done, VideoURL to the Drive link.

Module 5: Slack > Create a Message (optional). One line with the title and the Drive link.

That is the whole build. Three scenarios, thirteen modules, and after the first successful run the only thing you touch is the sheet.

Step 6: Schedule it and budget your operations

Scenario 1 is the only one that polls, and polling is where Make budgets die. Schedule it every six hours. That is four runs a day, and an idle run costs one operation, so the ceiling for doing nothing is about 120 operations a month. Each video costs roughly 13 operations across the three scenarios. At 20 videos a month you are at around 380 operations, well inside the free plan's 1,000. Do not set Search Rows to run every 15 minutes because it is available; you would spend 2,880 operations a month checking an empty sheet, which is the exact polling trap covered in the Make.com review.

Two more housekeeping items. Make charges operations for failed runs, so add an error handler on the Pictory module that writes Failed to the row instead of letting the scenario retry. And turn Scenario 1 off while you edit the prompt, because a half-edited prompt with a Ready row waiting will happily produce a broken storyboard on schedule.

The AI prompt that decides whether the video is usable

Everything downstream depends on this step. Pictory will faithfully turn whatever you give it into scenes, so if you feed it 2,000 words you get a twelve-minute video nobody watches. The prompt has to do three jobs: compress, structure one line per scene, and keep the concrete nouns that give Pictory's stock search something to match. Here is a prompt that does all three, with the article text mapped in after the last line:

You are writing a voiceover script for a 60 to 90 second vertical video
summarizing the article below.

Rules:
- 130 to 170 words total.
- 6 to 9 lines. Each line is one spoken sentence and becomes one scene.
- Line 1 is a hook stating the single most surprising or useful fact.
- Keep the concrete verdict, price, or number from the article.
- Use concrete nouns (laptop, microphone, dashboard, city street) rather
  than abstract ones, so stock footage can match each line.
- Spell out product names. No abbreviations, no emojis, no markdown,
  no bullet symbols, no quotation marks.
- Do not use dashes of any kind.
- The last line tells the viewer the full review is on AIToolBlaze.
- Ignore navigation, footer, comments, and anything that is not the
  article body.

Output only the script lines, one per line, nothing else.

Article:

The concrete nouns rule is the one most people skip, and it is the one that most affects the footage. A line like "the context window is large enough for long documents" gives Pictory nothing to search for, and you get a generic office shot. "It reads a 300-page contract without losing track" gets you footage of documents and a desk. Same information, better scene.

What to expect: time saved and output quality

The figures below are realistic estimates based on typical usage: Pictory's documented render behavior, the module count in the scenarios above, and the community feedback on Pictory's output further down. They are not measurements from a specific batch, and your numbers will move with post length, topic, and how busy Pictory's render queue is on the day.

At 20 videos a month, that is roughly 10 to 15 hours of hands-on work replaced by about an hour and a half of review. The wall-clock figure is worth understanding too. Make's share is seconds. Almost all of it is Pictory building the storyboard and then rendering, which matches the slow-render complaints in the community feedback below. The automation does not make Pictory faster. It makes Pictory's slowness irrelevant, because nobody is sitting there watching it.

What "needs no edits" means here: a 9:16 video between 60 and 90 seconds, an ElevenLabs voice reading a script you would have been happy to write yourself, burned-in captions with no spelling errors, brand colors and logo applied, and stock footage that does not actively contradict the narration. Pictory's own community consistently reports blog posts turning into usable video with little adjustment, and the prompt above is what keeps the automated version on that side of the line.

The failures are predictable, which is the important part:

• Abstract topics. A line about context windows or token limits gives Pictory's stock search nothing concrete, and you get generic office footage. Expect these to need one scene swapped in the Pictory editor, which takes under a minute each.
• Comparison posts. A summary that keeps both tools' features and drops the verdict produces 80 seconds of description with no conclusion. The "keep the concrete verdict" line in the prompt exists for exactly this.
• Very long posts. The prompt's word cap handles it. Without that cap, a 2,400-word review becomes a ten-minute video.

Anything the prompt handles well passes. Anything it handles badly fails the same way every time, which is what makes it fixable in the prompt rather than in the editor.

What it costs to run per month

The comparison that makes Level 2 worth it: a freelance editor producing 20 short vertical videos a month at even $20 each is $400, and the turnaround is days rather than minutes. At $80 to $110, the fully automatic version pays for itself on the first four videos, and that is before counting the 10 or more hours a month of your own time it hands back at a weekly-plus cadence.

If you publish once a month, none of that math works and Level 1 on a standard plan is the right call. The BLAZE code brings Professional Annual to $336 for the first year, which is $28 a month for a tool you will use for a lot more than this workflow.

Mistakes that trip people up

• Feeding the whole article to Pictory. Skip the AI step and map the article text straight into the storyboard, and a 2,400-word review becomes a ten-minute video. Always compress first.
• Not splitting scenes on new line. With that toggle off, the entire script becomes one scene with one stock clip behind 80 seconds of narration. Turn it on.
• Leaving aspect ratio on the default. The default is 16:9, which is the wrong shape for Shorts, and you will not notice until the first batch has rendered. Set it explicitly in the module.
• Updating the sheet at the end of the run instead of the start. If a second scheduled run starts before the first finishes, it picks up the same Ready row and creates a duplicate storyboard. Write Storyboarding to the row the moment you have a job ID.
• Skipping the brand kit. Without it, the first batch comes out in Pictory's default look and has to be re-rendered, which costs quota twice.
• Polling too often. Search Rows every 15 minutes burns close to 3,000 operations a month checking an empty sheet. Every six hours is plenty.

Who should build this, and who should not

Build it if you are:

• A blogger or marketer publishing weekly or more, with an archive of 30-plus posts that could each be a short
• Running a faceless YouTube Shorts, Reels, or TikTok channel from written content
• An agency or freelancer producing video for several client blogs, where the per-video math compounds fast
• Already comfortable in Make, or willing to spend a weekend getting there

Skip it if you are:

• Publishing once a month. Do it by hand in Pictory's app on a standard plan and keep the API money.
• Expecting original or cinematic footage. Pictory cannot invent a shot. Kling, Veo, and Runway can, and the best AI video generator roundup covers which one for which job.
• Needing product screenshots or screen recordings inside the video. The API workflow uses stock only; those still need the Pictory editor or a different tool.
• Not willing to learn Make's canvas. The routers and watch modules take a couple of days to click, and this workflow is not a good first scenario.

What the community is saying

Paraphrased community sentiment, not our testing:

• Pictory holds 4.8/5 across 163 verified reviews on Capterra, with ease of use the most consistent praise. The recurring complaints are fiddly voiceover editing, clumsy scene reordering, and slow renders. The automation sidesteps the first two entirely for the videos that pass review, and makes the third one something you no longer wait on.
• Make's Pictory integration page and app documentation list the storyboard, render, and watch modules used above, and Pictory's own post on the Make integration frames it around e-commerce and personalized customer videos. Blog-to-video is not their showcase example, which is a large part of why this post exists.
• On Make itself, the verdict in the Make.com review holds: the visual canvas is genuinely better than Zapier for a three-scenario build like this one, and the learning curve is real. Budget the weekend.

Bottom Line

If you publish written content weekly and want a short video from every post, connecting Make.com to Pictory's API turns a 30 to 45 minute manual job into about five minutes of review per video, and for concrete, informational posts most videos should need no edits once the prompt is tuned. The fully automatic version costs $80 to $110 a month, which is cheaper than four freelance shorts, and the semi-automatic version runs on a standard Pictory plan at $28 a month for your first year with code BLAZE (expires October 15, 2026). Build it if you have an archive and a publishing habit. Skip it if you post once a month or need footage that does not exist yet.

FAQ: repurposing blog posts into videos automatically

Can you automatically turn blog posts into videos?

Yes, and the reliable way to do it in 2026 is an automation platform in front of a blog-to-video tool. Make.com watches for a new post, an AI step condenses it into a short script, and Pictory's API builds a storyboard, adds an ElevenLabs voiceover and captions, and renders the video. Expect 10 to 20 minutes of wall-clock time and about five minutes of human attention per video once the workflow is running.

Do I need the Pictory API plan, or does the regular Pictory subscription work with Make.com?

For the fully automatic version you need Pictory API access, because Make's Pictory module authenticates with a client ID and client secret from the API Subscription page. As of September 2026 that is a separate subscription from the Starter, Professional, and Team app plans, priced at $79 a month billed annually or $99 monthly for 600 video minutes. A standard app plan is enough for the semi-automatic version, where Make prepares the script and you paste it into Pictory yourself.

How much does it cost to automate blog-to-video with Pictory and Make.com?

Roughly $80 to $110 a month for the fully automatic version: Pictory API Self-Serve at $79 or $99, Make on the free plan or Core at $9, and under a dollar of AI summarization. The semi-automatic version on Pictory Professional Annual is about $28 to $45 a month, or $336 for your first year with code BLAZE before October 15, 2026. Both are cheaper than outsourcing more than a handful of shorts.

How long does it take Pictory to render a video through the API?

Expect 10 to 20 minutes from the row being picked up to the MP4 landing in Google Drive, and nearly all of that is Pictory building the storyboard and then rendering. Make's part takes seconds. Because the render is asynchronous and Make's watch modules pick it up when it finishes, nobody has to sit and wait for it.

Can I do this with Zapier instead of Make.com?

Yes. Pictory has a Zapier integration with storyboard and render actions, so the same shape works there. Make is the better fit for this build because per-operation pricing is much cheaper for a multi-step workflow, the visual canvas makes the three-scenario structure easy to see, and the free plan is enough to run it. If you are already paying for Zapier and know it well, the wiring translates directly.

Does this work with WordPress?

Yes, and it is simpler. Replace the Google Sheets trigger with Make's WordPress > Watch Posts module filtered to published posts, and every new post flows straight through. The trade-off is losing the review gate, since every post becomes a video whether or not it should. Keep a sheet as a log even with a WordPress trigger, so failed or rejected videos are visible somewhere.

What video format and length does the workflow produce?

Whatever you set in the storyboard module. This guide uses 9:16 for Shorts, Reels, and TikTok, and the 130 to 170 word script produces videos between 60 and 90 seconds with an ElevenLabs voice and burned-in captions. Switch the aspect ratio to 16:9 for YouTube proper or blog embeds. The length is controlled by the prompt's word count, not by Pictory.

Is the output good enough to post on YouTube Shorts and TikTok?

For informational content, yes. Once the prompt is tuned, most videos on concrete topics should go out without edits, and the ones that need a fix usually need a single scene swapped in the Pictory editor. The ceiling is stock footage: it looks clean and on-brand but never distinctive, and it fails on abstract topics that give Pictory nothing to match. If your channel depends on original footage or your own face, this workflow is not it. The Pictory vs InVideo comparison covers the closest alternative in the same lane.

Can I use n8n instead of Make.com?

n8n has no native Pictory node as of September 2026, so you would use HTTP Request nodes against Pictory's REST API directly: authenticate, post the storyboard, poll the job endpoint, then render. It is more work than Make's native module and you have to handle the polling yourself, but if you already self-host n8n and want zero platform cost, it is doable.

Related reviews

• AI Video Tools topic hub: every video generator, script-to-video tool and comparison review in one place.
• Pictory review 2026: what Pictory is, what it is not, and the full annual pricing math.
• Make.com review 2026: the automation platform behind this workflow, including the learning curve and the operations gotchas.
• Best AI video generator 2026: the generative tools, if you need original footage rather than assembled stock.
• ElevenLabs review 2026: the voice engine reading your scripts inside Pictory.
• Best AI tools for YouTubers: the wider creator stack that pairs with this workflow.

Got a question about this workflow, or a scenario that is not going green? Get in touch: reader questions shape the next round of guides.