YouTube Shorts series automation: numbered episodes, thumbnails

Shorts series showed up in your account this week, and the setup screen wants something Shorts have never needed before: a custom thumbnail for every episode. Turning one long video into an episode run means ten cuts, ten reframes, ten burned-in episode numbers, and ten stills pulled at timestamps you choose.

Quick answer: YouTube Shorts series automation is four operations per episode: cut the source at your chosen timestamps, reframe to 1080x1920, burn a fixed "EP. N" bar, and extract one frame as that episode's thumbnail. Locally that's one ffmpeg -ss ... -t ... -vf "scale,crop,drawbox,drawtext" encode plus a second -frames:v 1 pass per episode, which means a local encoder, installed fonts, and ten long jobs to sit on. To skip the encoder hosting and the timeout babysitting, send each segment to FFmpeg Micro as one POST /v1/transcodes call and let an n8n loop collect the outputs.

Your split points are also your publish schedule

Cut first, package later is the usual order, and for standalone clips it's fine. For a series it breaks, because YouTube assigns episode numbers by publish date, and the number your viewer sees in the feed is the one you burned into the frame.

YouTube's own help page on creating shows spells out the rules: a Shorts series playlist may contain only Shorts, the videos must be portrait or square with a maximum duration of 180 seconds, episode numbers are auto-assigned by publish date and can be edited afterward, and you can upload a unique custom thumbnail for each individual Short. Series artwork has to be at least 1080x1920, under 10 MB, JPG or PNG.

The split list, the burned number, and the upload order are one decision made before the first upload. Publish segment three fifth and YouTube calls it episode five while your frame says EP. 3.

The feature rolled out on 2026-09-23 at Made On YouTube to Partner Program creators across web, mobile and TV, with seasons, episodes, per-episode thumbnails and sequential playback (YouTube Blog), and TechCrunch confirms the YPP gate.

Pick cut points that stay under the 180-second cap

Take a repurposing builder with a 24:40 interview and ten episodes to ship. The cut list is an array of second offsets, and every gap has to come in under 180. Leave a couple of seconds of headroom so encoder rounding doesn't push an episode over.

This n8n Code node turns offsets into one item per episode and throws if a segment is too long:

const source = 'https://storage.example.com/interview-master.mp4';
const cuts = [0, 148, 302, 455, 610, 768, 921, 1075, 1230, 1388, 1480];

return cuts.slice(0, -1).map((start, i) => {
  const duration = cuts[i + 1] - start;
  if (duration > 178) {
    throw new Error(`Segment ${i + 1} is ${duration}s, over the 180s Shorts cap`);
  }
  return { json: { episode: i + 1, label: `EP. ${i + 1}`, start, duration, source } };
});

Ten items, longest 158 seconds. Cut on beats rather than on a clock where you can. A segment that starts mid-sentence still satisfies YouTube and still loses the viewer.

One call does the cut, the reframe, and the hook bar

All three are the same encode, so don't run three passes. Trim with -ss and -t, fill 1080x1920 with scale plus crop, and stamp the episode bar with drawbox and drawtext in the same filter chain.

The local version for episode three:

ffmpeg -ss 302 -i interview-master.mp4 -t 153 \
  -vf "scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,\
drawbox=x=0:y=210:w=1080:h=150:color=0x111111@0.85:t=fill,\
drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:\
text='EP. 3':fontcolor=white:fontsize=84:x=(w-text_w)/2:y=246" \
  -c:v libx264 -preset veryfast -crf 21 -pix_fmt yuv420p \
  -c:a aac -b:a 128k -movflags +faststart ep03.mp4

The consistency trick is the absolute y=210 on the box and y=246 on the text. Fixed pixel offsets and one fixed fontsize put the bar in the same place on all ten episodes, so the feed reads as one series, not ten unrelated clips. Center vertically with (h-text_h)/2 instead and a font metric difference shifts the bar a few pixels between episodes, and it shows.

The same job as one API request:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer $FFMPEG_MICRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_url": "https://storage.example.com/interview-master.mp4",
    "args": "-ss 302 -t 153 -vf scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,drawbox=x=0:y=210:w=1080:h=150:color=0x111111@0.85:t=fill,drawtext=font=DejaVuSans:text=EP.\\ 3:fontcolor=white:fontsize=84:x=(w-text_w)/2:y=246 -c:v libx264 -preset veryfast -crf 21 -pix_fmt yuv420p -c:a aac -b:a 128k -movflags +faststart",
    "output_filename": "ep03.mp4"
  }'

