# YouTube New Upload Monitor - New Video Alerts (`seemuapps/youtube-new-upload-monitor`) Actor

Monitor YouTube channels for new uploads, Shorts and live streams. Each scheduled run outputs only videos new since the last run, with views and duration.

- **URL**: https://apify.com/seemuapps/youtube-new-upload-monitor.md
- **Developed by:** [Seemu Scraping](https://apify.com/seemuapps) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 new 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?

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 New Upload Monitor - New Video Alerts

Get notified about every new video, Short and live stream from the YouTube channels you care about. Add a list of channels, put the actor on a schedule, and each run returns **only the uploads that are new since the previous run** - with title, publish time, views, likes, duration, description, thumbnail and whether it is a Short or a live stream. No login, no cookies, no YouTube API quota.

Use it as a YouTube upload alert, a competitor video tracker, or the trigger for a Slack, email, Zapier, Make or n8n workflow.

### What you get

One row per new video:

- **videoId**, **url**, **title**, **description**, **thumbnailUrl**
- **publishedAt** and **updatedAt** (exact timestamps)
- **views** and **likes**
- **durationSeconds** and **category**
- **isShort** - true for YouTube Shorts
- **isLiveStream**, **liveStatus** (`none`, `upcoming`, `live`, `ended`, `premiere`) and **liveStartedAt**
- **channelId**, **channelTitle**, **channelUrl** and the **sourceInput** you entered
- **detectedAt** - when the monitor first spotted the video

### Use cases

- **New video alerts** - be first to react, comment or share when a creator posts
- **Competitor monitoring** - track every upload from rival brands and channels in your niche
- **Influencer and sponsorship tracking** - log every video a creator you work with publishes
- **Content curation and newsletters** - collect fresh videos from a list of channels each day
- **Automation triggers** - start transcription, summarization or social posting workflows the moment a video goes live
- **Shorts and live stream tracking** - follow only Shorts, only long-form, or include live streams

### How to use

1. Enter your **Channels** - one per line. Any of these work: `@mkbhd`, `https://www.youtube.com/@veritasium`, `https://www.youtube.com/channel/UC...`, `https://www.youtube.com/user/...` or a bare `UC...` channel ID.
2. Choose what happens the **First check of a channel**:
   - **Baseline** (default) - the actor remembers the channel's current videos and outputs nothing, so you only get alerted about uploads published afterwards.
   - **Output the latest videos right away** - returns the channel's most recent uploads (up to 15) on the first run, then only new ones after that.
3. Turn **Include Shorts** and **Include live streams** on or off.
4. Run once, then open **Schedules** in Apify Console and run it every 15 minutes, hourly or daily. Each scheduled run outputs only the videos that appeared since the last one.
5. Connect an integration (Slack, email, webhook, Zapier, Make, n8n, Google Sheets) to the run to get the new videos delivered wherever you work.

You can add or remove channels at any time. A newly added channel follows your **First check** setting; channels you already monitor keep their history.

#### How the monitor remembers what it has seen

Videos already reported are stored in a named key-value store (**State store name**, default `youtube-new-upload-monitor-state`) that persists between runs. To run several independent monitors - for example one per client or one per schedule - give each a different **State store name**. To start over and get alerted about a channel's current videos again, delete that store (or the channel's `channel-UC...` record in it) from the **Storage** section of Apify Console.

### Output format

```json
{
  "videoId": "RE3_PGwDwhw",
  "url": "https://www.youtube.com/watch?v=RE3_PGwDwhw",
  "title": "Lose 150 Lbs Together, Win $250,000",
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "channelTitle": "MrBeast",
  "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
  "publishedAt": "2026-10-17T16:00:18.000Z",
  "updatedAt": "2026-10-21T22:14:36.000Z",
  "description": "Will this couple be able to lose 150 LBS together by the end?...",
  "thumbnailUrl": "https://i.ytimg.com/vi/RE3_PGwDwhw/hqdefault.jpg",
  "views": 118067952,
  "likes": 1744519,
  "durationSeconds": 2596,
  "isShort": false,
  "isLiveStream": false,
  "liveStatus": "none",
  "liveStartedAt": null,
  "category": "Entertainment",
  "sourceInput": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "detectedAt": "2026-10-21T22:23:15.594Z"
}
```

Export the dataset as JSON, CSV, Excel or HTML, or pull it straight into Google Sheets.

### Good to know

- Each run checks the **15 most recent uploads** of every channel, so schedule the monitor often enough that a channel never posts more than 15 videos between two runs.
- A live stream is reported once, when it is first detected - check **liveStatus** to see whether it was `upcoming`, `live` or already `ended` at that moment.
- Videos that were private or scheduled and later made public are reported when they appear in the channel's uploads.
- **durationSeconds** is empty for live streams that have not ended yet.
- Free plan runs report up to 50 new videos per run; any remaining new videos are picked up on the next run.

### Pricing

You pay per new video found. Runs where nothing new was uploaded cost only a tiny amount of platform usage, which makes frequent schedules cheap.

# Actor input Schema

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

YouTube channels to watch, one per line: channel URLs, @handles or UC... channel IDs.

## `firstRunBehavior` (type: `string`):

What to do the first time a channel is checked. Baseline remembers its current videos so that only uploads published after this run are reported. Output the latest videos returns up to 15 of the channel's most recent uploads immediately.

## `includeShorts` (type: `boolean`):

Report new YouTube Shorts as well as regular videos.

## `includeLiveStreams` (type: `boolean`):

Report new live streams (scheduled, live now or ended). Turn off to only get regular uploads and Shorts.

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

Only the newest N uploads of each channel are checked on each run (up to 15).

## `stateStoreName` (type: `string`):

Name of the key-value store that remembers which videos were already reported, so each scheduled run only outputs new uploads. Use a different name for each independent monitor (e.g. one per schedule or client). Letters, digits and hyphens only.

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

Optional. Leave off by default. Enable Apify Proxy only if YouTube starts blocking requests from the default network.

## Actor input object example

```json
{
  "channels": [
    "@mkbhd",
    "@veritasium"
  ],
  "firstRunBehavior": "baseline",
  "includeShorts": true,
  "includeLiveStreams": true,
  "maxVideosPerChannel": 15,
  "stateStoreName": "youtube-new-upload-monitor-state",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One record per new upload: videoId, url, title, channelId, channelTitle, channelUrl, publishedAt, updatedAt, description, thumbnailUrl, views, likes, durationSeconds, isShort, isLiveStream, liveStatus, liveStartedAt, category, sourceInput, detectedAt.

# 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("seemuapps/youtube-new-upload-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("seemuapps/youtube-new-upload-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 seemuapps/youtube-new-upload-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,seemuapps/youtube-new-upload-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/xzQTb3LUsBTBNpMMT/builds/47cY60DxET4gkMDUh/openapi.json