Faceless YouTube Pipeline with Claude: Scripts, Voice, Frames & Compliance

The viral version of this idea says "$41K a month with Claude and zero face time." The posts making that claim sell courses, prompt packs, and niche-finder affiliate codes. One is a copy of another with only the revenue figure changed. None show verifiable earnings.

The honest version is less exciting and more useful. AI collapses the production cost of a faceless video to cents. It does nothing for the two things that decide whether a channel earns: whether people click, and whether YouTube considers the channel worth paying. This blueprint covers both halves: the build, and the rules that decide whether it ever makes money.

What You'll End Up With

• generate_script.py: a retention-structured script from Claude, steered by your own Channel Bible
• generate_voice.py: narration from Kokoro (preset voices) or Chatterbox (your cloned voice)
• generate_srt.py: segment-timed captions from faster-whisper, which also drive the visual cuts
• generate_frames.py: one Flux image per scene, from a locked art spec
• render_video.py: the timeline, audio, and burned-in captions assembled into a 1080p MP4
• An outlier-tracking sheet for finding formats that already work

The Problem: Production Is Cheap, Monetization Isn't

The gate

To earn ad revenue you need the YouTube Partner Program. The official requirements are 1,000 subscribers plus either 4,000 public watch hours in the last 12 months or 10 million public Shorts views in 90 days. Watch time from the Shorts feed does not count toward the 4,000 hours. Meeting the numbers starts a human review; it doesn't guarantee approval.

Secondary guides describe a lower early-access tier (500 subscribers, 3 uploads in 90 days, 3,000 watch hours or 3M Shorts views) that unlocks fan funding but not ads. Third-party outlets also report that the thresholds double on February 1, 2027. Neither appeared on an official YouTube page at the time of writing. Check YouTube Studio's Earn tab for what applies to your channel.

The policy that kills automated channels

On July 15, 2025, YouTube renamed its "repetitious content" policy to inauthentic content. The monetization policies now explicitly exclude mass-produced content made with automation or AI that differs only slightly from video to video. YouTube's own example of a violation is the same background music and repetitive AI imagery behind AI-scripted narration, across many uploads.

Reviews look at the channel, not one video: its main theme, most-viewed and newest uploads, and metadata. A pipeline that outputs one template forever is exactly what reviewers are trained to flag. The consequence is losing monetization: the channel can be removed from the Partner Program, and serious or repeated violations can lead to termination.

The economics, without the hype

The best public data comes from AIR's analysis of 300 channels: education had the highest median RPM, about $10 per 1,000 views, roughly four times the all-niche median. Kids content sits near the bottom. Finance and tech RPMs quoted online range from $8 to $80 depending on who is selling what; treat $10–20 as a hopeful middle.

Shorts pay far less. Creators report roughly $2–6K a month from 3–6M monthly views, under $1 per 1,000. Use Shorts to grow the channel, cut from your long-form videos, not as the business.

Pick a Niche You Can Have Opinions About

The highest-value prompt in the whole workflow runs before any code:

The "real opinion" constraint is not decoration. It is your compliance strategy: a channel built on a person's actual views is hard to mistake for mass-produced content.

Niches to avoid:

• Film/TV clip channels. Content ID routes revenue to the rights holder, and fair use is a defense you argue after a claim, not a permission.
• Reddit-story narration. Low RPM and the most heavily templated format on the platform.
• Kids content. The lowest monetized playback rate in AIR's data, plus made-for-kids restrictions.

Setup

pip install anthropic kokoro soundfile faster-whisper srt diffusers transformers accelerate sentencepiece moviepy
pip install chatterbox-tts   # only if you clone a voice; it pins its own torch (see the Colab note)
# Kokoro uses espeak-ng as a phoneme fallback
sudo apt-get install -y espeak-ng ffmpeg   # macOS: brew install espeak-ng ffmpeg

channel/
├── bible.md            # your Channel Bible (opinions, voice, banned clichés)
├── art_spec.txt        # the art spec prompt from Step 4, with a {scene} placeholder
├── my_voice.wav        # optional: your voice sample for Chatterbox
├── videos/
│   └── 001-topic-slug/
│       ├── script.txt
│       ├── voice.wav
│       ├── captions.srt
│       ├── scenes.json  # scene start times + descriptions
│       ├── frames/
│       ├── raw.mp4
│       └── final.mp4

Set ANTHROPIC_API_KEY in your environment. Everything else runs locally or on Colab with no API key.

Run It on Google Colab (Free GPU)

Steps 2–4 load neural models. On a laptop without a CUDA GPU, Chatterbox and Flux run painfully slowly or not at all. A Colab GPU runtime fixes that. If you're new to Colab, start with Getting Started and Working in Colab.

