Rank before you clip
Sort the catalogue by views per day since upload, not total views. Old evergreen videos with steady traffic make the best shorts; the launch-day spike doesn't.
Channel clipping means the whole channel, not one link: every new upload is clipped as it lands, and the back catalogue gets worked through in batches, with nobody pasting URLs. This guide builds that system three ways (a no-code toggle, an agent on a schedule, a script you own), then covers back-catalogue strategy, what it costs per channel per month, the approval queue that keeps it safe, and running it for many channels.
A channel system has two inputs that share one pipeline. The stream is new uploads: a trigger fires when a video publishes, the clipper runs, clips land in a review queue, approved ones go to a scheduler. The backlog is everything already on the channel: worked through at a fixed daily rate, best-performing videos first, until it's done.
Keep them separate in your tracking and your budget. The stream is small and permanent; the backlog is large and temporary, and it's where credits disappear if you let it run unmetered.
Pick by how much you want to own. All three end in the same review queue.
Connect the YouTube channel in OpusClip, enable Auto Import, set a clip-length range, a brand template and (optionally) a ClipAnything prompt such as "moments where the guest makes a bold claim". Each new upload is clipped automatically and appears in your projects; on Pro, approve and send to the six-platform scheduler. Costs one credit per source minute, so long uploads eat credits even when you keep three clips; there's no backlog mode, so batch the catalogue by pasting links. Best for one channel, one brand, no engineering. See the OpusClip review.
Connect a clipper's MCP server to Claude (Katto's hosted server works on the free plan; OpusClip's on Pro) and create a scheduled task that runs every few hours with the brief in the panel opposite. The agent reads the channel's RSS feed, compares against a seen-list it keeps in a file, creates a job per new video, polls, filters by score, and files clips with a one-line reason each. It never publishes; you approve from the queue. Add the backlog as a second instruction with a daily cap. Best when briefs vary by channel or you want judgement in the loop. See MCP servers.
A cron job polls youtube.com/feeds/videos.xml?channel_id=…, diffs against a database of seen video IDs, submits each new URL to the clipper's API (Katto, Klap, Vizard, OpusClip or self-hosted SupoClip), and a signed webhook or poll collects the clips into a review folder with metadata. A second job drains the backlog at N per day. Most control, most maintenance; the right build for agencies running many channels. Skeleton opposite; API details on AI clipping API and MCP.
Paste into a scheduled task that runs every 2–4 hours with the clipper's MCP server connected. Replace the channel ID and the score threshold once you have view data.
You are the clipping agent for channel UC_XXXX.
1. Fetch https://www.youtube.com/feeds/videos.xml?channel_id=UC_XXXX
2. Read seen.json. For each video ID not in it (max 3 per run):
- estimate cost first; stop and report if over 120 credits
- create a clip job: 30–60 s clips, 9:16, up to 8 clips,
brief: "complete ideas with a strong first sentence"
- poll until done; fetch clips
- keep clips with score >= 80; for each, write
queue/<videoId>/<clipId>.json with url, start, end,
score, and one line on why it was kept
- add the video ID to seen.json
3. Backlog: if fewer than 3 new videos ran, take up to
2 videos from backlog.txt (top first) and do the same.
4. Never publish, schedule, or delete anything.
5. Finish with a summary: videos processed, clips queued,
credits used, anything skipped and why.import json, os, re, time, urllib.request as u
CHANNEL = "UC_XXXX"
FEED = f"https://www.youtube.com/feeds/videos.xml?channel_id={CHANNEL}"
API, KEY = os.environ["CLIP_API"], os.environ["CLIP_API_KEY"]
SEEN = "seen.json"; DAILY_BACKLOG = 5
seen = set(json.load(open(SEEN))) if os.path.exists(SEEN) else set()
xml = u.urlopen(FEED).read().decode()
ids = re.findall(r"<yt:videoId>(.*?)</yt:videoId>", xml)
def submit(video_id):
body = json.dumps({"url": f"https://youtube.com/watch?v={video_id}",
"clip_length": "30-60s", "count": 8, "aspect": "9:16"}).encode()
req = u.Request(f"{API}/jobs", body, {"Authorization": f"Bearer {KEY}",
"Content-Type": "application/json"})
return json.load(u.urlopen(req))["id"] # webhook delivers clips later
new = [v for v in ids if v not in seen][:3] # stream: new uploads
backlog = [l.strip() for l in open("backlog.txt")][:DAILY_BACKLOG] if os.path.exists("backlog.txt") else []
for v in new + [b for b in backlog if b not in seen]:
job = submit(v); seen.add(v)
print("submitted", v, job)
json.dump(sorted(seen), open(SEEN, "w"))
# cron: */15 * * * * python3 watcher.py (webhook handler files clips to queue/)Sort the catalogue by views per day since upload, not total views. Old evergreen videos with steady traffic make the best shorts; the launch-day spike doesn't.
Two to five videos a day. A 300-video channel takes three to five months on a $29 plan; that's fine. Unmetered, it empties a month's credits in a week.
Where the tool supports it, submit only the segment after the intro and before the outro. Per-minute billing rewards this immediately.
Per-project (ClipForge) or per-video (Katto) tools make long archive videos cheap; per-minute tools (OpusClip, Vizard, Klap) make short ones cheap. Match the tool to the catalogue's average length.
Stream only, at two cadences. Backlog is extra and metered separately. Entry tiers, monthly billing.
| Channel cadence | Source minutes / mo | OpusClip | Vizard | Klap | Katto | ClipForge | SupoClip |
|---|---|---|---|---|---|---|---|
| Weekly 60-min episode | 240 | Pro $29 (300 cr) | Creator $29 (600 cr) | Basic $29 (300 min) | Solo €8.90 (10 videos) | Creator $19 (20 proj) | ~$3 API |
| Daily 20-min video | 600 | Pro ×2 $58 | Creator $29 (600 cr) | Pro $79 (900 min) | Creator €14.90 (25 videos)* | Pro $49 (100 proj) | ~$7 API |
| Channel watching | — | Native (Auto Import) | API + cron | API + cron | MCP / API + schedule | Manual links | MCP / API + cron |
* 30 videos exceeds Katto Creator's 25; Studio (late 2026) or a second account. Figures assume full source length is submitted; narrowing the range lowers per-minute costs. Model your own channel in the earnings calculator.
Start at 80, log views per clip against score for a month, then move the bar to where clips actually earn. The number is a ranking; your data turns it into a forecast.
Open each queued clip, drag the in-point to the strongest word, check the crop. Thirty seconds per clip, and the single biggest quality lever in the whole system.
Until weeks of approvals show the picks are reliable and the brand rules are encoded, the scheduler is fed by you, not the agent. Then promote one channel at a time.
Eight clips from one video should go out over a week, not an hour. A burst of near-identical Shorts reads as spam and gets throttled.
Video ID, job ID, credits used, clips kept, clips approved, views at day 7 and 14. The log is what lets you tune the threshold and prove the system pays.
Watching someone else's channel and clipping every upload is systematic reproduction of their work. Do it only inside a campaign or programme that grants it. See rights and rules.
The system doesn't change with more channels; the config does. One watcher, one clipper integration, one webhook handler, and a config row per channel: feed ID, brief, caption template, score threshold, daily backlog cap, and which queue clips land in. Approvals stay per client; the pipeline is shared.
OpusClip's Auto Import is the only native one. Katto, Vizard, Klap, OpusClip and SupoClip can all be driven from the channel's RSS feed through their APIs, and Katto, OpusClip and SupoClip through MCP with an agent on a schedule.
Poll https://www.youtube.com/feeds/videos.xml?channel_id=CHANNEL_ID every 15 minutes and diff video IDs against a seen-list. No API key needed. The YouTube Data API's push notifications work too if you already use it.
Yes, via OpusClip's scheduler, Katto's publishing, or your own scheduler using the YouTube API. Keep a human approval between the queue and the scheduler until the picks have earned trust.
Source length × the tool's billing unit. 300 videos averaging 20 minutes is 6,000 source minutes: about 20 months of OpusClip Pro, 10 of Vizard Creator, or 300 Katto videos (about a year of Creator). Meter it and start with the evergreen videos.
Only with permission: your own channels, clients who've authorised it, or a campaign that grants it. Systematic clipping of someone else's uploads without it is reproduction of their work. See automatic YouTube clipper for the per-link rules.