Get Paid per View for Clipping: Auto-Cut Podcasts into Shorts with Whisper, Gemini and FFmpeg (Real Rates, Real Risks)

Streamers, podcasters and course sellers have figured out that short clips sell their long content better than ads do. Instead of hiring an editor, many of them now post a clipping campaign: they put up a budget, anyone can cut clips from their videos and post them on TikTok, YouTube Shorts or Instagram Reels, and the clipper gets paid per 1,000 views the clip earns.

The biggest marketplace for this is Whop’s Content Rewards, and there are smaller ones run through Discord servers. You don’t need followers, a client call or a portfolio. You need clips that get views, and lots of them.

The slow part of clipping is watching a 2-hour podcast to find the 40 seconds worth posting. That part can be automated. In this guide you’ll build a Python script that:

• transcribes a long video locally with faster-whisper (free)
• sends the timestamped transcript to Gemini 3.5 Flash-Lite, which returns the best 30–60 second moments as structured JSON
• cuts each moment, crops it to 9:16, and burns in subtitles with FFmpeg

Then we’ll go through what it actually pays, what it costs, and how clippers get their accounts throttled or banned.

How per-view clipping pays

The model is simple:

1. A creator or brand funds a campaign with a fixed budget (for example $2,000) and a rate (for example $1.00 per 1,000 views).
2. You download their source content (most campaigns link a Google Drive folder or their own channel), cut clips, and post them on your own social accounts.
3. You submit the link of each posted clip. The platform tracks views and pays out from the budget until it runs out.

Rates. These change daily, so check the live campaign list on whop.com before you plan anything. Snapshots of live campaigns in 2026 put the typical rate around $1 per 1,000 views, with most between roughly $0.50 and $3, and the higher ones usually come with stricter rules or small budgets. Many campaigns also set:

• a minimum view count before a clip counts at all
• a maximum payout per clip
• rules on which platforms are allowed, a required caption, hashtag or tag, and “no reuploads of full videos”

Here’s why the rate matters less than it looks: a clip with 800 views earns about $0.80 at $1 CPM, or nothing if the minimum is 1,000 views. The money is in the clips that break out to 50K–500K views. Your job is to post enough decent clips that a few of them break out. That’s a volume game, and volume is what automation is for.

What you need

Gemini pricing (check ai.google.dev/pricing before relying on it): Gemini 3.5 Flash-Lite paid tier is $0.30 per 1M input tokens and $2.50 per 1M output tokens. A 1-hour transcript is roughly 12,000–15,000 tokens, so picking highlights from an hour of video costs about half a cent.

Install everything:

python -m venv clipenv
source clipenv/bin/activate        # Windows: clipenv\Scripts\activate
pip install faster-whisper google-genai pydantic
export GEMINI_API_KEY="your-key"   # Windows: set GEMINI_API_KEY=your-key
ffmpeg -version                    # should print a version, not an error

Step 1: Pick a campaign and get the source file

Before writing any code, open the campaign list and filter for ones that suit automation:

• Talking-head content (podcasts, interviews, streams with a facecam). A center crop works on these. Gameplay or screen recordings need manual framing.
• Source files provided. If the campaign links a Drive folder, download from there. If it says “clip from my YouTube channel,” the creator has given permission, but YouTube’s Terms of Service still restrict downloading. Ask the campaign owner for files when you can.
• Rate × budget left. A $3 CPM campaign with $40 of budget remaining will be gone before your clips get traction. A $1 CPM campaign with $5,000 left is a better bet.

Save the file as source.mp4 in a working folder.

Step 2: The script

Save this as autoclip.py:

import json, subprocess, sys
from pathlib import Path

from faster_whisper import WhisperModel
from google import genai
from google.genai import types
from pydantic import BaseModel

MODEL = "gemini-3.5-flash-lite"
PRICE_IN, PRICE_OUT = 0.30, 2.50          # USD per 1M tokens
WHISPER_SIZE = "small"                     # "medium" is better, slower
NUM_CLIPS = 8