Which GPU to pick:

Burn rates we've observed on other Colab builds: T4 about 1.2–1.5 compute units per hour, L4 about 1.8–2.5, A100 about 5.4–7.5. These are observations, not published rates. Skip the A100, G4, and H100 for this pipeline: they cost more per hour and the models here don't need them.

Three habits keep a Colab batch safe:

# 1. Keys live in Colab Secrets (key icon in the sidebar), never in the notebook
import os
from google.colab import userdata
os.environ["ANTHROPIC_API_KEY"] = userdata.get("ANTHROPIC_API_KEY")

# 2. Work on Drive so outputs survive a disconnect
from google.colab import drive
drive.mount("/content/drive")
os.chdir("/content/drive/MyDrive/channel")

# 3. Make every step skip work that already exists (see the `if out.exists()` checks below)

Model weights download from Hugging Face on first run. Hugging Face Models in Colab covers caching them so you don't pay the download time every session. When a batch finishes, disconnect the runtime: idle GPUs still burn units.

Step 1: The Script (generate_script.py)

Two pieces of text do the real work. The system prompt enforces retention structure. The Channel Bible makes the scripts sound like your channel instead of the average of every channel.

bible.md is a short file you write once and keep editing:

# Channel Bible
Channel: [name], about [niche], for [specific viewer].
Positions I hold that most channels in this niche don't:
- [contrarian view 1, with the reason]
- [contrarian view 2]
Recurring segments: [e.g. "the number nobody quotes", a closing myth-bust]
Voice: dry, specific, no hype. Never say: "game-changer", "in today's video", "let's dive in".

import sys
from pathlib import Path
import anthropic

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You write 1,500-word educational YouTube scripts for voiceover.
Structure:
1. Hook within the first 5 seconds: open on peak conflict or the most surprising statistic.
   Never open with "welcome back" or a channel intro.
2. Three narrative beats, each built on a concrete, contrarian real-world example.
3. A story-driven curiosity loop roughly every 45 seconds: open a question, pay it off later.
4. One clear, actionable takeaway.
5. A soft call to subscribe in the last 15 seconds.
Tone: plain and conversational, written for someone with no background in the topic.
Output only the words to be spoken: no headings, stage directions, or bracketed notes.

