# YouTube Channel Scraper — New Video Alerts (`magnova/youtube-channel-scraper`) Actor

Follow any YouTube channel: video ID, title, watch link, publish date, view count, thumbnail, a Shorts flag and a description snippet from YouTube's official channel RSS feeds. First run delivers the latest videos; monitoring mode delivers only new uploads. $0.005 per video, no start fee.

- **URL**: https://apify.com/magnova/youtube-channel-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Videos, For creators, Automation
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Channel Scraper — New Video Alerts

**Track any YouTube channel and get its new uploads as clean, structured data — the first run hands you the channel's latest videos, and every run after that can deliver only the NEW ones.**

YouTube has no channel watchlist API for the public, no new-upload alerts you can pipe into a workflow, and the official Data API makes you register an app and manage quota just to learn that a channel posted a video. This Actor reads YouTube's **official per-channel RSS upload feeds** — the feeds YouTube itself publishes for feed readers, keyless and logged out — and returns one structured record per video: its ID, title, watch link, publish timestamp, the channel's ID and name, a thumbnail, the view count at read time and a scrubbed description snippet. In monitoring mode it remembers what it has already delivered, so scheduled runs hand you only new uploads.

The feeds mix **Shorts and long-form videos** together with no marker — so every delivered record carries an **`isShort`** flag, checked live against YouTube's own `/shorts/` endpoint, and the **`excludeShorts`** option drops Shorts entirely if you only want long-form.

**$0.005 per video delivered. No start fee. You never pay for duplicates, already-delivered videos, or videos your cursor filtered out.**

### Sample record (real record, Marques Brownlee channel feed, 2026-11-15)

```json
{
  "recordType": "VIDEO",
  "videoId": "hdMszZ2ah5Q",
  "videoTitle": "Macbook PROLED Review: It's Not About That",
  "videoUrl": "https://www.youtube.com/watch?v=hdMszZ2ah5Q",
  "publishedAt": "2026-11-11T18:43:56+00:00",
  "updatedAt": "2026-11-14T05:16:35+00:00",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelName": "Marques Brownlee",
  "channelUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
  "thumbnailUrl": "https://i1.ytimg.com/vi/hdMszZ2ah5Q/hqdefault.jpg",
  "descriptionSnippet": "Incredible laptop. But don't get distracted. Protect and make your MacBook unique with dbrand at https://dbrand.com/shop/macbook MKBHD Merch: http://shop.MKBHD.com Playlist of MKBHD Intro music: https://goo.gl/B3AWV5 Laptop provided by Apple for review. ~",
  "viewCount": 5698100,
  "isShort": false,
  "source": "youtube"
}
```

### What you can watch

Give the Actor channels in whichever form you have them — mix forms freely in one run (up to 25 channels):

- **Channel IDs** — the `UC…` string from the channel page URL: `UCBJycsmduvYEL83R_U4JriQ`.
- **@handles** — e.g. `@mkbhd`, `@veritasium`. Handles are resolved to channel IDs inside the run, from the channel's own public page.
- **Channel page URLs** — `https://www.youtube.com/@mkbhd` or `https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ`.
- **Uploads-playlist IDs** — the `UU…` playlist every channel has (its ID is the channel ID with `UC` swapped for `UU`).

A channel whose feed cannot be read — a typo'd ID, a deleted channel — produces one ERROR record naming that channel and never stops the run or the other channels. A channel's feed holds its **~15 latest uploads**; that is the whole corpus the feed offers, and it is exactly the window a new-upload watch needs.

### Monitoring mode — only-new delivery

1. Pick (or create) one of your own key-value stores in the **Monitor state store** input.
2. First run with **`monitorOnlyNew` on**: the channels' current videos are recorded silently as the baseline — you are **not charged** for them. (Leave it off and the first run delivers the full corpus instead, charged per video.)
3. Schedule the run (hourly or daily). Every later run delivers — and charges — **only videos that were not in the baseline**, and remembers them.

Without a store, every run is a fresh corpus pull. Videos are recognised by their stable YouTube video ID, so the same video reached through both a channel ID and its @handle is delivered once per run, and never again on later runs once a store has seen it.

**Stateless alternative — the `publishedSince` cursor.** If your workflow tool (Make, Zapier, n8n) would rather hold its own place, pass a `publishedSince` timestamp: only videos published strictly after it are delivered. Advance the cursor to the newest `publishedAt` after each run and you have only-new delivery with no state store at all. (One interplay to know: when a monitor store *is* selected, the Actor remembers every video it processed, including cursor-filtered ones — so moving the cursor backwards later will not re-deliver them.)

### Fields you get

Population rates below were measured on a 135-video launch census across 9 channels (tech, science, news, cooking, gaming, talks, space, music, entertainment) on 2026-11-14 — the claims-vs-data discipline every Magnova listing follows.

