# YouTube Video Scraper (`schnellscrapers/youtube-video-monitor`) Actor

Scrape public YouTube channel videos for titles, views, publish dates, durations, thumbnails, hashtags, and optional descriptions and likes. Filter new uploads by topic, date, or views before billing. No login or YouTube API key required.

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

## Pricing

$1.50 / 1,000 video 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 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

### What does YouTube Video Scraper do?

YouTube Video Scraper monitors the Videos tab of one or more public YouTube channels and returns clean records for new-upload checks, competitor research, SEO audits, and content planning. It reads the channel feed directly, applies topic, date, and view filters before writing results, and optionally fetches exact watch-page metadata for selected videos.

### What data can you extract from YouTube?

- Video identity — video ID, canonical watch URL, title, thumbnail, duration, and source channel URL
- Publishing signals — relative publish text from the feed and exact publish timestamp when details are enabled
- Performance — parsed view count, source view label, and optional like and comment counts
- Topic monitoring — hashtags and the include-topic phrases matched in each returned record
- Channel context — channel ID, name, handle, canonical URL, and subscriber count when exposed
- Detail content — full description and additional hashtags when exact details are enabled

The default feed-only mode is designed for recurring checks. It avoids a watch-page request for every video, so a daily run can look for new uploads without paying for enrichment that the workflow does not need.

### How to use YouTube Video Scraper

1. Open YouTube Video Scraper and click **Try for free**.
2. Add one or more channel handles or URLs, such as `@Apify` or `https://www.youtube.com/@Apify`.
3. Set the per-channel and total video limits. Use `titleKeywords`, `excludeKeywords`, `minViews`, or `publishedAfter` to narrow the run before billing.
4. Leave **Fetch exact video details** off for the lowest-cost channel monitor, or enable it for descriptions, likes, and exact publish timestamps.
5. Click **Run**, then download JSON, CSV, or Excel from the Dataset tab or use the Apify API.

### How much does it cost?

YouTube Video Scraper uses pay-per-event pricing: one billable event is one video record written to the default dataset. The FREE tier price is **$0.0015 per result ($1.50 per 1,000)**. Filtered-out videos and dry-run previews are not written and are not billed as result events. Keep `maxPagesPerChannel` and `maxVideosPerChannel` low for recurring alerts; turn on detail fetching only when the extra fields are needed.

### Input

The required `channels` array accepts handles, usernames, channel IDs, and public channel URLs. `sortBy` uses YouTube's Latest, Popular, or Oldest feed control when that control is present. The `publishedAfter` filter accepts an ISO date or a relative period such as `7 days`.

```json
{
  "channels": ["@Apify", "https://www.youtube.com/@mkbhd"],
  "maxVideosPerChannel": 30,
  "maxPagesPerChannel": 1,
  "titleKeywords": ["scraping", "AI"],
  "excludeKeywords": ["shorts"],
  "minViews": 100,
  "includeVideoDetails": false,
  "dryRun": false
}
```

### Output

Each output row represents one video that survived the configured filters.

```json
{
  "videoId": "4UosK7KTOmE",
  "url": "https://www.youtube.com/watch?v=4UosK7KTOmE",
  "title": "Automate Meta Ad Research with Apify & 12Labs",
  "viewCount": 203,
  "viewCountText": "203 views",
  "publishedText": "8 days ago",
  "publishedAt": null,
  "durationText": "15:59",
  "hashtags": [],
  "matchedKeywords": ["scraping"],
  "channelName": "Apify",
  "detailsFetched": false
}
```

When details are enabled, `description`, `likes`, `publishedAt`, and exact duration and channel fields are populated when YouTube exposes them. Fields unavailable in the source are returned as `null`, never invented.

### Integrations