Follow this Channel Bible. Its positions override generic takes:
{bible}"""


def generate_script(topic: str, bible_path: str = "bible.md") -> str:
    bible = Path(bible_path).read_text()
    message = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,
        system=SYSTEM_PROMPT.format(bible=bible),
        messages=[{"role": "user", "content": f"Write the complete script for: {topic}"}],
    )
    return message.content[0].text


if __name__ == "__main__":
    topic, out_dir = sys.argv[1], Path(sys.argv[2])
    out = out_dir / "script.txt"
    if not out.exists():
        out_dir.mkdir(parents=True, exist_ok=True)
        out.write_text(generate_script(topic))

Read every script before voicing it. This is the cheapest place to add the human input the policy asks for: cut the weak beat, add the example only you know, fix the claim the model got wrong.

Step 2: The Voice (generate_voice.py)

You don't need a paid TTS subscription. Two open-weight models cover the pipeline, and both are licensed for commercial use:

Avoid F5-TTS, XTTS-v2, and Fish Speech for a monetized channel: their weights carry non-commercial licenses. If you prefer a hosted API, the ElevenLabs free tier also excludes commercial use, so budget for a paid plan.

Kokoro (preset voice):

import sys
from pathlib import Path
import numpy as np
import soundfile as sf
from kokoro import KPipeline

def voice_kokoro(script: str, out: Path, voice: str = "af_heart"):
    pipeline = KPipeline(lang_code="a")  # "a" = American English
    chunks = [np.asarray(audio) for _, _, audio in pipeline(script, voice=voice, split_pattern=r"\n+")
              if audio is not None]
    sf.write(out, np.concatenate(chunks), 24000)

Chatterbox (your cloned voice). It generates best in short passages, so voice the script paragraph by paragraph:

import torch
import torchaudio
from chatterbox.tts import ChatterboxTTS

def voice_chatterbox(script: str, out: Path, sample: str = "my_voice.wav"):
    model = ChatterboxTTS.from_pretrained(device="cuda")
    paragraphs = [p.strip() for p in script.split("\n") if p.strip()]
    wavs = [model.generate(p, audio_prompt_path=sample) for p in paragraphs]
    torchaudio.save(str(out), torch.cat(wavs, dim=-1), model.sr)

Record my_voice.wav as 10–20 seconds of clean speech in a quiet room. Cloning your own voice is the cleanest option: you need nobody's consent, and it carries the least disclosure risk. Never clone someone else's voice without written permission.

Pick the engine on the command line (python generate_voice.py videos/001-topic-slug chatterbox):

if __name__ == "__main__":
    video_dir = Path(sys.argv[1])
    engine = sys.argv[2] if len(sys.argv) > 2 else "kokoro"
    out = video_dir / "voice.wav"
    if not out.exists():
        script = (video_dir / "script.txt").read_text()
        voice_chatterbox(script, out) if engine == "chatterbox" else voice_kokoro(script, out)

Step 3: Captions and Timing (generate_srt.py)

Whisper transcribes your narration back into timed segments. That one file does two jobs: it becomes the burned-in captions, and its timestamps decide when the visuals cut.

import sys
from datetime import timedelta
from pathlib import Path
import srt
from faster_whisper import WhisperModel

def generate_srt(audio: Path, out: Path):
    model = WhisperModel("large-v3", device="cuda", compute_type="float16")
    segments, _ = model.transcribe(str(audio), vad_filter=True)
    subs = [
        srt.Subtitle(index=i, start=timedelta(seconds=s.start),
                     end=timedelta(seconds=s.end), content=s.text.strip())
        for i, s in enumerate(segments, start=1)
    ]
    out.write_text(srt.compose(subs))

if __name__ == "__main__":
    video_dir = Path(sys.argv[1])
    out = video_dir / "captions.srt"
    if not out.exists():
        generate_srt(video_dir / "voice.wav", out)

On CPU, swap in device="cpu", compute_type="int8" and a smaller model such as "small".

Step 4: The Frames (generate_frames.py)

A 10-minute narration produces well over 100 caption segments. One image per segment is wasteful, and the cuts feel frantic. Instead, group consecutive segments into scenes of at least 8 seconds, ask Claude for one visual description per scene, then render each with a locked art spec.

The art spec is what keeps a video visually coherent. Save it as art_spec.txt in the channel folder; the script swaps each scene description into {scene}:

import json
import re
import sys
from pathlib import Path
import anthropic
import srt
import torch
from diffusers import FluxPipeline

def group_scenes(subs, min_seconds=8.0):
    scenes, current = [], []
    for sub in subs:
        current.append(sub)
        if (current[-1].end - current[0].start).total_seconds() >= min_seconds:
            scenes.append(current)
            current = []
    if current:
        scenes.append(current)
    return scenes

def describe_scenes(scenes, attempts: int = 3) -> list[str]:
    narration = [" ".join(s.content for s in scene) for scene in scenes]
    prompt = (
        f"Below are {len(narration)} narration chunks. For each one, write one concrete "
        "visual scene (one sentence: who or what is shown, doing what). Return only a JSON "
        f"array of exactly {len(narration)} strings, in order.\n\n" + json.dumps(narration)
    )
    for _ in range(attempts):
        message = anthropic.Anthropic().messages.create(
            model="claude-sonnet-5-5",
            max_tokens=8000,
            messages=[{"role": "user", "content": prompt}],
        )
        fence = "`" * 3  # strip a Markdown code fence if Claude adds one
        text = re.sub(rf"^{fence}(?:json)?\s*|\s*{fence}$", "", message.content[0].text.strip())
        descriptions = json.loads(text)
        if len(descriptions) == len(scenes):
            return descriptions
    raise ValueError(f"Expected {len(scenes)} scene descriptions, got {len(descriptions)}")

def generate_frames(video_dir: Path, art_spec_path: str = "art_spec.txt"):
    # Plan once and cache, so reruns reuse the same descriptions as the cached frames
    plan_path = video_dir / "scenes.json"
    if plan_path.exists():
        plan = json.loads(plan_path.read_text())
    else:
        subs = list(srt.parse((video_dir / "captions.srt").read_text()))
        scenes = group_scenes(subs)
        descriptions = describe_scenes(scenes)
        plan = [{"start": s[0].start.total_seconds(), "scene": d}
                for s, d in zip(scenes, descriptions)]
        plan_path.write_text(json.dumps(plan, indent=2))

    frames = video_dir / "frames"
    frames.mkdir(exist_ok=True)
    todo = [(i, p["scene"]) for i, p in enumerate(plan, start=1)
            if not (frames / f"frame_{i:03d}.png").exists()]
    if not todo:
        return

    art_spec = Path(art_spec_path).read_text()
    pipe = FluxPipeline.from_pretrained(
        "black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
    pipe.enable_model_cpu_offload()  # fits a 24 GB L4

    for i, scene in todo:
        image = pipe(art_spec.replace("{scene}", scene), width=1920, height=1088,
                     num_inference_steps=4, guidance_scale=0.0,
                     max_sequence_length=256).images[0]
        image.save(frames / f"frame_{i:03d}.png")

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

FLUX.1-schnell is Apache 2.0, so its output is safe to monetize. Flux needs dimensions divisible by 16, hence 1088 instead of 1080; the renderer crops to 1080. If you'd rather not run a model, a hosted image API such as Gemini's works with the same art spec. Swap the pipeline call for an API call.

Step 5: Render (render_video.py)

Each frame stays on screen from its scene's start until the next scene starts. That way the visuals cover Whisper's silent gaps and the video length matches the narration exactly.

import json
import subprocess
import sys
from pathlib import Path
from moviepy import AudioFileClip, ImageClip, concatenate_videoclips

def render(video_dir: Path):
    audio = AudioFileClip(str(video_dir / "voice.wav"))
    starts = [s["start"] for s in json.loads((video_dir / "scenes.json").read_text())]
    starts[0] = 0.0
    ends = starts[1:] + [audio.duration]

    clips = [
        ImageClip(str(video_dir / "frames" / f"frame_{i:03d}.png"))
        .with_duration(end - start)
        .cropped(height=1080, y_center=544)
        for i, (start, end) in enumerate(zip(starts, ends), start=1)
    ]
    video = concatenate_videoclips(clips).with_audio(audio)
    raw = video_dir / "raw.mp4"
    video.write_videofile(str(raw), fps=24, codec="libx264", audio_codec="aac")

    # Burn in captions with FFmpeg
    # Run inside video_dir so the subtitles filter gets a bare filename (no path escaping)
    subprocess.run([
        "ffmpeg", "-y", "-i", "raw.mp4",
        "-vf", "subtitles=captions.srt:force_style='FontSize=11,Outline=1'",
        "-c:a", "copy", "final.mp4",
    ], check=True, cwd=video_dir)

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

This uses the MoviePy 2.x API (with_duration, with_audio, cropped). Older tutorials use set_duration and moviepy.editor, which no longer exist in 2.x. For background music, use the YouTube Audio Library, which is cleared for monetized videos, and mix it well under the voice.

Packaging Decides Reach

Creators who run these pipelines say they put roughly 40% of their effort into the title and thumbnail. Click-through rate decides whether YouTube shows the video to anyone. The pipeline can draft options. Pick and refine them yourself.

• Write 10 titles per video and pick the one that creates the most specific curiosity gap.
• The thumbnail needs one subject, high contrast, and at most three words, readable on a phone.
• The first 30 seconds must deliver what the title promised. The script's 5-second hook rule exists for this.

Finding Formats That Already Work

Don't guess at formats. Track the ones already outperforming in your niche:

Batch Schedule

A sustainable weekly rhythm for one person:

Aim for one or two long-form videos a week, with Shorts cut from them. Consistency matters more than volume. Volume without variety is what the policy targets.

Compliance Checklist

Before every upload:

• Altered or synthetic content. Disclose realistic AI content: a real person appearing to say or do something they didn't, altered footage of real events, or realistic scenes that never happened. Disclosure isn't required for clearly unrealistic or animated visuals (a whiteboard stick figure qualifies), or AI help with scripts, titles, or thumbnails. For AI-cloned voices, check the current policy page; when in doubt, disclose. Disclosing doesn't reduce reach or monetization eligibility.
• Reused content. Third-party clips need real commentary or educational value added. See YouTube's fair use guidance.
• Licenses. Commercial-use rights for every model and asset: Kokoro (Apache 2.0), Chatterbox (MIT), FLUX.1-schnell (Apache 2.0), and the YouTube Audio Library for music.
• Voice. Your own voice, a preset voice, or written consent. Nothing else.
• Variety. Does this upload look and sound like the last ten? If yes, change the art spec, the format, or the angle.

What Automation Can't Do

• Opinion. The Channel Bible helps, but if you have no views on the niche, the scripts converge on the generic average, and so does the channel.
• Fact-checking. Claude will state wrong numbers confidently. Every statistic in a script needs a source you checked.
• Approval. Meeting the thresholds starts a human review. A channel that reads as a content farm can fail review even at 1,000 subscribers.
• Time. No reliable data says how long a new channel takes to reach the threshold. Plan on months of uploads before any ad income.

What It Costs

The real cost is your time on scripts and packaging, and that time is what makes the channel pay.

What's Next

• Google Colab guides: GPU runtimes, compute units, and the Colab CLI for running these steps from your terminal
• Scroll-Storytelling Firefly River: another blueprint built around locked art direction and negative constraints
• Tool Blueprints: more end-to-end builds