Auto-Publish 30 YouTube Shorts Per Week from One Long Video

One 30-minute video contains enough material for 30+ YouTube Shorts. Most creators leave that content on the table because splitting, captioning, and publishing 30 clips manually takes hours. With n8n and FFmpeg Micro, you can automate the entire pipeline: split the long video, add captions to each clip, and schedule them for auto-publish.

This is the same pattern used by creator-economy automators who post 4-5 Shorts per day without touching an editor after the initial recording.

The Pipeline at a Glance

The workflow does three things:

The whole thing runs in n8n, triggered by dropping a video URL into a webhook or a Google Drive folder.

Step 1: Split the Long Video into Clips

First, you need timestamps. If you've already scripted your video, you know where each topic starts and ends. If not, use FFmpeg Micro's transcription endpoint to generate an SRT file and identify natural break points.

Generate the transcript:

curl -X POST https://api.ffmpeg-micro.com/v1/transcribe \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "media_url": "https://storage.googleapis.com/your-bucket/long-video.mp4"
  }'

Poll the transcribe job until it completes, then download the SRT. Each subtitle block gives you a natural cut point.

Trim each clip with the API:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.googleapis.com/your-bucket/long-video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-ss", "argument": "00:02:15"},
      {"option": "-t", "argument": "45"},
      {"option": "-vf", "argument": "crop=ih*9/16:ih"},
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-preset", "argument": "fast"}
    ]
  }'

This extracts 45 seconds starting at 2:15, crops to 9:16 vertical format, and re-encodes with H.264. One API call per clip.

Step 2: Add Captions to Each Clip

YouTube Shorts with burned-in captions get significantly higher watch time. After trimming each clip, run transcription on the individual clip, then burn the subtitles back in.

Transcribe the clip:

curl -X POST https://api.ffmpeg-micro.com/v1/transcribe \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "media_url": "gs://your-output-bucket/clip-01.mp4"
  }'

Once the SRT is ready, download it and use FFmpeg Micro to burn the subtitles into the video. The text overlay virtual option (@text-overlay) can handle word-by-word caption styling if you want the TikTok-style animated caption look.

Step 3: The n8n Workflow

In n8n, this becomes a six-node workflow:

The Code node is where the logic lives. Parse the SRT into segments of 30-60 seconds, group by topic, and generate a trim command for each.

const totalDuration = $input.first().json.duration;
const CLIP_DURATION = 45;
const segments = [];

for (let i = 0; i < Math.floor(totalDuration / CLIP_DURATION); i++) {
  const startSeconds = i * CLIP_DURATION;
  const hours = String(Math.floor(startSeconds / 3600)).padStart(2, '0');
  const mins = String(Math.floor((startSeconds % 3600) / 60)).padStart(2, '0');
  const secs = String(startSeconds % 60).padStart(2, '0');

  segments.push({
    clipNumber: i + 1,
    startTime: `${hours}:${mins}:${secs}`,
    duration: CLIP_DURATION
  });
}

return segments.map(s => ({ json: s }));

Each segment feeds into the Loop node, which makes the FFmpeg Micro API call for that specific clip.

Scheduling the Uploads

Don't publish all 30 Shorts at once. Spread them across the week using YouTube's scheduled publish feature.

In the n8n YouTube upload node, set the publishAt field to a future timestamp. A good cadence for Shorts is 4-5 per day, spaced 3-4 hours apart:

That's 30 Shorts across 7 days from a single recording session.

Cost Breakdown

For a 30-minute source video producing 30 clips:

One long video per month stays within the free 100-minute quota. If you're doing this weekly, the Pro plan at $19/month covers 500 minutes. That's enough for about 5 source videos per month.

Common Pitfalls

Vertical crops cut off important content. If your source video is landscape with text or graphics near the edges, crop=ih*9/16:ih centers the crop. For talking-head content this works great. For screen recordings, you may need to shift the crop window with crop=ih*9/16:ih:in_w/4:0.

SRT timestamps don't reset after trimming. When you transcribe a clip that was trimmed from a longer video, the Whisper timestamps start at 00:00:00, which is what you want. But if you're reusing the SRT from the original long video, you need to offset the timestamps. Transcribe each clip individually to avoid this.

YouTube rejects Shorts over 60 seconds. Keep clips under 60 seconds or YouTube treats them as regular videos. The 45-second default in this guide leaves buffer for intro and outro frames.

FAQ

How many YouTube Shorts can I make from a 30-minute video?
A 30-minute video typically produces 30-40 Shorts at 45-60 seconds each. The exact number depends on your content. Talking-head videos with clear topic transitions split cleanly. Screen recordings may need manual timestamp selection.

Do I need to install FFmpeg to use this workflow?
No. FFmpeg Micro is a cloud API that handles video processing via HTTP requests. You send the API call from n8n (or Make.com, or any HTTP client), and FFmpeg Micro does the splitting, cropping, and captioning on its servers.

What does this cost per month?
One 30-minute source video per month fits in FFmpeg Micro's free tier (100 min/mo). For weekly production, the Pro plan at $19/month covers about 5 source videos.

Can I use Make.com instead of n8n?
Yes. FFmpeg Micro has an official Make.com app in the app store. The workflow structure is identical: trigger, transcribe, loop, trim, caption, upload. Make.com's iterator module handles the looping.

*Last verified: June 2026. All API examples tested against the FFmpeg Micro production API.*