Use the [Apify API](https://docs.apify.com/api/v2) to trigger runs and read datasets from Python, Node.js, Make, n8n, Zapier, or scheduled workflows. Webhooks can forward a completed monitoring run into a CRM, Slack, or an internal content dashboard.

### Related actors

- [YouTube Shorts Scraper](https://apify.com/schnellscrapers/youtube-shorts-monitor) — monitor the Shorts tab specifically with view, date, and engagement filters.
- [YouTube Transcript Scraper](https://apify.com/karamelo/youtube-transcripts) — extract transcript records when you need spoken text rather than channel-feed metadata.
- [YouTube Channel Scraper](https://apify.com/streamers/youtube-channel-scraper) — collect broader channel and video data at scale.

### FAQ

#### How does YouTube Video Scraper work?

It fetches a public channel's Videos page and parses the structured JSON that YouTube embeds in the page. Pagination and the Latest, Popular, and Oldest controls use the same page-initiated continuation requests the site uses. Detail enrichment is a separate, optional watch-page request.

#### Can I use YouTube Video Scraper as an API?

Yes. Start a run with the [Apify API](https://docs.apify.com/api/v2/actor-runs) and read the default dataset URL returned by the run. The dataset can also be connected to webhooks and schedules in the Apify Console.

#### Can I use YouTube Video Scraper in Python or Node.js?

Yes. Use `apify-client` to run the actor and download dataset items:

```js
const run = await client.actor("YOUR_USERNAME/youtube-video-monitor").call({ channels: ["@Apify"] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Does it require a YouTube login or API key?

No login, cookies, or YouTube Data API key are required for the public channel and watch-page paths used by this actor. The actor does not download video or audio bytes.

#### Is it legal to scrape YouTube with YouTube Video Scraper?

The actor reads public YouTube pages. You are responsible for your use of the output and for complying with applicable laws, platform rules, and the terms that apply to your account and workflow.

#### Can it monitor new videos automatically?

Yes. Schedule recurring runs in Apify, keep the feed page budget small, and use `publishedAfter` or topic filters to make each run a focused upload check.

### Your feedback

If YouTube changes its embedded page structure or you need another filter, open an issue on the actor page with a reproducible input. Suggestions for channel-level fields, output aliases, and monitoring workflows are welcome.

# Actor input Schema

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

One or more public channel handles, usernames, channel IDs, or channel URLs. Examples: `@Apify`, `Apify`, or `https://www.youtube.com/@Apify`.

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

Maximum videos considered from each channel before filters are applied. Lower values keep recurring monitoring runs fast and cheap.

## `maxPagesPerChannel` (type: `integer`):

Maximum initial or continuation feed pages fetched per channel. One page is enough for a low-cost recurring check; increase it for older uploads.

## `maxItems` (type: `integer`):

Hard cap on videos written across all input channels after filters. Use a small value such as `20` for a cost-bounded smoke run.

## `sortBy` (type: `string`):

Order the channel feed as newest, popular, or oldest. Popular and oldest use YouTube's own channel sort controls when available.

## `publishedAfter` (type: `string`):

Optional exact date or relative period such as `2026-01-01`, `7 days`, or `2 weeks`. Date filtering fetches video detail pages for exact timestamps.

## `titleKeywords` (type: `array`):

Keep a video when its title, description, or hashtags contain at least one of these case-insensitive phrases. Filtering happens before dataset writes.

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

Drop a video when its title, description, or hashtags contain any of these case-insensitive phrases. Filtering happens before dataset writes.

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

Keep only videos with at least this many parsed views. Videos without a view count are excluded when this is greater than zero.

## `includeVideoDetails` (type: `boolean`):

Fetch each selected video page for exact publish time, views, likes, description, duration, and channel metadata. Off is the cheapest feed-only mode.

## `dryRun` (type: `boolean`):

Fetch, filter, and validate videos without writing dataset records. Use for previews and smoke tests when you want logs without result billing.

## Actor input object example

```json
{
  "channels": [
    "@Apify"
  ],
  "maxVideosPerChannel": 50,
  "maxPagesPerChannel": 1,
  "maxItems": 1000,
  "sortBy": "newest",
  "titleKeywords": [],
  "excludeKeywords": [],
  "minViews": 0,
  "includeVideoDetails": false,
  "dryRun": false
}
```

# Actor output Schema

## `records` (type: `string`):

Video URL, title, views, source publish label, exact publish time when requested, duration, hashtags, topic matches, thumbnail, channel metadata, and source URL.

# 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": [
        "@Apify"
    ],
    "publishedAfter": "",
    "titleKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("schnellscrapers/youtube-video-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": ["@Apify"],
    "publishedAfter": "",
    "titleKeywords": [],
    "excludeKeywords": [],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,schnellscrapers/youtube-video-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/nXoo3gmbjAN2MIHnx/builds/M01tkf2zgODarkBMp/openapi.json