How to Use Claude AI to Clip YouTube Videos with the ClipAgent API

Here's a scenario: you run a YouTube channel. Every week you publish a 60-minute podcast. You know you should be clipping it into 8-10 shorts for TikTok, Reels, and YouTube Shorts. But finding the right moments, trimming, adding captions, cropping to 9:16 — it takes hours. So most weeks, you just... don't.

What if you could say to an AI: "Here's this week's episode. Find the 5 most viral moments. Render them with Hormozi-style captions. Go."

That's what we're building. A fully autonomous AI clipping agent using Claude as the brain and the ClipAgent APIas the hands. By the end of this tutorial, you'll have a Python script that turns any YouTube URL into finished short-form clips — with zero manual editing.

Why This Combination Works

Claude is great at judgment.It can read a list of potential clips, understand the hooks, evaluate what's likely to go viral on TikTok vs. YouTube, and make creative decisions. It understands audience, platform culture, and content strategy.

Claude is terrible at video processing.It can't download a YouTube video, extract audio, detect faces, or render an MP4. These are not language tasks.

The ClipAgent API is great at video processing. Give it a YouTube URL — it downloads the video, transcribes it, detects speakers, identifies viral moments using AI, and renders 9:16 clips with captions. But it doesn't have creative judgment about which clips to publish or how to position them.

Put them together and you get something neither can do alone: an autonomous clipping agent with both creative intelligence and video processing capability.

Setup: Two API Keys, Five Minutes

You need:

1. ClipAgent API key — Get one from your ClipAgent dashboard. $2 per video processed. No subscription, credits never expire.
2. Anthropic API key — Sign up at console.anthropic.com. Claude Sonnet is cheap — this entire workflow costs a few cents per run.

Install the Python dependencies:

pip install anthropic requests

Step 1: Send a YouTube URL to ClipAgent

The ClipAgent API does all the heavy lifting. You give it a URL — it downloads the video, transcribes the audio, detects speakers, analyzes the content, and returns a ranked list of clip candidates.

import requests

CLIPAGENT_API_KEY = "your_clipagent_key"

def analyze_video(youtube_url: str, max_clips: int = 10) -> dict:
    """Send a YouTube URL to ClipAgent for viral moment detection."""
    response = requests.post(
        "https://clip-agent.com/v1/analyze",
        headers={
            "Authorization": f"Bearer {CLIPAGENT_API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "url": youtube_url,
            "max_clips": max_clips,
            "min_duration": 30,
            "max_duration": 90,
        },
    )
    response.raise_for_status()
    return response.json()

The response looks like this:

{
  "video_id": "abc123",
  "title": "The Future of AI Startups — Full Episode",
  "duration": 3847,
  "clips": [
    {
      "id": "clip_001",
      "title": "Why 90% of AI startups will fail this year",
      "hook": "Here's what nobody's talking about...",
      "start_ms": 124000,
      "end_ms": 189000,
      "virality_score": 94,
      "speaker_count": 2
    },
    {
      "id": "clip_002",
      "title": "The one metric that actually predicts virality",
      "hook": "Forget views. Forget likes. The only number...",
      "start_ms": 845000,
      "end_ms": 912000,
      "virality_score": 88,
      "speaker_count": 1
    },
    // ... more clips ranked by virality
  ]
}

Notice each clip has a virality_score, a hook (the opening line that grabs attention), and speaker_count. This is what Claude will use to make its decisions.

Step 2: Let Claude Be the Creative Director

This is where it gets interesting. Instead of just sorting by virality score (a simple sort() would do that), we ask Claude to think like a social media strategist:

import anthropic

client = anthropic.Anthropic()  # uses ANTHROPIC_API_KEY env var

def pick_best_clips(clips: list, context: str = "") -> str:
    """Ask Claude to select and rank the best clips for publishing."""

    clips_text = ""
    for c in clips:
        clips_text += (
            f"- [{c['id']}] "{c['title']}"\n"
            f"  Hook: "{c['hook']}"\n"
            f"  Virality: {c['virality_score']}/100 | "
            f"Duration: {(c['end_ms'] - c['start_ms']) / 1000:.0f}s | "
            f"Speakers: {c['speaker_count']}\n\n"
        )

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[
            {
                "role": "user",
                "content": f"""You're a short-form video strategist.

I have these clip candidates from a podcast episode:

{clips_text}

{f"Additional context: {context}" if context else ""}

Pick the top 3 clips to publish. For each:
1. Why this clip will perform well (be specific — hook quality,
   emotional trigger, shareability)
2. Which platform it's best for (TikTok, YouTube Shorts, or Reels)
   and why
3. A suggested caption/description for that platform

Return the clip IDs in order of priority.""",
            }
        ],
    )
    return message.content[0].text

