Build a YouTube monitoring agent in under 30 minutes

A marketing lead I know spent 6 hours every Monday checking 12 YouTube channels by hand. Watching videos at 2x speed. Copy-pasting quotes into a Google Doc.

She sent a Slack summary nobody read until Wednesday.

She replaced that entire workflow with 40 lines of Python and an API call.

In this guide, I'll show you how to automate YouTube channel monitoring with an AI agent. It pulls transcripts, runs them through an LLM, and drops a structured report in Slack.

The whole setup takes less than 30 minutes. The time it saves compounds every week.

Why you should automate youtube channel monitoring

Think about what you're actually doing when you "monitor" a YouTube channel. You open the page. You scan for new uploads. You watch or skim.

You take notes. You tell your team what you found.

That's five steps of work that a script can do in seconds.

The math on manual monitoring

10 channels. 4 new videos per week each. 15 minutes per video to watch and summarize. That's 10 hours a week.

Over a year, that's 520 hours on something a bot handles in minutes.

And that's just the time cost. The real problem is consistency. People skip weeks. They miss videos.

They summarize what they remember, not what was actually said.

An agent doesn't skip weeks. It processes every video the same way, every time.

This isn't just about competitors

Most people think "monitoring" means watching competitors. That's one use case. But there are at least four others worth your attention:

• Industry trend tracking. Follow 20 thought leaders in your space and spot topics before they go mainstream.

• Your own channel repurposing. Every new video you publish gets auto-transcribed and turned into blog drafts, social posts, and newsletter content.

• Client reporting for agencies. Set up per-client monitoring and deliver branded intelligence reports without manual work.

• Educational content tracking. Researchers and educators can follow lecture series and conference channels to stay current.

Which of these would save you the most time right now?

How the monitoring agent works

The architecture has three layers. Each one does one thing well.

1. Data layer (TranscriptAPI). Checks channels for new uploads and pulls full transcripts.

2. Intelligence layer (LLM). Reads transcripts and produces structured analysis.

3. Orchestration layer. Handles scheduling, state, and delivery.

TranscriptAPI handles YouTube's messy parts — caption extraction, rate limits, format normalization. The LLM handles understanding. The orchestration layer keeps it all running on schedule.

You can build the orchestration yourself with cron and Python. Or you can skip the infrastructure and use a platform like CRHQ that manages scheduling, state, and error recovery for you. I'll show both approaches.

Set up your TranscriptAPI account

Go to transcriptapi.com and sign up. You get 100 free credits immediately. No credit card required.

Two endpoints matter for this project:

• /youtube/channel/latest returns the latest 15 uploads from any channel. Free. Zero credits. Call it every hour without spending anything.

• /youtube/transcript returns the full transcript with timestamps. Costs 1 credit per call. Failed requests cost 0 credits.

The paid plans start at $5/month for 1,000 credits, or $54/year with cheaper top-ups. Rate limits are 200 requests per minute on monthly plans and 300 RPM on annual.

For most monitoring setups, you won't come close to those limits. Ready to write some code?

Step 1: check channels for new uploads

Start with the free endpoint. This polls a channel and returns its most recent videos.

import requests
import os

API_KEY = os.environ["TRANSCRIPTAPI_KEY"]
BASE_URL = "https://transcriptapi.com/api/v2"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def get_latest_videos(channel_handle):
    """Get latest videos from a channel (free, 0 credits)."""
    response = requests.get(
        f"{BASE_URL}/youtube/channel/latest",
        params={"channel": channel_handle},
        headers=HEADERS
    )
    response.raise_for_status()
    return response.json()["videos"]

channels = ["@mkbhd", "@ThePrimeagen", "@hubaboratechstuff"]
for channel in channels:
    videos = get_latest_videos(channel)
    print(f"{channel}: {len(videos)} recent videos")
    for v in videos[:3]:
        print(f"  - {v['title']} ({v['published']})")

