Reformatting isn't original. Repurpose long-form video to Shorts

If you run a clip pipeline in n8n or Make, last week's YouTube announcement landed as a question you can't answer: is my workflow the thing that just got demoted? Part of it is. The cutting and rendering survive. The one-template-over-a-batch pattern is exactly what YouTube named.

Quick answer: To repurpose long form video to shorts that YouTube still counts as original, each clip has to differ in substance, not just in file. That means distinct in and out points per segment, a crop-based 9:16 recomposition instead of a letterbox pad, captions generated from that segment's own audio, and a hook written for that clip rather than one template string looped over the batch. The mechanical part is three FFmpeg passes per clip (-ss/-t cut, crop+scale, subtitles burn-in), which you can run as one API call each on FFmpeg Micro with no FFmpeg installed and no render servers. Picking the segments and writing the hooks is the part you keep doing yourself.

What YouTube actually said on October 1

YouTube's Creator Liaison Rene Ritchie announced on Creator Insider that the Shorts recommendation system now "further prioritize[s] original content and reduce[s] the reach of content re-uploaded from other creators without adding anything of your own." The line that matters to anyone running a pipeline is what does not count as adding your own: "VO descriptions of what's happening on screen, minor technical edits, or template-based bulk changes," per Search Engine Journal's account. What does count: original commentary, analysis, distinctive editing, storytelling.

Three things the coverage is clear about. First, YouTube did not address creators clipping their own long-form videos; the announcement aims at re-uploads from other creators, so the self-clipping case is undefined. Second, this is a recommendations change, not a monetization change; monetization still runs under the existing reused content policy, which applies at the channel level. Third, there is no start date, no re-evaluation window, no status indicator and no email. A channel can lose Shorts distribution without being told, and 9to5Google's write-up is the closest thing to a notification most builders get.

Nobody can tell you your own clips are safe, so stop shipping output that pattern-matches the thing being demoted.

Reformatting is not transformation

Reformatting changes the container. Transformation changes what the viewer sees and hears. A pad keeps every source pixel and adds black or blurred bars above and below, the cheapest "minor technical edit" there is: the frame is identical, just smaller. A crop recomposes the shot. It throws away two thirds of the width and decides what the subject of a vertical frame is.

Same with captions. Burning the full-video SRT across 30 clips is a format change applied in bulk. A transcript per segment produces a different caption track per clip, because the audio under each clip differs. It's also a correctness fix most pipelines get wrong: burned subtitles ignore -itsoffset, because the subtitles filter reads the file off disk rather than from the timed stream. Cut at 14:22, burn the whole-video SRT, and your cues are 862 seconds out of sync.

None of this is about evading a classifier. If you can't describe what makes clip 7 different from clip 3 in one sentence, neither can a recommendation system.

The pipeline: upload once, diverge four times

The working pipeline is four decisions per clip on top of one upload. Push the source video to FFmpeg Micro once, get a file reference, then submit one job per segment against that reference. Billing is on the duration of the video processed, metered per second, so cutting a 38-second segment out of a 52-minute recording bills 38 seconds, not the hour.

1. Pick segments that stand on their own

Segment selection is editorial work, and it's now the expensive part of the pipeline in the only sense that matters: it's the part the algorithm pays for. A segment qualifies if it opens on a claim, resolves inside 60 seconds, and makes sense to someone who has never seen the source video. A 52-minute podcast rarely has 30 of those. It usually has six to nine.

In practice that's a Google Sheet with one row per clip and five columns: start, duration, crop_x, hook, status. An LLM drafts the candidate rows from a word-level transcript and a human approves them, the same approval gate we built into the viral shorts automation, moved earlier.

2. Cut distinct in and out points

Each segment gets its own -ss and -t, and -ss goes before -i so FFmpeg seeks instead of decoding 14 minutes it will discard:

ffmpeg -ss 00:14:22 -t 00:00:38 -i source.mp4 \
  -c:v libx264 -preset veryfast -crf 20 -c:a aac clip-03.mp4

The API equivalent is one POST against the file you already uploaded:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer $FFMPEG_MICRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file_id": "file_8f2c41",
    "output_format": "mp4",
    "ffmpeg_args": "-ss 00:14:22 -t 00:00:38 -c:v libx264 -crf 20 -c:a aac"
  }'

