How I Cut AI Video Ad Production Time by 50% Using n8n + Sora + Runway

Yes, you can cut AI video ad production time by roughly half, and I did it solo for one client without hiring an editor or paying agency margins. The win does not come from one magic model. It comes from treating creative like an assembly line: brief to script, script to video, render and caption, then publish. Last quarter that line pushed 30+ ad variants per week into live campaigns. Here is the exact build, the cost of each piece, and the honest list of what breaks.

Quick answer

• The pipeline has four stages, all orchestrated in self-hosted n8n: script generation, model-matched video generation, FFmpeg render, and multi-platform publish.
• Model choice is per shot type: HeyGen for talking heads, Runway for b-roll, Sora for narrative motion. Cost per clip runs from about $0.10 to $2.00, so cheap models carry the volume.
• The documented result on the real engagement was roughly 50% faster production end to end.
• Only build this past about 15 variants per week. Below that, a freelance editor wins on cost and hassle.

What problem does this actually solve?

A performance account burns through creative. To hold off fatigue, a Meta campaign wants 5-10 fresh creatives per week. At around $300 per video from a freelance editor, that full cadence runs $1,500 to $3,000 per week, roughly $6,000 to $12,000 per month.

On a $10K monthly ad budget the math is brutal: producing creative properly would cost as much as the media it is meant to feed. So most accounts under-produce, the algorithm starves, and results slide. That is the squeeze this pipeline is built to break.

How the pipeline works (4 stages)

Stage 1: Brief to script (Claude / GPT-5)

Every campaign starts with a brief: audience, hook angles, CTAs, visual references. I feed it into an n8n workflow that runs the brief through a language model to generate 3 script variants per angle.

I use exactly three angles, because those are the three that consistently earn clicks and they fail for different reasons. Pain-point hooks land with cold audiences but fatigue fast. Social-proof hooks convert warm traffic but flop cold. Demo-led hooks carry the product but need a strong first second. Running all three at once means the auction, not my guess, decides which one this audience wants.

// Inside an n8n Code node
const angles = ["pain-point", "social-proof", "demo-led"];
const briefs = angles.map((angle) => ({
  angle,
  audience: $json.audience,
  product: $json.product,
  cta: $json.cta,
}));
return briefs;

Output: 9 scripts (3 angles times 3 variants). Each script is 90 to 120 words, structured as hook, problem, solution, CTA, with an explicit shot type tagged per line so the next stage knows which model to call. This is the one genuinely agentic step in the whole system, where a model makes a judgment call instead of following a fixed rule. If you want to understand where that line sits, I wrote a separate piece on AI agents versus plain automation.

Stage 2: Script to video (Sora / Runway / HeyGen)

Different models for different jobs, chosen by the shot type tagged in Stage 1. The trade-off is quality and motion versus cost per clip.

n8n calls each API in parallel based on the tag, so the nine scripts do not queue behind each other. Costs above are rough and move every quarter as the vendors reprice, so treat them as ratios, not quotes. The ratio is the point: a talking-head clip is more than ten times cheaper than a Sora shot, and for most direct-response ads a clean presenter reading a sharp hook outperforms a cinematic b-roll clip anyway.

Stage 3: Render and caption (FFmpeg + Whisper)

Raw clips are not ad-ready. Each one needs four things: a 2-second brand intro, burned-in captions (the vast majority of feed views happen with the sound off), a CTA card at the end, and three aspect-ratio cuts (9:16, 1:1, 16:9). All of it runs headless with FFmpeg and Whisper on a VPS, driven by n8n.

Captions come from Whisper transcribing the clip's own audio into an SRT file, which FFmpeg then burns in. The brand card and CTA card are pre-rendered clips concatenated on. Here is the core of what runs per variant:

# 1. Transcribe the clip's audio to SRT captions
whisper raw_clip.mp4 --model small --output_format srt --output_dir ./caps
 
# 2. Burn captions in, then concat brand intro + clip + CTA card
ffmpeg -i raw_clip.mp4 \
  -vf "subtitles=./caps/raw_clip.srt:force_style='Fontsize=18,Outline=2'" \
  -c:v libx264 -preset veryfast captioned.mp4
 
printf "file 'brand_intro.mp4'\nfile 'captioned.mp4'\nfile 'cta_card.mp4'\n" > list.txt
ffmpeg -f concat -safe 0 -i list.txt -c copy assembled.mp4
 
# 3. Cut the vertical variant natively (repeat for 1:1 and 16:9)
ffmpeg -i assembled.mp4 -vf "scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920" \
  -c:v libx264 -preset veryfast final_9x16.mp4