class Clip(BaseModel):
    start: float
    end: float
    hook_title: str
    why_it_works: str


class ClipList(BaseModel):
    clips: list[Clip]


def transcribe(video: Path, cache: Path):
    if cache.exists():
        return json.loads(cache.read_text())
    model = WhisperModel(WHISPER_SIZE, device="auto", compute_type="int8")
    segments, info = model.transcribe(str(video), vad_filter=True)
    segs = [{"start": round(s.start, 2), "end": round(s.end, 2), "text": s.text.strip()}
            for s in segments]
    cache.write_text(json.dumps(segs, ensure_ascii=False))
    print(f"Transcribed {len(segs)} segments, language={info.language}")
    return segs


def pick_clips(segs):
    transcript = "\n".join(f"[{s['start']:.1f}-{s['end']:.1f}] {s['text']}" for s in segs)
    prompt = f"""You are a short-form video editor. From this timestamped transcript,
pick the {NUM_CLIPS} best standalone moments for TikTok/Shorts/Reels.

Rules:
- Each clip 25-60 seconds. Use the exact start/end seconds from the transcript.
- The first sentence must hook on its own: a bold claim, a surprising number,
  a conflict, a strong opinion, or a question. No "so, um, anyway" openings.
- The clip must make sense without the rest of the video.
- End on a payoff or punchline, not mid-thought.
- No overlapping clips.
- hook_title: max 8 words, in the transcript's language, no clickbait lies.

Transcript:
{transcript}"""

    client = genai.Client()
    resp = client.models.generate_content(
        model=MODEL,
        contents=prompt,
        config=types.GenerateContentConfig(
            response_mime_type="application/json",
            response_schema=ClipList,
        ),
    )
    u = resp.usage_metadata
    out_tokens = (u.candidates_token_count or 0) + (u.thoughts_token_count or 0)  # thinking is billed as output
    cost = (u.prompt_token_count * PRICE_IN + out_tokens * PRICE_OUT) / 1e6
    print(f"Gemini: {u.prompt_token_count} in / {out_tokens} out = ${cost:.4f}")
    return resp.parsed.clips


def to_srt_time(t):
    ms = int(round(max(t, 0) * 1000))
    h, ms = divmod(ms, 3_600_000)
    m, ms = divmod(ms, 60_000)
    s, ms = divmod(ms, 1000)
    return f"{h:02}:{m:02}:{s:02},{ms:03}"


def write_clip_srt(segs, clip, path: Path):
    lines, n = [], 1
    for s in segs:
        if s["end"] <= clip.start or s["start"] >= clip.end:
            continue
        a = max(s["start"], clip.start) - clip.start
        b = min(s["end"], clip.end) - clip.start
        lines += [str(n), f"{to_srt_time(a)} --> {to_srt_time(b)}", s["text"], ""]
        n += 1
    path.write_text("\n".join(lines), encoding="utf-8")


def render(video: Path, clip, srt: Path, out: Path):
    style = ("FontName=Arial,Fontsize=13,Bold=1,PrimaryColour=&H00FFFFFF,"
             "OutlineColour=&H00000000,BorderStyle=1,Outline=2,Alignment=2,MarginV=70")
    vf = (f"crop=ih*9/16:ih,scale=1080:1920,"
          f"subtitles={srt.as_posix()}:force_style='{style}'")
    subprocess.run([
        "ffmpeg", "-y", "-loglevel", "error",
        "-ss", f"{clip.start:.2f}", "-t", f"{clip.end - clip.start:.2f}", "-i", str(video),
        "-vf", vf, "-c:v", "libx264", "-preset", "veryfast", "-crf", "20",
        "-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart", str(out),
    ], check=True)