In n8n: Google Sheets node reads the approved rows, Loop Over Items splits them, an HTTP Request node submits the job, a Wait node plus a status GET polls it, and an HTTP Request downloads the result. Check the field names in the docs before you wire it; the shape is submit, poll, download. If your instance lost Execute Command in n8n 2.0, or faces the Docker-only requirement in v3, that's another reason the video step belongs behind HTTP rather than in your image.

3. Reframe with a crop, not a pad

Vertical conversion is where "minor technical edit" is easiest to avoid, because a real crop needs a per-clip decision. For 1920x1080 source, 9:16 at full height is 608 pixels wide, and the crop_x column is where the subject lives in that particular segment:

-vf "crop=608:1080:980:0,scale=1080:1920,setsar=1"

Clip 3 has the guest on the right, so x=980. Clip 7 is a slide, so it gets x=656 and a tighter crop on the chart. The lazy version, scale=1080:-2,pad=1080:1920:0:(oh-ih)/2, is one string that works for all 30 clips, which is the problem. Same tradeoff for ad formats in one product video, four cuts.

4. Caption from that segment's own transcript

Each clip's captions should come from each clip's audio. Transcribe the finished segment, then burn the SRT it returns:

curl -X POST https://api.ffmpeg-micro.com/v1/transcribe \
  -H "Authorization: Bearer $FFMPEG_MICRO_API_KEY" \
  -d '{"file_id": "file_clip03"}'

The signed SRT URL drops into the next transcode's filter chain as subtitles='<url>', with timestamps that start at zero because the clip starts at zero. If you send whole recordings to a transcription step, send a URL rather than the binary; n8n chokes on large file bodies long before the audio is the problem.

5. One hook per clip, written by a person

The hook is a sentence, not a field. One template value swapped across a batch, the same "WATCH THIS" over clip after clip, is the literal definition of a template-based bulk change. Write them in the same sheet row as the segment, render them with drawtext or the @text-overlay option, and vary position and length because the clips vary. Testing openings on one segment is a different job: three hooks from one encode covers it.

Template pipeline vs per-clip pipeline

The difference between the two pipelines is small in code and large in output. Both run in n8n and call the same endpoints. Only one produces files that are genuinely different from each other.

Eight clips averaging 38 seconds is 304 seconds of input per pass. Cut plus caption burn is roughly 61 tokens on FFmpeg Micro, against the 200 tokens a free account starts with, no card to enter. Failed jobs are never billed, and there's no rounding up to the minute, which matters when your unit of work is a 23-second segment.

Common pitfalls

Most of what breaks in this pipeline breaks quietly, and the clip still uploads.

When this is the wrong approach

A per-clip pipeline is the wrong tool when the output genuinely should be identical across items: platform-spec variants of one finished ad, numbered episodes with consistent branding, a watermark pass over a back catalog. That's Shorts series work, and consistency is the point there, not a liability.

It's also wrong if your channel's model is republishing other people's clips. No amount of crop math makes that original under the October 1 wording, and the fix is a commentary track, not a filter chain. If you want a drag-and-drop editor with a timeline, an API isn't that; FFmpeg Micro renders what you specify, which is useful because it's deterministic at volume. The judgment stays with you, the render goes to the API, which is how the content repurposing workflows are built.

FAQ

Does clipping my own long-form video count as unoriginal on YouTube?

YouTube did not say. The October 1 announcement addresses content re-uploaded from other creators, and reporting on it notes that the self-clipping case was never discussed. The safer read is that the stated criteria apply to output regardless of source, so clips differing only by template value are exposed either way.

How do I know if my channel was already throttled?

Nothing in YouTube Studio reports Shorts throttling. The change shipped with no start date, no status dashboard, no email and no strike, so a channel can lose distribution with nothing to look at but its own analytics. Ritchie did say the system reassesses reach if a channel moves toward original work, without giving a timeline.

Do AI-generated hooks count as my own commentary?

An AI-written hook sits in a gray area, and what distinguishes it is whether it's one string reused or a different claim per clip. A model drafting eight hooks from eight transcripts is doing editorial work a person then approves. A model filling one template with a variable is a template-based bulk change with extra steps.

Can I still batch Shorts at all?

Batching is still fine, and the render is the part to automate. What changed is the input: a queue of eight approved segments with per-clip crop offsets and hooks produces eight distinct videos, while 30 interval cuts with one caption style produce 30 reformats.

The render side of this is eight API calls and no FFmpeg install, and a free account comes with 200 tokens, about 33 minutes of video, without a credit card. Sign up free and cut the first segment from a recording you already have.