Why this is better than just sorting by score: Claude considers things the virality algorithm can't — like whether two clips cover similar topics (you don't want to post both), whether a hook works better on TikTok vs. YouTube (different audiences), or whether a clip needs context that short-form viewers won't have.

You can customize the prompt for your specific channel. Add context like "My audience is SaaS founders, they respond well to data and contrarian takes" — and Claude will factor that into its picks.

Step 3: Render the Winners

Once Claude picks the clips, render them as finished 9:16 shorts with captions and branding:

def render_clip(video_id: str, clip_id: str,
                caption_style: str = "hormozi") -> str:
    """Render a clip as a vertical short with captions."""
    response = requests.post(
        "https://clip-agent.com/v1/render",
        headers={
            "Authorization": f"Bearer {CLIPAGENT_API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "video_id": video_id,
            "clip_id": clip_id,
            "format": "9:16",
            "captions": {
                "style": caption_style,
                "uppercase": True,
            },
            "smart_crop": True,
            "brand": {
                "handle": "@yourhandle",
                "position": "bottom-right",
            },
        },
    )
    response.raise_for_status()
    return response.json()["download_url"]

The API returns a download_urlfor the finished MP4. Speaker-aware smart crop is applied automatically — for multi-speaker clips, the frame follows whoever is talking. The karaoke captions highlight each word as it's spoken.

The Real Power Move: Claude Tool Use

Everything above requires you to write the glue code — call the API, pass results to Claude, call another API. But with Claude's tool use feature, you can make it fully autonomous. Define the API endpoints as tools, and Claude decides when and how to call them:

tools = [
    {
        "name": "analyze_video",
        "description": (
            "Analyze a YouTube video to detect viral clip candidates. "
            "Returns clips ranked by virality with hooks, timestamps, "
            "and speaker info."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "url": {
                    "type": "string",
                    "description": "YouTube video URL"
                },
                "max_clips": {
                    "type": "integer",
                    "description": "Max clips to return (default 10)"
                }
            },
            "required": ["url"]
        }
    },
    {
        "name": "render_clip",
        "description": (
            "Render a selected clip as a 9:16 vertical short with "
            "karaoke captions and smart speaker tracking."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "video_id": {"type": "string"},
                "clip_id": {"type": "string"},
                "caption_style": {
                    "type": "string",
                    "enum": ["hormozi", "viral", "beast",
                             "ember", "minimal", "outline"],
                    "description": "Caption style preset"
                }
            },
            "required": ["video_id", "clip_id"]
        }
    }
]

# One message. That's it.
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    tools=tools,
    messages=[{
        "role": "user",
        "content": (
            "Here's our latest podcast: "
            "https://youtube.com/watch?v=dQw4w9WgXcQ\n\n"
            "Analyze it, pick the 3 most viral moments, and render "
            "them with hormozi-style captions. Our audience is tech "
            "founders who like actionable advice."
        )
    }]
)

# Claude will:
# 1. Call analyze_video with the URL
# 2. Review the clip candidates
# 3. Pick the best 3 based on your audience description
# 4. Call render_clip for each one
# 5. Return a summary with download links

That's an autonomous AI clipping agent in ~60 lines of Python. You give it a URL and a sentence about your audience. It gives you finished short-form clips.

Taking It to Production

The script above works for one-off runs. Here's how to turn it into a production pipeline:

1. Watch for new uploads

Use the YouTube Data API to monitor channels you want to clip. When a new video drops, trigger the pipeline automatically.

2. Add platform-specific logic

Tell Claude about each platform's culture in its system prompt. TikTok rewards controversy and hot takes. YouTube Shorts favors educational content. Instagram Reels does well with aspirational and aesthetic content. Claude can pick different clips for different platforms from the same source video.

3. Schedule publishing

Once clips are rendered, use the ClipAgent desktop app's built-in content calendar and scheduler — or connect to platform APIs directly. Post at optimal times for each platform.

4. Learn from performance

Track which clips Claude picks vs. which ones actually perform. Feed that data back into the prompt: "Last month, clips with strong hooks and single-speaker focus outperformed multi-speaker clips by 3x on our channel." Claude gets better with context.

Frequently Asked Questions

Related: ClipAgent vs OpusClip — Honest 2026 Comparison