The response includes video IDs, titles, publish dates, and view counts. That's enough to decide which videos deserve a full transcript pull.

For a deeper understanding of the channel endpoints used here, see our channel videos API guide.

Filter before you spend credits

Not every video needs a transcript. You can filter by publish date (only videos from the last 24 hours), view count (skip videos under a threshold), or title keywords.

This keeps your credit usage low. I've seen monitoring setups that track 15 channels and spend fewer than 100 credits per month.

Step 2: pull transcripts for new videos only

The trick is tracking which videos you've already processed. Here's a simple approach using a local JSON file.

import json
from pathlib import Path

MEMORY_FILE = Path("processed_videos.json")

def load_processed():
    if MEMORY_FILE.exists():
        return set(json.loads(MEMORY_FILE.read_text()))
    return set()

def save_processed(video_ids):
    MEMORY_FILE.write_text(json.dumps(list(video_ids)))

def get_transcript(video_id):
    """Pull full transcript for a video (1 credit)."""
    response = requests.get(
        f"{BASE_URL}/youtube/transcript",
        params={"video_url": video_id, "format": "text"},
        headers=HEADERS
    )
    if response.status_code == 404:
        return None  # No captions available
    response.raise_for_status()
    return response.json()

def process_new_videos(channels):
    processed = load_processed()
    new_transcripts = []

    for channel in channels:
        videos = get_latest_videos(channel)
        for video in videos:
            vid = video["videoId"]
            if vid not in processed:
                transcript = get_transcript(vid)
                if transcript:
                    transcript["channel"] = channel
                    transcript["title"] = video["title"]
                    new_transcripts.append(transcript)
                    processed.add(vid)

    save_processed(processed)
    return new_transcripts

This file-based memory works fine for a single script. But what happens when your server restarts? Or when you want two agents sharing state?

Agent platforms solve this with persistent memory across runs. No file management. No worrying about state surviving a server restart.

Step 3: analyze transcripts with an LLM

Now feed the transcripts to an LLM and ask for structured output. The prompt is where you control what the agent pays attention to.

The LLM analysis step follows a similar pattern to our video summarizer API tutorial.

from openai import OpenAI

client = OpenAI()

