YouTube Channel Scraper — New Video Alerts avatar

YouTube Channel Scraper — New Video Alerts

Pricing

from $3.50 / 1,000 videos

Go to Apify Store
YouTube Channel Scraper — New Video Alerts

YouTube Channel Scraper — New Video Alerts

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.

Pricing

from $3.50 / 1,000 videos

Rating

0.0

(0)

Developer

Magnova

Magnova

Maintained by Community

Actor stats

0

Bookmarked

1

Total users

0

Monthly active users

9 hours ago

Last modified

Features

Limited permissionsMulti-tenantServer interface

Share

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)

{
"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.

FieldWhat it isOn at least
videoIdThe video's stable YouTube ID100% of records
videoTitleThe video's title, exactly as published98%
videoUrlThe watch page URL100%
publishedAtPublish moment (ISO-8601, from the feed)98%
updatedAtLast feed-entry update (a title/description edit moves it)98%
channelIdThe channel's stable ID (UC…)100%
channelNameThe channel's name as published98%
channelUrlThe channel's public page100%
thumbnailUrlThe video's thumbnail image URL95%
viewCountViews as the feed reported them at read time95%
descriptionSnippetThe description's opening (up to 1,000 chars), scrubbed80%
isShorttrue for a Short, false for a long-form video — checked live against YouTube's /shorts/ endpoint95%
sourceAlways youtube100%

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.