# YouTube Channel Monitor - New Video Alerts, No API Key (`sonic_scraper/youtube-channel-monitor`) Actor

YouTube channel monitor for new uploads. Track up to 1,000 channels, filter by keyword or date, and get only new videos on each scheduled run: titles, dates, views, thumbnails, links. No YouTube API key or quota. $2 per 1,000 videos.

- **URL**: https://apify.com/sonic_scraper/youtube-channel-monitor.md
- **Developed by:** [Group Oject](https://apify.com/sonic_scraper) (community)
- **Categories:** Videos, Social media, Automation
- **Features:** Limited permissions
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 results

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 Monitor - New Video Alerts, No API Key

Track any list of YouTube channels and get a clean dataset of their latest uploads. Schedule it, turn on **new-only mode**, and each run returns only the videos you have not seen before. No YouTube Data API key, no quota, no login.

![YouTube Channel Monitor output in Apify: video, channel, published, views, ratings, new, keyword matches](https://api.apify.com/v2/key-value-stores/lwQu1lCMCLQIIhSMQ/records/youtube-channel-monitor-output.png)

*Real output from a default run of YouTube Channel Monitor in Apify Console.*

### What can YouTube Channel Monitor do?

- **Monitor many channels in one run**: paste channel URLs, `@handles`, or `UC...` channel IDs (up to 1,000 per run).
- **Return only new uploads** on scheduled runs. The Actor remembers which videos it already delivered under a `stateKey` you choose.
- **Filter by topic**: keep videos whose title or description contains your keywords, and drop videos containing excluded words.
- **Filter by date**: keep only uploads from the last N days.
- **Get video stats from the feed**: views, rating count and rating average where YouTube exposes them.
- **Run on a schedule** and send new rows anywhere: webhooks, Slack, Google Sheets, Make, Zapier, n8n, or your own API client.

Typical uses: competitor content tracking, newsroom and analyst source watchlists, creator and sponsorship research, AI pipelines that need to know when a channel posts, and "alert me when X uploads" automations.

### What data does it extract?

One dataset row per video.

| Field | Description |
|---|---|
| `videoId`, `videoUrl` | YouTube video ID and watch URL |
| `title`, `description` | Video title and description from the channel feed |
| `channelName`, `channelId`, `channelUrl` | Channel the video belongs to |
| `publishedAt`, `updatedAt` | Upload time and last feed update (ISO 8601) |
| `thumbnailUrl` | Video thumbnail |
| `viewCount` | View count reported in the feed |
| `ratingCount`, `ratingAverage` | Rating data reported in the feed, when available |
| `matchedKeywords` | Which of your `includeKeywords` matched |
| `isNew` | `true` when the video was not delivered before under this `stateKey` |
| `sourceInput`, `feedUrl`, `scrapedAt` | Which input produced the row, the feed used, and when |

### How much does it cost to monitor YouTube channels?

This Actor uses pay-per-event pricing:

- **$2.00 per 1,000 videos** delivered ($0.002 per video)
- **$0.005 per Actor start** (per GB of memory, minimum one)

Example: a daily monitor of 20 channels in new-only mode usually delivers a handful of new videos per day. 30 daily runs with 5 new videos each cost about 30 x $0.005 + 150 x $0.002 = **$0.45 per month**. Runs with no new videos cost only the start fee. Check the Pricing tab for the current rates.

### How to monitor YouTube channels for new videos

1. Open the Actor and paste channel URLs or `@handles` into **Channels** (or one per line into the text box).
2. Optional: add `includeKeywords` (for example `review`, `launch`) or set `publishedWithinDays`.
3. Turn on **Monitor new videos only** and give the monitor a unique `stateKey`, such as `competitor-tech-channels`.
4. Run once. The first run returns the current matching uploads and saves them as seen.
5. Save the input as a task and add a schedule (hourly, daily, weekly). Later runs return only new videos.
6. Connect a webhook or integration to forward new rows to Slack, email, Sheets, or your app.

#### Input example

```json
{
  "channels": [
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium",
    "UCBJycsmduvYEL83R_U4JriQ"
  ],
  "includeKeywords": ["iphone", "review"],
  "excludeKeywords": ["#shorts"],
  "publishedWithinDays": 7,
  "monitorNewOnly": true,
  "stateKey": "tech-reviewers",
  "maxVideosPerChannel": 15
}
```

#### Output example

```json
{
  "videoId": "dQw4w9WgXcQ",
  "title": "iPhone review after one month",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "channelName": "Example Channel",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
  "publishedAt": "2026-10-24T15:00:06+00:00",
  "updatedAt": "2026-10-25T08:12:44+00:00",
  "thumbnailUrl": "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg",
  "description": "My honest thoughts after a month...",
  "viewCount": 1824531,
  "ratingCount": 90210,
  "ratingAverage": 5,
  "matchedKeywords": ["iphone", "review"],
  "isNew": true,
  "sourceInput": "https://www.youtube.com/@mkbhd",
  "feedUrl": "https://www.youtube.com/feeds/videos.xml?channel_id=UCBJycsmduvYEL83R_U4JriQ",
  "scrapedAt": "2026-10-25T09:00:02.114Z"
}
```

### Input reference

| Field | Default | What it does |
|---|---|---|
| `channels` / `channelsText` | - | Channel URLs, `@handles`, or `UC...` IDs |
| `maxVideosPerChannel` | 15 | Latest uploads per channel (YouTube feeds expose up to 15) |
| `publishedWithinDays` | 0 | Keep uploads from the last N days; 0 = no date filter |
| `includeKeywords` / `excludeKeywords` | \[] | Title/description keyword filters |
| `monitorNewOnly` | false | Output only videos not delivered before under `stateKey` |
| `stateKey` | `default` | Name of the monitor's memory; use one per scheduled task |
| `maxChannels` | 100 | Safety cap on channels per run (max 1,000) |
| `maxConcurrency` / `requestDelayMs` | 3 / 250 | Parallelism and politeness delay |
| `proxyConfiguration` | none | Optional Apify Proxy for large or frequent runs |

### Use the YouTube monitor through the API, MCP and integrations

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("sonic_scraper/youtube-channel-monitor").call(run_input={
    "channels": ["https://www.youtube.com/@veritasium"],
    "monitorNewOnly": True,
    "stateKey": "science-channels",
})
for video in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(video["publishedAt"], video["title"], video["videoUrl"])
```

- **Schedules + webhooks**: create a task, schedule it, and add a webhook on `ACTOR.RUN.SUCCEEDED` to push new videos to your endpoint.
- **Make, Zapier, n8n**: use the Apify app/node, run this Actor, then map dataset rows to Slack, Gmail, Notion, or Sheets.
- **AI agents (MCP)**: add `https://mcp.apify.com?tools=sonic_scraper/youtube-channel-monitor` to Claude, Cursor, or any MCP client.

The run also saves a `SUMMARY` record (channels processed, videos delivered, per-channel counts) and an `ERRORS` record with the reason for any channel that failed.

### How it works and where the data comes from

- **Source:** YouTube's public channel feeds, one per channel.
- **How it is collected:** plain HTTP feed requests, with no browser, API key, daily quota or login.
- **What it does not collect:** full channel history. Views and ratings are included only where the feed reports them.
- **Known limits:** at most the latest 15 uploads per channel, which is what YouTube's feed exposes. Up to 1,000 channels per run.
- **How failures are reported:** the `ERRORS` record gives the reason for any channel that failed. The `SUMMARY` record shows per-channel counts.

Maintained by Group Oject. Questions or a broken run? Open an issue on the Issues tab and it gets answered.

### FAQ

**Is there an Apify actor that alerts me when YouTube channels upload new videos, without an API key?** YouTube Channel Monitor (apify.com/sonic_scraper/youtube-channel-monitor) tracks a list of YouTube channels and returns their latest uploads. With new-only mode on, each scheduled run returns only videos not delivered before. It needs no YouTube Data API key, quota or login, and costs $2.00 per 1,000 videos.

**Do I need a YouTube API key?** No. The Actor reads YouTube's public channel feeds, so there is no API key and no daily quota.

**How many videos per channel can it return?** The latest 15 uploads per channel, which is what YouTube's channel feed exposes. For full channel history, use a full channel video scraper instead. This Actor is built for monitoring.

**What does the first new-only run return?** The current matching uploads. They are stored as seen, so the next run returns only videos published after that.

**Can I run several separate monitors?** Yes. Use a different `stateKey` per task, for example `clients-a` and `competitors-b`.

**Does it include Shorts and live streams?** It returns whatever YouTube puts in the channel's upload feed, which normally includes Shorts and finished live streams.

**Is monitoring YouTube channels legal?** The Actor reads only public feed data. You are responsible for how you use it and for following YouTube's terms and applicable law.

### Related Actors

- [YouTube Channel Scraper API](https://apify.com/sonic_scraper/youtube-channel-scraper-api) - subscribers, video counts, emails in bio, avatars, banners
- [YouTube Comments Scraper API](https://apify.com/sonic_scraper/youtube-comments-scraper-api) - comments, likes and reply counts for any video
- [YouTube Scraper API](https://apify.com/sonic_scraper/youtube-scraper-api) - videos from search terms, playlists and video URLs
- [Google News Scraper](https://apify.com/sonic_scraper/google-news-scraper) - track news coverage alongside channel uploads

# Actor input Schema

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

Channel URLs, @handles, or channel IDs to monitor.

## `channelsText` (type: `string`):

Paste one channel URL, @handle, or UC... channel ID per line.

## `maxVideosPerChannel` (type: `integer`):

Maximum recent uploads returned per channel. YouTube RSS normally exposes up to 15.

## `publishedWithinDays` (type: `integer`):

Keep videos published within this many days. Leave 0 to include every upload exposed by the feed.

## `includeKeywords` (type: `array`):

Optional. Keep videos whose title or description contains at least one keyword.

## `excludeKeywords` (type: `array`):

Optional. Remove videos whose title or description contains any keyword.

## `monitorNewOnly` (type: `boolean`):

Remember previously seen video IDs in a named store and output only new uploads on later runs. The first run returns current matching videos.

## `stateKey` (type: `string`):

Use a stable unique key for each scheduled monitor, for example competitor-tech-channels.

## `maxChannels` (type: `integer`):

Safety limit for channels processed in one run.

## `requestDelayMs` (type: `integer`):

Delay between YouTube requests.

## `maxConcurrency` (type: `integer`):

Parallel channel requests.

## `proxyConfiguration` (type: `object`):

Optional for large or frequent runs.

## `debugMode` (type: `boolean`):

Show detailed request and filtering logs.

## Actor input object example

```json
{
  "channels": [
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "maxVideosPerChannel": 15,
  "publishedWithinDays": 0,
  "monitorNewOnly": false,
  "stateKey": "default",
  "maxChannels": 100,
  "requestDelayMs": 250,
  "maxConcurrency": 3,
  "debugMode": false
}
```

# Actor output Schema

## `videos` (type: `string`):

Clean video records from all monitored channels.

## `summary` (type: `string`):

Channel totals, filters, new-video counts, and errors.

## `errors` (type: `string`):

Channels that could not be resolved or fetched.

# 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": [
        "https://www.youtube.com/@mkbhd",
        "https://www.youtube.com/@veritasium"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sonic_scraper/youtube-channel-monitor").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": [
        "https://www.youtube.com/@mkbhd",
        "https://www.youtube.com/@veritasium",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sonic_scraper/youtube-channel-monitor").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": [
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium"
  ]
}' |
apify call sonic_scraper/youtube-channel-monitor --silent --output-dataset

```

## MCP server setup

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

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/8IdQXmmXcIGCiFQzM/builds/bbSDMxMfSaRCU5fbf/openapi.json
