How to Turn Long Videos into Short Clips with n8n

One good podcast episode or webinar holds five or six clips worth posting. The problem isn't finding them, it's the grind: watch the whole thing, scrub for the good parts, note timestamps, cut, caption, schedule, and remember which ones already went out. An n8n video to clips workflow does the scrubbing for you. Transcribe once, let an LLM mark the strong moments by timestamp, cut those ranges, and queue them with captions.

The templates that rank for this all lean on one paid relay, an Upload-Post, a Swiftia, a FastPix, to both render and publish, with a black-box "find the viral moments" step you can't tune. The pipeline below keeps the selection logic in your own n8n instance so you can swap the render service and still own the brain of it.

What you can automate from one long video

A single source video becomes a queue of short-form assets:

• Three to six vertical clips from a long episode
• A caption and hook generated per clip
• Platform-specific titles for Shorts, Reels, and TikTok
• A thumbnail frame pulled from each clip's start
• A scheduled posting cadence across several days
• A Sheets log of every clip, its source, and its post status

Cut the clips you'll actually post. Generating twelve when you publish three a week just fills a folder nobody opens.

The video-to-clips pipeline

Source video → Transcribe (word timestamps) → LLM picks segments
       → Parse ranges → Cut clips → Caption → Review gate → Queue + Log

The video gets transcribed with timestamps. An LLM reads the transcript and returns the best start and end times. A parse step turns those into clean numbers. The cut step trims each range. Captions get written, a human approves, and the queue takes over.

1. Transcribe with word-level timestamps

This is the foundation, and it's where most builds quietly fail. A plain transcript has no time data, so the LLM guesses and the cuts land wrong. Use a model that returns word-level timestamps, Whisper via the OpenAI node, or AssemblyAI. Now every word carries a time, and clip boundaries can be exact.

2. Let the LLM mark the moments

Pass the timestamped transcript to an OpenAI node and ask for the strongest self-contained segments: each with a start second, an end second, and a one-line reason. Cap the count so it returns four, not forty. The reason field matters, it's how a human later sees why a clip was picked without rewatching.

3. Cut the ranges

The actual trim needs something that handles video by timestamp. On a self-hosted n8n instance, an Execute Command node calling FFmpeg does it for free, FFmpeg cuts cleanly on keyframes and handles the vertical crop. If you'd rather not manage FFmpeg, an HTTP Request to a clipping API works, and because selection already happened upstream, the render service is a swappable detail, not the whole product.

4. Caption each clip

For every cut range, run an OpenAI call that writes a hook and caption from that clip's transcript slice. Per-clip captions beat one caption for all, the clip about pricing and the clip about hiring need different hooks. Parse each response before it reaches the post step.

5. Gate, queue, and log

Don't auto-publish raw AI cuts. Email the clips to an approver, or drop them in a review folder, and only the approved branch queues. Append a row per clip: source video, start, end, caption, status, scheduled time. That log is your dedupe guard so a re-run never re-posts a clip that already shipped.

Implementation patterns worth copying

Pattern: split selection from rendering

Keep the transcript-and-select half in n8n and treat the cut step as a plug. Today it's FFmpeg; tomorrow it's a hosted API. Because the LLM already returned timestamps, swapping the renderer is a one-node change, not a rebuild. The Content Scheduler & Distributor uses the same separation, the queue and per-channel formatting stay stable while the output target changes.

Pattern: schedule across days, not all at once

Posting six clips in an hour buries five of them. Spread them: append each clip with a scheduled_at value a day apart, and let a Schedule trigger publish the next due one each morning. A Schedule trigger that fires while the previous execution is still running will silently drop the run, so give it breathing room with a sensible interval.

Pattern: keep the source transcript

Store the full timestamped transcript in a Sheet alongside the clips. When you want more clips from the same episode next month, you skip the transcription cost entirely and just re-run the selection step. It's also your safety net when a render fails halfway: the timestamps are already saved, so you re-cut without paying for transcription twice.

Watch the running cost while you're at it. Whisper bills per minute of audio and the render service bills per clip, so a daily long-video pipeline adds up faster than the per-run number suggests. In practice, teams cap the clip count per source and batch the renders overnight, when a slower, cheaper tier is fine. The transcript cache is what makes that batching free to retry.

n8n nodes you'll use most

Getting started

1. Pick a source: a podcast feed, a YouTube URL, or an uploaded file.
2. Transcribe with a model that returns word-level timestamps.
3. Prompt an LLM for four to six segments as numeric start and end seconds.
4. Add a Code node to parse that JSON, with an error branch for bad output.
5. Cut each range with FFmpeg or a clipping API.
6. Generate a per-clip caption and route everything through a review gate.
7. Queue approved clips a day apart and log each with its post status.

For the adjacent jobs, turn a podcast into a blog post with n8n reuses the same transcription step for written content, and build an n8n content repurposing workflow shows the fan-out that turns one clip's transcript into captions for several platforms. The Social Media Scheduler & Designer covers the graphic side when a clip needs a cover card.