# YouTube Channel RSS Scraper & New Video Monitor (`groupoject/youtube-channel-monitor`) Actor

Monitor multiple YouTube channels and extract recent or newly published videos from public RSS feeds. Get titles, descriptions, dates, thumbnails, views, and links without a YouTube API key.

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

## Pricing

from $1.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## YouTube Channel RSS Scraper & New Video Monitor

Monitor recent uploads from multiple YouTube channels without a YouTube API key. This Actor resolves channel URLs and `@handles`, reads YouTube's public RSS feeds, and returns clean video records ready for alerts, dashboards, spreadsheets, and automation.

### Why use this Actor?

- **No YouTube API key or quota setup**
- **Monitor up to 1,000 channels in one run**
- **Output only new uploads** across scheduled runs
- **Filter by keywords, excluded terms, and publication age**
- **Fast HTTP-only execution** with no browser overhead
- **Export JSON, CSV, Excel, XML, or RSS** through Apify

### Quick start

```json
{
  "channels": [
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "maxVideosPerChannel": 15,
  "publishedWithinDays": 30
}
````

The dataset contains one row per video with its title, channel, publication and update dates, description, thumbnail, views, rating count, matched keywords, and direct YouTube URL.

### Monitor only new YouTube uploads

Turn on `monitorNewOnly` and choose a stable `stateKey`. The first run returns the current matching uploads and records their video IDs. Later runs using the same key return only videos that were not seen before.

```json
{
  "channels": ["@mkbhd", "@LinusTechTips", "@veritasium"],
  "monitorNewOnly": true,
  "stateKey": "competitor-tech-channels",
  "maxVideosPerChannel": 15
}
```

Schedule that input daily or hourly and connect an Apify webhook to Slack, Make, Zapier, email, Google Sheets, or your own API.

Use a different `stateKey` for each independent monitor. State is kept in a named Apify key-value store so it survives separate Actor runs.

### Filter uploads by topic

Search both video titles and descriptions using `includeKeywords`. A video is kept when at least one include keyword matches. `excludeKeywords` always remove matching videos.

```json
{
  "channels": ["@Google", "@Microsoft", "@OpenAI"],
  "includeKeywords": ["AI", "Gemini", "Copilot", "GPT"],
  "excludeKeywords": ["livestream replay"],
  "publishedWithinDays": 14
}
```

### Input fields

| Field | Description |
| --- | --- |
| `channels` | YouTube channel URLs, `@handles`, or `UC...` channel IDs. |
| `channelsText` | Bulk list with one channel per line. |
| `maxVideosPerChannel` | Recent videos kept per channel, from 1 to 15. |
| `publishedWithinDays` | Keep videos no older than this; `0` disables the filter. |
| `includeKeywords` | Keep videos matching at least one term in title or description. |
| `excludeKeywords` | Remove videos matching any listed term. |
| `monitorNewOnly` | On later runs, output only unseen video IDs. |
| `stateKey` | Stable identifier for this monitor's persistent state. |
| `maxChannels` | Safety cap, up to 1,000 channels per run. |
| `maxConcurrency` | Parallel channel requests, from 1 to 10. |
| `proxyConfiguration` | Optional Apify Proxy settings for large repeated workloads. |

### Output example

```json
{
  "videoId": "WOzcFkld6_g",
  "title": "The Most Interesting Displays In The World!",
  "videoUrl": "https://www.youtube.com/watch?v=WOzcFkld6_g",
  "channelName": "Marques Brownlee",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelUrl": "https://www.youtube.com/@mkbhd",
  "publishedAt": "2026-06-16T18:17:15+00:00",
  "thumbnailUrl": "https://i4.ytimg.com/vi/WOzcFkld6_g/hqdefault.jpg",
  "viewCount": 3100000,
  "ratingCount": 92000,
  "matchedKeywords": [],
  "isNew": true
}
```

### Practical use cases

- Competitor channel upload alerts
- Brand and product mention monitoring
- Creator and influencer watchlists
- Newsroom source monitoring
- YouTube content research
- Podcast and webinar episode tracking
- AI video discovery pipelines

### Limits

YouTube's public channel RSS feed normally exposes the 15 most recent uploads. This Actor is optimized for fast recurring monitoring, not full historical channel scraping. View and rating numbers are snapshots supplied by the RSS feed and may lag behind the YouTube video page.

Use the data responsibly and follow YouTube's terms and applicable privacy and copyright rules.

# 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("groupoject/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("groupoject/youtube-channel-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 groupoject/youtube-channel-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=groupoject/youtube-channel-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel RSS Scraper & New Video Monitor",
        "description": "Monitor multiple YouTube channels and extract recent or newly published videos from public RSS feeds. Get titles, descriptions, dates, thumbnails, views, and links without a YouTube API key.",
        "version": "1.0",
        "x-build-id": "Fy1Iw8CP5KaClZjxy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/groupoject~youtube-channel-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-groupoject-youtube-channel-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/groupoject~youtube-channel-monitor/runs": {
            "post": {
                "operationId": "runs-sync-groupoject-youtube-channel-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/groupoject~youtube-channel-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-groupoject-youtube-channel-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "channels": {
                        "title": "YouTube channels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Channel URLs, @handles, or channel IDs to monitor.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelsText": {
                        "title": "Bulk channel list",
                        "type": "string",
                        "description": "Paste one channel URL, @handle, or UC... channel ID per line."
                    },
                    "maxVideosPerChannel": {
                        "title": "Max videos per channel",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Maximum recent uploads returned per channel. YouTube RSS normally exposes up to 15.",
                        "default": 15
                    },
                    "publishedWithinDays": {
                        "title": "Published within (days)",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Keep videos published within this many days. Leave 0 to include every upload exposed by the feed.",
                        "default": 0
                    },
                    "includeKeywords": {
                        "title": "Include keywords",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Keep videos whose title or description contains at least one keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Remove videos whose title or description contains any keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "monitorNewOnly": {
                        "title": "Only output new uploads",
                        "type": "boolean",
                        "description": "Remember previously seen video IDs in a named store and output only new uploads on later runs. The first run returns current matching videos.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "Monitor state key",
                        "type": "string",
                        "description": "Use a stable unique key for each scheduled monitor, for example competitor-tech-channels.",
                        "default": "default"
                    },
                    "maxChannels": {
                        "title": "Max channels",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety limit for channels processed in one run.",
                        "default": 100
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between YouTube requests.",
                        "default": 250
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel channel requests.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional for large or frequent runs."
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Show detailed request and filtering logs.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