Each variant takes about 45 seconds to render. Running four FFmpeg processes in parallel and supervising them with PM2, all 9 scripts across 3 aspect ratios (27 final videos) come out in roughly 7 minutes.

Stage 4: Publish (Meta + TikTok + YouTube APIs)

The final n8n step ships everything and writes down what it shipped:

• Upload each cut to Meta as new ad sets inside the live campaign, via the Marketing API.
• Push the 9:16 cut to TikTok Ad Manager as a new Smart+ creative.
• Drop the same vertical on YouTube as a Short with the caption reused as the title.
• Log every variant, its angle, model, cost, and platform IDs to a Google Sheet.

That last bullet matters more than it looks. Without a log you cannot tie a winning ad ID back to its angle and script, so you can't learn anything from the volume. The log is the difference between spraying variants and running a system. A trimmed publish-and-log payload looks like this:

{
  "variant_id": "q2-pain-point-v1-9x16",
  "angle": "pain-point",
  "model": "heygen",
  "cost_usd": 0.12,
  "aspect": "9:16",
  "meta_adset_id": "1203847",
  "tiktok_creative_id": "77420193",
  "youtube_video_id": "kR3nP",
  "status": "live"
}

All 27 variants go live in under 10 minutes.

Did it actually save time?

Yes. On the real engagement the production time dropped by roughly 50% end to end, and that is the figure documented in the case study. The mechanism behind the number is boring but dependable. When an account can absorb 30+ variants a week instead of a handful, the ad platform has far more shots to test, so it finds the winning creative faster and I stop hand-editing videos one at a time. More volume is not vanity here, it is how the auction learns.

What breaks, and what I would do differently

What worked

• Parallel rendering on a VPS. Do not render serially. Four FFmpeg processes supervised by PM2 turned a 30-minute job into 7 minutes.
• Aspect ratio at render time, not after. Do not make 16:9 and crop down. Cut each ratio from the assembled clip so the subject stays framed. Sora and HeyGen both output vertical natively, so start there when you can.
• Bilingual presenters from day one. HeyGen has Italian, German, and Spanish voices and faces. Generate localized variants natively instead of translating captions after the fact.

What broke

• Skipping the script stage. The first version went brief straight to video. Quality was all over the place because the model had no structure to hang the shot on. Adding an explicit hook, problem, solution, CTA script fixed about 80% of the bad outputs.
• Whisper mishearing product names. Auto-captions confidently misspelled brand and product names on nearly every clip. The fix was a find-and-replace pass on the SRT against a per-client glossary before FFmpeg burns it in. Cheap step, saved every render from an embarrassing typo on screen.
• Silent API failures at publish. Early on, a rejected Meta upload would fail quietly and I would not notice until the ad set was empty. Now every publish node has an error branch that pings me, so a broken run shows up right away instead of slipping past me.
• Running on a Mac mini. I first hosted FFmpeg on a Mac mini in my office. It worked, but disk I/O was the bottleneck. Moving to a Hetzner CPX21 at about $8 per month cut rendering time by 60%.

Should you build this?

Honest answer: it depends entirely on your weekly variant volume. Below the threshold, this pipeline is a hobby that costs you money.

• Under 5 variants per week: Do not build it. Hire a freelance editor on Upwork at around $150 per video and spend your time elsewhere.
• 5 to 15 variants per week: Build a manual version with Descript and HeyGen. You get most of the speed with none of the plumbing. No automation layer needed yet.
• 15+ variants per week: Build the full pipeline. This is where manual production genuinely can't keep up and payback lands inside 2 to 3 weeks.

What this costs to build

If you want to run it on your own product, the recurring tooling is modest:

The real cost is build time: roughly 2 to 3 weeks for someone fluent in n8n and FFmpeg. Do not build all four stages at once. Build it in this order:

1. Wire up stages 2 and 3 first (generate and render), and judge the output quality with your own eyes before you trust it with a live account.
2. Add stage 1, the script step, once the middle reliably produces clips worth publishing.
3. Add stage 4, the publish-and-log step, last, so you are only automating distribution after the creative is good.
4. Only then add error branches and alerting on every external call, because that is what turns a demo into something you can leave running.

If a month of plumbing is not how you want to spend your time, hand that part off. The generation, render, and publish orchestration is a standard n8n automation engagement, and the script step is a small AI agents build inside it. Show me the brief format you already use and your weekly variant count, and we can map which stages are worth automating and which ones you are better off keeping manual.