| Field | What it is | On at least |
|---|---|---|
| `videoId` | The video's stable YouTube ID | 100% of records |
| `videoTitle` | The video's title, exactly as published | 98% |
| `videoUrl` | The watch page URL | 100% |
| `publishedAt` | Publish moment (ISO-8601, from the feed) | 98% |
| `updatedAt` | Last feed-entry update (a title/description edit moves it) | 98% |
| `channelId` | The channel's stable ID (`UC…`) | 100% |
| `channelName` | The channel's name as published | 98% |
| `channelUrl` | The channel's public page | 100% |
| `thumbnailUrl` | The video's thumbnail image URL | 95% |
| `viewCount` | Views as the feed reported them at read time | 95% |
| `descriptionSnippet` | The description's opening (up to 1,000 chars), scrubbed | 80% |
| `isShort` | `true` for a Short, `false` for a long-form video — checked live against YouTube's `/shorts/` endpoint | 95% |
| `source` | Always `youtube` | 100% |

One honest absence: the feed publishes **no like count**, so this Actor ships none. What the feed doesn't carry is never promised.

**Shorts, specifically:** the feed gives no hint which uploads are Shorts, so the flag is earned per video at delivery time — YouTube's own `/shorts/<id>` page answers for a Short and redirects to the watch page for a long-form video. On the 2026-11-15 verification run (Marques Brownlee + BBC News, 30 videos) every check was conclusive and every flag matched an independent re-check: 7 Shorts, 23 long-form. On the rare video where the check is inconclusive, the record ships *without* the flag rather than with a guess — the SUMMARY record counts those as `shortsUndetermined`. Turn on **`excludeShorts`** and Shorts are filtered out before delivery: never delivered, never charged, and remembered by the monitor store like cursor-filtered videos (so switching the option off later doesn't dump old Shorts into your dataset).

### Pricing — $0.005 per video

- **$5.00 per 1,000 videos** delivered (SILVER plans $4.25, GOLD and above $3.50). No start fee, no monthly minimum.
- Worked example: watch 10 channels on a daily schedule. The seed-day corpus is 10 × ~15 videos = ~150 videos = **$0.75 once** — and with `monitorOnlyNew` the seed is free. A typical channel posts 2–4 videos a week, so afterwards you see roughly 5 new videos a day: about **$0.75/month**. A quiet day with no new uploads costs $0.00.
- **Not charged:** videos already delivered (duplicates within a run, or remembered by your monitor store), the silently seeded baseline (`monitorOnlyNew` first run), cursor-filtered videos (`publishedSince`), Shorts skipped with `excludeShorts`, ERROR records, and the end-of-run SUMMARY record. Empty runs cost $0.
- Stopping rules built in: `maxResults` caps delivery, `maxTotalChargeUsd` caps this run's charges, and the run stops cleanly at your Apify **maximum total charge** when one is set. Videos a capped run could not deliver stay unseen and are delivered by the next run while they are still in the feed.

### Use it as an API (Server Actor)

This actor also runs as a **server**: send one HTTP request and get the videos back in the response — no run to start, no dataset to poll.

```
POST https://magnova--youtube-channel-scraper.apify.actor
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"channels": ["@mkbhd"], "maxResults": 25}
```

The body takes the same fields as the normal input below. The response is `{"records": [...], "summary": {...}}`. Server mode is a snapshot lookup — the monitor state store stays a scheduled/batch-run feature — and one request returns at most 100 videos. You are charged the same $0.005 per delivered video as a normal run (tiered by your Apify plan), billed to your own Apify account; error rows are never charged.

### Use with AI agents (MCP)

This Actor is agent-ready: it is discoverable and runnable through Apify's MCP server, so an AI assistant can call it directly.

- **Tool:** run Actor `magnova/youtube-channel-scraper` with a JSON input, e.g. `{"channels": ["UCBJycsmduvYEL83R_U4JriQ"], "maxResults": 100}` for a corpus pull, or add `"monitorOnlyNew": true` plus your key-value store id in `"monitorStore"` for a new-uploads watch. Add `"excludeShorts": true` for long-form only; either way each record's `isShort` field lets your agent split Shorts from long-form itself.
- **Output:** one JSON record per video on the default dataset, plus a final `SUMMARY` record with counts (delivered, duplicates skipped, filtered, seeded) — agents can branch on `recordType`.
- **Cost control for agents:** charges accrue per delivered video only; pass `maxResults` (and/or a run-level max charge) to bound spend deterministically.

### YouTube Channel API

Programmatic access is plain Apify: start a run of `magnova/youtube-channel-scraper` from the API, the CLI, or any Apify client, then read the default dataset. Each run ends with a `SUMMARY` record carrying the run's counts, so polling automations can tell "no new videos" apart from "a channel failed" (the latter also writes an `ERROR` row naming the channel, and the monitor state for it is not advanced — the next run catches up).

Compared with snapshot channel scrapers that re-deliver a channel's whole catalogue on every run — and bill you for it every time — this Actor's monitoring mode makes repeat runs cost only what actually changed: nothing on a quiet day, a few cents on a busy one.

### Use cases

- **Competitor and niche tracking** — watch rival channels in your niche; every new upload lands in your dataset or webhook the hour it posts.
- **Content operations** — feed new uploads into an n8n/Make workflow: summarise the description, draft a response brief, post to Slack.
- **Research and archiving** — build a timestamped corpus of what specific channels published and when, with view counts at read time.
- **Newsroom and fandom alerts** — be first to know when a watched channel publishes, without refreshing YouTube.