{ "id": "tr_8f31c2a90d", "status": "queued" }

Poll GET https://api.ffmpeg-micro.com/v1/transcodes/tr_8f31c2a90d until status is completed and the output URL is there. Same flags, no encoder to install, no 2.5-minute render holding a worker on your box.

To settle the bar's color, height and wording before committing to ten episodes, the Viral Short blueprint is this exact step as an upload-and-download form: burn hook text onto a vertical video, optional music bed. Get the look right, then copy the numbers into the filter chain above.

The genuinely new step is pulling a frame per episode

A Shorts thumbnail can come straight out of the episode it belongs to. Grab a frame at a timestamp where the episode bar is on screen, and the thumbnail carries the episode number for free:

ffmpeg -ss 2.5 -i ep03.mp4 -frames:v 1 -q:v 2 ep03-thumb.jpg

Because ep03.mp4 is already 1080x1920, the extracted frame is 1080x1920, the floor YouTube publishes for series artwork. Its thumbnail guidance recommends 2160x3840 for Shorts, with a minimum height of 640 px, a 9:16 ratio, JPG or PNG, up to 50 MB on desktop. A -q:v 2 JPEG at 1080x1920 lands in the low hundreds of kilobytes, so the 10 MB artwork ceiling is never in play. For the recommended size, add -vf scale=2160:3840:flags=lanczos to the frame grab.

As an API call it's the same POST /v1/transcodes shape, with the episode output as the input:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer $FFMPEG_MICRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_url": "https://cdn.ffmpeg-micro.com/out/ep03.mp4",
    "args": "-ss 2.5 -frames:v 1 -q:v 2",
    "output_filename": "ep03-thumb.jpg"
  }'

The n8n loop that runs the whole series in one execution

One execution, one source video, ten episodes and ten thumbnails. The loop is a Split In Batches node with batch size 1 around four HTTP Request calls:

For ten segments, polling is fine. For a 40-episode run, swap the Wait-and-poll pair for a webhook so a stalled job can't hold the execution open, using the patterns in webhooks for long-running video jobs.

Why HTTP rather than shelling out to FFmpeg inside n8n:

That Execute Command change is why this is an HTTP step now; full story in n8n disabled the Execute Command node.

Pitfalls that cost a whole series run

Most of these failures are silent, which is worse than an error.

Where the automation stops, and when to skip it

Uploading the thumbnails is still manual: Shorts custom thumbnails can currently only be added in YouTube Studio on a computer, on a verified account. Through the Data API, thumbnails.set costs 50 quota units against a 10,000-unit daily pool, roughly 200 operations a day, needs phone verification, and has been reported to fail silently while the video upload succeeds. So the realistic target is ten correctly sized JPGs named ep01-thumb.jpg through ep10-thumb.jpg, in publish order, ready to drag into Studio.

Some series are the wrong fit for this. If every episode needs its own animated lower-third, scripted voiceover or per-episode layout, a template-editor service matches better than a filter chain, because the variation lives in the design, not the encode. And if your source is an unstructured talking head with no natural beats, no split timestamp saves it. FFmpeg does the repeatable part: identical geometry, identical bar, identical thumbnail treatment, ten times in a row. For the reframe decisions behind that crop, see FFmpeg can't auto reframe video to vertical.

FAQ

How long can a Shorts series episode be?

A Shorts series episode can run up to 180 seconds and must be portrait or square, per YouTube's help page on creating shows. The playlist may contain only Shorts, so a 4-minute cut disqualifies that segment entirely.

Do I have Shorts series in my account yet?

Shorts series is gated to YouTube Partner Program creators and began rolling out on 2026-09-23 across web, mobile and TV. If Studio doesn't offer seasons and episodes on a Shorts playlist, either the rollout hasn't reached your channel or it isn't in YPP.

Can I upload Shorts thumbnails programmatically?

Shorts custom thumbnails can currently only be added in YouTube Studio on a computer, on a verified account. The thumbnails.set endpoint in the YouTube Data API costs 50 quota units against a 10,000-unit daily pool and has been reported to fail silently on Shorts, so treat the upload as a manual step and automate the image production.

How do I make the burned episode number match YouTube's?

YouTube auto-numbers series episodes by publish date, so the burned EP. N bar only matches if you publish the segments in the order you numbered them. Publish one at a time in sheet order, or edit the numbers in Studio afterward to match what's on screen.

Point the loop at your first source video and you'll have ten numbered episodes plus ten thumbnails without installing FFmpeg anywhere. The free tier is enough to run a full series and see whether the bar lands where you want it.