# YouTube Channel Monitor (`arched_friend/youtube-channel-monitor`) Actor

Track every new video from any list of YouTube channels. Title, link, description, thumbnail, view count and publish date, from handles or channel URLs, with no API key and no quota.

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

## Pricing

$3.00 / 1,000 video founds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Monitor: Every New Video From Every Channel You Watch

**Know what your competitors, your creators and your category published, without opening YouTube.**

Watching a list of channels by hand does not survive contact with a busy week. Subscriptions get buried, the algorithm reorders everything, and the video you needed to see is three weeks old by the time you find it.

Give this a list of channels and get every video they published, newest first, with the title, link, full description, thumbnail, view count and rating.

Built for marketers tracking competitor content, brands running creator partnerships, media teams watching a category, and anyone who reports on what a set of channels is putting out.

### How it works

```mermaid
flowchart LR
    A[Handles, URLs<br/>or channel ids] --> B{Already a<br/>channel id?}
    B -->|yes| D[Read the channel feed]
    B -->|no| C[Resolve the handle<br/>to a channel id]
    C --> D
    D --> E[Filter by date,<br/>keywords and views]
    E --> F{New since<br/>the last run?}
    F --> G[(Your video feed)]
```

No API key and no quota. YouTube publishes a feed for every channel, and that is what this reads.

### What you get

One row per video. A real row from a live run:

```json
{
  "channel": "Marques Brownlee",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "channelUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
  "videoId": "mfmdXPT7nAM",
  "title": "I Said Yes to Every Email for a Month! (Again)",
  "url": "https://www.youtube.com/watch?v=mfmdXPT7nAM",
  "publishedAt": "2026-08-21T18:53:07.000Z",
  "views": 4592739,
  "ratingCount": 104629,
  "ratingAverage": 5,
  "thumbnail": "https://i2.ytimg.com/vi/mfmdXPT7nAM/hqdefault.jpg",
  "descriptionExcerpt": "Sometimes the inbox wins."
}
```

View counts and ratings are included, so you can sort a week of competitor uploads by what actually landed rather than by what was posted.

### Paste whatever you have

Handles, full URLs, old vanity URLs and raw channel ids all work:

```json
{
  "channels": [
    "@mkbhd",
    "https://www.youtube.com/@veritasium",
    "https://www.youtube.com/c/mkbhd",
    "UCsBjURrPoezykLs9EqgamOA"
  ],
  "days": 7,
  "onlyNewVideos": true
}
```

A channel page names several channel ids, including the recommended channels in its sidebar. The Actor reads the canonical one, so a handle never resolves to somebody else's channel.

### Running it as an alert feed

Turn on `onlyNewVideos` and schedule it. The Actor remembers what it has reported, so each run returns only what is new and the dataset becomes an inbox rather than a growing pile. Add `keywords` to watch for a topic instead of a whole channel.

### Run it from the command line

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~youtube-channel-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "channels": ["@mkbhd", "@veritasium"],
    "days": 30
  }'
```

### Pricing

$0.003 per video returned. A channel that published nothing in the window costs nothing.

| | This Actor | YouTube Data API | Social listening SaaS |
| --- | --- | --- | --- |
| 30 channels, daily | about $2 a month | Free until the quota, then blocked | $99 to $500 a month |
| API key needed | No | Yes, plus a Google Cloud project | No |
| Daily quota | None | 10,000 units, spent fast | Their limits |
| View counts | Yes | Yes | Usually |
| Data you own | Dataset, API, webhook | Yours to store | Their dashboard |

### Notes and limits

- YouTube publishes the **15 most recent videos** per channel in its feed. A long lookback returns whatever those 15 cover, so for daily or weekly monitoring it is plenty and for deep archive work it is not.
- A brand new upload sometimes has no view count yet. That comes through as `null` rather than `0`, and a minimum views filter never hides it.
- Live streams and shorts appear in the feed like any other video.
- Channels that are deleted, renamed to a handle that no longer exists, or region blocked are reported in the run summary under `channelsNotResolved` with the reason, rather than failing the run.

### Related products

- **Competitor Content Tracker** for the blog posts those same companies publish.
- **Hacker News Brand Monitor** for where your product gets discussed.
- **App Store Review Tracker** for what users say inside your app.

# Actor input Schema

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

The channels to watch, one per line. A handle such as @mkbhd, a channel URL, or a raw channel id all work. Handles are resolved to a channel id automatically.

## `days` (type: `integer`):

Only return videos published in this window. Set it to match your schedule, so a daily run looks back one or two days.

## `keywords` (type: `array`):

Optional filter. Keep only videos whose title or description mentions one of these terms, which is how you watch for a topic rather than a whole channel.

## `minViews` (type: `integer`):

Only keep videos with at least this many views. A video too new to have a published view count is always kept, since that is usually the one you want to see.

## `onlyNewVideos` (type: `boolean`):

Remember what has already been reported and return only videos that are new. Turn this on for a scheduled run so the dataset works as an alert feed.

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

Caps how many videos to keep from each channel, newest first. YouTube publishes the 15 most recent per channel, so 15 is the ceiling.

## `timeoutSeconds` (type: `integer`):

How long to wait for each request before retrying it.

## Actor input object example

```json
{
  "channels": [
    "@mkbhd",
    "@veritasium"
  ],
  "days": 30,
  "minViews": 0,
  "onlyNewVideos": false,
  "maxVideosPerChannel": 15,
  "timeoutSeconds": 20
}
```

# Actor output Schema

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

One row per video, newest first, with the title, link, description, thumbnail, view count and rating.

## `runSummary` (type: `string`):

Video counts per channel, the most viewed and newest videos of the run, and any channel that could not be resolved.

# 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": [
        "@mkbhd",
        "@veritasium"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/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": [
        "@mkbhd",
        "@veritasium",
    ] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/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/9PrgCHhfA0JNdVj8c/builds/41jynVb0SFOYJi6Jq/openapi.json