### FAQ

**How many videos does one run return per channel?** The channel's feed holds its ~15 latest uploads, so a corpus run returns up to ~15 per channel. Monitoring runs return only the new ones since your baseline.

**What counts as "new"?** A video ID the monitor store has never seen (or, with the cursor, a video published after your `publishedSince`). Title edits do not re-deliver a video.

**Can I get long-form videos only, without Shorts?** Yes — turn on `excludeShorts`. Every record also carries an `isShort` flag either way, so you can filter in your own workflow instead if you prefer.

**Do I need a YouTube API key or a Google account?** No. The Actor reads the public RSS feeds YouTube publishes for feed readers — no key, no login, nothing to register.

**Why is there no like count or comment data?** The feed doesn't publish them. This Actor ships only what the official feed carries, and says so.

**Is my monitor store used for anything else?** No. It holds one small state record: the video IDs already seen, a run count and a timestamp. Nothing else is written to it.

**What does a failed channel cost me?** Nothing. ERROR records are never charged, and the failed channel's state is not advanced, so the next run retries it in full.

### A note on sources and data

This Actor reads YouTube's official, public RSS upload feeds — the same feeds any feed reader uses — logged out, with no API key, no login and no CAPTCHA bypass. Whether a video is a Short is checked against YouTube's own public `/shorts/` pages, also logged out. Records carry a video's public facts as published; creator descriptions are scrubbed before delivery, so emails, phone numbers and social-profile links a creator typed into a description never appear in the output. No contact data, no commenter data, no enrichment — monitoring and alerting only.

# Actor input Schema

## `channels` (type: `array`):

YouTube channels to read, one entry each: a channel id (e.g. "UCBJycsmduvYEL83R_U4JriQ" — the UC… part of the channel page URL), an @handle (e.g. "@mkbhd"), a full channel page URL ("https://www.youtube.com/@mkbhd" or "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ"), or an uploads-playlist id (UU…). Each channel's official RSS upload feed is read; its ~15 latest videos are the channel's corpus. Handles are resolved to channel ids inside the run; an entry that cannot be read produces an ERROR record and never stops the other channels.

## `excludeShorts` (type: `boolean`):

On: Shorts are not delivered (and never charged) — only long-form videos ship. Each video is checked against YouTube's own /shorts/ endpoint at delivery time; a video whose format cannot be determined is delivered rather than dropped. Skipped Shorts are remembered by the monitor store like cursor-filtered videos, so turning this off later does not re-deliver them. Off (default): every video is delivered, with an "isShort" true/false field on each record so your own workflow can filter.

## `maxResults` (type: `integer`):

Hard cap on videos delivered (and charged) in one run, across all channels in the run. Videos a capped run could not deliver stay unseen in monitoring mode and are delivered by the next run if they are still in the feed.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged videos reach this amount (checked conservatively at the highest per-video price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new videos stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the channels' current videos as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current videos without delivering or charging anything, and only videos published afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which videos it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the channels' current videos as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every video it processed (including cursor-filtered ones), so moving your cursor earlier later does not re-deliver old videos.

## `publishedSince` (type: `string`):

Optional user-held cursor: only videos published strictly after this moment are delivered (ISO date or datetime, e.g. "2026-11-01" or "2026-11-01T00:00:00Z"). Hold the cursor in your own workflow (Make/Zapier/n8n) and advance it to each run's newest publishedAt for stateless only-new delivery without a monitor store. Filtered-out videos are never charged. Leave empty to deliver the feeds' full contents.

## Actor input object example

```json
{
  "channels": [
    "UCBJycsmduvYEL83R_U4JriQ",
    "@veritasium"
  ],
  "excludeShorts": false,
  "maxResults": 1000,
  "maxTotalChargeUsd": 1,
  "monitorOnlyNew": false,
  "publishedSince": "2026-11-01T00:00:00Z"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "channels": [
        "UCBJycsmduvYEL83R_U4JriQ",
        "UCHnyfMqiRRG1u-2MsSQLbXA",
        "UC16niRr50-MSBwiO3YDb3RA"
    ],
    "excludeShorts": false,
    "maxResults": 100,
    "monitorOnlyNew": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/youtube-channel-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "channels": [
        "UCBJycsmduvYEL83R_U4JriQ",
        "UCHnyfMqiRRG1u-2MsSQLbXA",
        "UC16niRr50-MSBwiO3YDb3RA",
    ],
    "excludeShorts": False,
    "maxResults": 100,
    "monitorOnlyNew": False,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/youtube-channel-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channels": [
    "UCBJycsmduvYEL83R_U4JriQ",
    "UCHnyfMqiRRG1u-2MsSQLbXA",
    "UC16niRr50-MSBwiO3YDb3RA"
  ],
  "excludeShorts": false,
  "maxResults": 100,
  "monitorOnlyNew": false
}' |
apify call magnova/youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/youtube-channel-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5P5GEMKGqhtLfbQV5/builds/FZo8v5Kyq5Cl76gIz/openapi.json