def main(video_path):
    video = Path(video_path)
    outdir = video.with_suffix("")
    outdir.mkdir(exist_ok=True)
    segs = transcribe(video, outdir / "transcript.json")
    clips = sorted(pick_clips(segs), key=lambda c: c.start)
    log = []
    for i, c in enumerate(clips, 1):
        if not 15 <= c.end - c.start <= 90:
            print(f"skip clip {i}: bad length {c.end - c.start:.0f}s")
            continue
        srt, mp4 = outdir / f"clip{i:02}.srt", outdir / f"clip{i:02}.mp4"
        write_clip_srt(segs, c, srt)
        render(video, c, srt, mp4)
        log.append(c.model_dump() | {"file": mp4.name})
        print(f"clip{i:02}  {c.start:7.1f}-{c.end:7.1f}  {c.hook_title}")
    (outdir / "clips.json").write_text(json.dumps(log, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main(sys.argv[1])

Run it:

python autoclip.py source.mp4

You’ll get a source/ folder with clip01.mp4 … clip08.mp4, a matching .srt for each, the cached transcript, and clips.json with the hook title and the model’s reason for every pick. The transcript is cached, so if you don’t like the picks you can rerun for another half-cent without transcribing again.

A few notes on the choices:

• -ss before -i seeks quickly, and -t sets the clip length. Because we re-encode anyway (for the crop and subtitles), the cut is still accurate.
• crop=ih*9/16:ih takes a vertical slice from the center of a landscape video. On a two-person podcast shot wide, that can cut off whoever is talking. See Reality check.
• Timestamps come from Whisper segments, so clips start and end on sentence boundaries, which is what you want anyway.
• The length check throws away any clip the model returns outside 15–90 seconds instead of trusting it.
• No temperature setting. Gemini 3.5 Flash-Lite ignores custom temperature/top-p/top-k values, so the script doesn’t pretend to tune them. Thinking defaults to minimal, which keeps the cost at fractions of a cent.
• Run it from the folder that holds the video (python autoclip.py source.mp4, not a full C:\... path). FFmpeg’s subtitles filter treats the : in a Windows drive letter as an option separator and fails.

How long does it take? On a recent laptop CPU, the small Whisper model with int8 typically transcribes an hour of audio in roughly 5 to 30 minutes, depending on the CPU. On a mid-range NVIDIA GPU it’s a few minutes. Rendering eight 45-second clips takes a couple of minutes. If you want word-by-word highlighted captions (the style that tends to hold attention better), our guide on batch captioning reels with faster-whisper and FFmpeg shows how to swap the plain SRT for an ASS file with word timings.

Step 3: Review, then post

Don’t post straight out of the script. Spend 30 seconds per clip:

1. Watch the first 3 seconds. If the hook isn’t there, trim the start or bin the clip. Most of your clips will live or die here.
2. Check the subtitles for names and brand terms. Whisper misspells names. A wrong guest name in a creator’s own campaign gets clips rejected.
3. Check the crop. If the speaker is off-frame, either re-render with an offset crop (crop=ih*9/16:ih:X:0, where X is the left edge in pixels) or drop it.
4. Add the campaign’s required caption, tag or hashtag. Missing these is the most common reason for a rejected submission.

Then post from the phone app, one or two clips per account per day to start, and submit each link to the campaign.

Costs

The tools cost almost nothing. Your real cost is time: about 30–60 minutes a day to pick sources, review clips, post and submit.

Realistic earnings

Results are spread very unevenly. A rough way to think about it, at a $1 CPM campaign with no minimum:

These are illustrations, not promises. A single clip that hits 300K views is worth more than 200 clips that sit at 500 views. And if the campaign has a 1,000-view minimum, most first-month clips earn exactly $0.

It starts to compound once an account has followers in a niche (finance podcasts, fitness, business talk). New clips get pushed to them faster, and you can run several campaigns in that niche on the same account.

Risks: platform crackdowns, bans, and rejected payouts

This is a grey area in a couple of ways, so be clear about what you’re doing.

Reused content policies. You’re posting someone else’s footage on your accounts, with the owner’s permission. The platforms judge that on their own terms:

• YouTube renamed its “repetitious content” monetization policy to “inauthentic content” in July 2025, targeting mass-produced, repetitive uploads. That’s about YouTube Partner Program money, not Shorts reach, but channels that pump out near-identical clips are exactly what it’s aimed at.
• TikTok says unoriginal or low-effort reposted content may be ineligible for the For You feed, which is where clip views come from.
• Meta announced in July 2025 that Facebook accounts repeatedly reposting other people’s content would lose monetization and distribution, and Instagram also ranks original content above reposts.

What counts as “original enough” isn’t published. To stay on the safe side, make real edits (a tight cut, a hook, captions, your own title) instead of posting raw slices of the video. The script gets you the cut and captions. The review step is where you do the editing.

Mass accounts. Clippers run multiple accounts per platform to post more. That’s common, but the platforms’ own rules restrict it: TikTok and Instagram prohibit fake or inauthentic accounts and coordinated spam, and many accounts run from the same phone and IP address get linked and throttled together. If you do it:

• Keep it to a few accounts per platform, each with a real niche and a real profile.
• Don’t post the same clip on several of your own accounts. Duplicates are easy to detect.
• Warm up new accounts by using them normally for a few days before posting.
• Accept that you can lose an account at any time. Never build everything on one.

Botted views get you banned from the campaign, not paid. Campaign platforms check where views come from. Buying views or using engagement pods to inflate a clip is the fastest way to get your payout voided and your Whop account removed. It also moves from grey area into defrauding the person who funded the campaign. Don’t.

Copyright. Only clip content from campaigns that authorize it. Clipping a random celebrity podcast and monetizing it is copyright infringement, and a copyright strike on YouTube is more than a ToS warning: three strikes and the channel is terminated.

Payout risk. Campaign budgets run out, rules change mid-campaign, and the campaign owner reviews submissions. Read the rules every time and screenshot them when you join. Expect some rejected clips no matter what.

Reality check

Fully automated posting doesn’t work. Scheduling tools that auto-upload 20 clips a day to 10 accounts are exactly the pattern platforms throttle. The script automates the editing. Posting stays manual, or at least human-paced.

The model picks “interesting,” not “viral.” Gemini is good at finding self-contained moments with a clear point. It’s mediocre at predicting what will blow up. Treat its picks as a shortlist. Over time, save the clips that performed and add two or three of their transcripts to the prompt as examples of what works for your accounts.

Center crop fails on wide shots. Two-person podcasts filmed side by side, slides, gameplay: all of these need speaker tracking or manual framing. Skip those campaigns until you add it, or crop by hand.

Popular campaigns are crowded. Big campaigns attract thousands of clippers posting the same moments. Newer, smaller campaigns in a specific niche often pay better per hour, because fewer people are competing for the same audience.

Common mistakes:

• Posting 30 clips on day one from a brand-new account
• Skipping the campaign’s required tag or link, then wondering why it was rejected
• Making clips too long. Most good clips are 25–50 seconds.
• Chasing the highest CPM instead of the biggest remaining budget
• Letting Whisper’s spelling of a guest’s name go out unchecked

Model names change. If gemini-3.5-flash-lite is retired, set MODEL to the current Flash-Lite model and update PRICE_IN/PRICE_OUT.

Final checklist

• FFmpeg, faster-whisper and the Gemini key working (ffmpeg -version, one test run)
• Campaign picked: talking-head, source files provided, enough budget left
• Every clip reviewed: hook in the first 3 seconds, names spelled right, speaker in frame
• Required caption/tag added; link submitted after posting
• Two or three accounts max per platform to start, no duplicate clips across them
• No bought views, no unauthorized content

Start with one campaign and one account per platform today. Run the script on one episode, post the best three clips, and check the numbers after a week before you scale up.