def analyze_transcripts(transcripts):
    if not transcripts:
        return "No new videos found across monitored channels."

    context = ""
    for t in transcripts:
        title = t.get("title", "Unknown")
        channel = t.get("channel", "Unknown")
        text = t.get("transcript", "")
        if isinstance(text, list):
            text = " ".join(seg["text"] for seg in text)
        context += f"\n\n--- {title} (by {channel}) ---\n{text[:3000]}"

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": """Analyze these YouTube transcripts and produce a report:
1. Key topics covered (with which video each came from)
2. Notable announcements or claims
3. Products and tools mentioned
4. Content format observations (what's working?)
5. Recommended action items for our team

Be specific. Use bullet points. No filler."""
        }, {
            "role": "user",
            "content": f"Analyze these {len(transcripts)} new videos:\n{context}"
        }]
    )
    return response.choices[0].message.content

Customize the prompt for your use case

The default prompt above works for competitor tracking. But you can tune it for anything.

For trend detection, ask the LLM to compare this week's topics against a list of last week's topics. For content repurposing, ask it to extract key quotes, create a blog outline, and draft three social posts. For client reporting, ask it to format the output as a branded summary with your agency's tone.

The transcript is the raw material. The prompt shapes it into whatever you need.

Step 4: deliver reports to Slack

The last step is getting the report to the people who need it.

def send_to_slack(report, webhook_url):
    requests.post(webhook_url, json={
        "text": f"*YouTube Monitor -- Daily Report*\n\n{report}"
    })

# Run the full pipeline
channels = ["@mkbhd", "@ThePrimeagen", "@hubaboratechstuff"]
transcripts = process_new_videos(channels)
report = analyze_transcripts(transcripts)
send_to_slack(report, os.environ["SLACK_WEBHOOK_URL"])

That's the entire pipeline in about 80 lines of Python. Run it once to test. Then make it run itself.

Making it run on autopilot: cron vs. agent platform

A script that runs once is a tool. A script that runs every morning at 8 AM is an agent. Here are two ways to get there.

Option A: cron job on a VPS

# Run every day at 8 AM UTC
0 8 * * * cd /home/deploy/yt-monitor && python3 monitor.py >> monitor.log 2>&1

Simple. Cheap. Works until it doesn't. You're responsible for:

• Keeping the server running

• Handling crashes (if the script fails at 3 AM, nobody notices until Monday)

• Managing state (that JSON file needs to persist through deploys and restarts)

• Updating the workflow (SSH into the server, edit code, pray nothing breaks)

For a personal side project? Totally fine.

For a team that depends on the reports? Frustrating.

Option B: deploy on CRHQ

CRHQ is an agent orchestration platform. Instead of managing cron jobs and VPS instances, you define your monitoring workflow as an agent skill. The platform handles the rest.

What you get out of the box:

• Scheduling. Set daily, hourly, or custom cron expressions from a dashboard.

• Persistent memory. The agent tracks processed videos without you writing storage code.

• Error recovery. Failed API calls get retried automatically.

• Slack delivery. Built-in, no webhook setup.

• Multi-agent handoff. Your monitoring agent can pass transcripts to a content-writing agent or a deeper research agent.

The tradeoff is clear. Cron gives you full control. A managed platform gives you reliability without ops work.

What it costs to monitor 10 channels

Let's do the math on TranscriptAPI credits.

Checking channels for new uploads is always free. You only spend credits when you pull a transcript. So the cost depends on how many new videos your channels post.

A typical setup: 10 channels, each posting about 2 videos per week. That's 20 transcripts per week, 80 per month. At the $5/month plan (1,000 credits), you're using 8% of your allocation.

Even aggressive monitoring of 25 channels with 5 uploads per week each totals 500 credits per month. Still under the monthly plan limit.

Have you ever tracked how many videos your monitored channels actually post per week? The number is usually lower than you think.

How to automate youtube channel monitoring in 7 steps

Here's the fastest path from zero to working agent:

1. Sign up for TranscriptAPI at transcriptapi.com. You get 100 free credits, no card needed.

2. Pick 3-5 channels to monitor. Start small. Competitors, thought leaders, or your own channel.

3. Copy the Python code from this guide into a single monitor.py file. Set your API keys as environment variables.

4. Run it once manually. Verify you get transcripts and a report.

5. Customize the LLM prompt for your specific needs. The prompt controls the output.

6. Deploy it. Either set up a cron job or create an agent on CRHQ.

7. Add more channels over time. Start with the ones that matter most and expand as you trust the system.

The whole thing takes 20-30 minutes. Most of that is deciding which channels to track and tuning your analysis prompt.

Going further: RAG pipelines and MCP servers

Once you're pulling transcripts on a schedule, you've built a data pipeline. What you do with that data is up to you.

Some teams feed transcripts into a RAG pipeline so they can ask questions across months of video content. "What did our competitors say about pricing in Q1?" becomes a searchable query instead of a memory exercise.

Others connect their agents to YouTube data through an MCP server, which lets tools like Claude access transcripts directly. If you're curious about that setup, there's a full walkthrough on connecting a YouTube MCP server to Claude.

The monitoring agent is the starting point. The transcript data it collects becomes the foundation for whatever analysis you need next.

Conclusion

You can automate YouTube channel monitoring with a Python script, TranscriptAPI, and an LLM. The whole workflow replaces hours of manual work. Build it in 30 minutes and save time every week.

The code in this guide works as-is. Copy it, run it, and customize the prompt for your situation.

What's the first channel your agent will start watching?