# YouTube Shorts Scraper (`schnellscrapers/youtube-shorts-monitor`) Actor

Scrape YouTube Shorts from public channels for titles, views, likes, publish dates, hashtags, thumbnails, descriptions, and channel data. Filter by keywords, views, dates, or sort order before output. Pay per Short with no login or YouTube API key.

- **URL**: https://apify.com/schnellscrapers/youtube-shorts-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 shorts

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

## YouTube Shorts Scraper

Track public creator channels on a schedule and keep only the Shorts that matter to your workflow.

### What does YouTube Shorts Scraper do?

YouTube Shorts Scraper reads a channel's Shorts feed and returns one clean dataset record per Short. Use it for competitor content checks, creator research, trend lists, and recurring alerts based on title, hashtag, view, or publish-date filters.

### What data can you extract from YouTube Shorts?

- Short identity — video ID, canonical URL, title, thumbnail URL
- Performance — parsed views, source view label, optional exact likes
- Publishing — exact publish timestamp and duration when details are enabled
- Content — description and hashtags
- Creator — channel ID, name, handle, URL, and subscriber count
- Provenance — source channel URL, scrape timestamp, and detail-fetch flag

### How to use YouTube Shorts Scraper

1. Add one or more YouTube channel handles or URLs in the input box.
2. Set the maximum Shorts and feed pages per channel.
3. Choose newest, popular, or oldest, then add optional keyword, view, or date filters.
4. Turn on exact Short details when you need publish times, likes, duration, or descriptions.
5. Click Run and download the dataset as JSON, CSV, or Excel, or call it through the dataset API.

### How much does it cost?

The actor uses pay-per-result pricing: one billable result is one Short written to the dataset, priced at $0.0015 per Short ($1.50 per 1,000 at the free tier). There is no actor-specific result allowance or run-start charge; Apify account-plan limits still apply. Feed-only mode uses one direct HTML request per channel page. Exact details add one public Short-page request per selected candidate, so leave enrichment off for lightweight recurring checks.

### Input

`channels` is required and accepts handles such as `@Apify`, usernames such as `Apify`, or full channel URLs. `maxShortsPerChannel` and `maxPagesPerChannel` bound the run. Source sorting is honored before the page budget is applied, and filters run before records are written.

```json
{
  "channels": ["@Apify", "https://www.youtube.com/@MrBeast"],
  "maxShortsPerChannel": 20,
  "sortBy": "popular",
  "titleKeywords": ["ai", "scraping"],
  "minViews": 1000,
  "includeVideoDetails": true
}
```

### Output

Each dataset item represents one Short. Feed-only runs populate identity, titles, views, thumbnails, hashtags, and channel data; detail mode also populates exact publish time, likes, duration, and description.

```json
{
  "videoId": "yIXOBAV3Jt8",
  "url": "https://www.youtube.com/shorts/yIXOBAV3Jt8",
  "title": "New in Apify: AI that scrapes live data before it answers #ai",
  "viewCount": 1267,
  "likes": 14,
  "publishedAt": "2026-07-30T10:25:47-07:00",
  "durationSeconds": 53,
  "hashtags": ["#ai"],
  "channelName": "Apify",
  "detailsFetched": true
}
```

### Integrations

Use the Apify API from Python or Node.js, schedule recurring runs, trigger webhooks, or connect the dataset to Make, Zapier, or n8n through Apify integrations. See the [Apify integrations documentation](https://docs.apify.com/platform/integrations) for workflow examples.

### Related actors

- [YouTube Scraper](https://apify.com/streamers/youtube-scraper) — broader YouTube channel and video extraction.
- [YouTube Shorts Scraper](https://apify.com/streamers/youtube-shorts-scraper) — established Shorts extraction with per-result pricing.

### FAQ

#### Does this need a YouTube API key or login?

No. The actor reads structured data embedded in public YouTube channel and Short pages.

#### How does YouTube Shorts Scraper work?

It reads the structured data embedded in public channel and Short pages, then optionally fetches individual Short pages for exact engagement and publish metadata.

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

Yes. Start a run through the Apify API or client library and read the run's default dataset.

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

Yes. Use the Apify client for either language; the dataset endpoint returns JSON, CSV, or Excel exports.

#### What does exact detail mode change?

It opens each selected Short page and adds exact publish time, views, likes, duration, description, and detail-page channel fields. This is more expensive than feed-only mode.

#### How do I monitor only recent Shorts?

Set `publishedAfter` to an ISO date such as `2026-08-01` or a relative period such as `7 days`. The actor fetches detail pages automatically so the cutoff uses the source timestamp.

#### Are excluded Shorts billed?

No. Keyword, minimum-view, and date filters run before `Actor.pushData`, so excluded records are not emitted as results.

#### Can I use this for recurring checks?

Yes. Schedule the actor with a small page and result cap, then compare successive datasets or send each run to a webhook or downstream automation.

#### Is it legal to scrape YouTube Shorts?

This actor reads public pages and makes no legal or compliance determination. Users are responsible for following applicable law, platform rules, and their own data-use requirements.

### Your feedback

Report a reproducible issue or request a field through the Issues tab on the Actor page.

# Actor input Schema

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

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

## `maxShortsPerChannel` (type: `integer`):

Maximum Shorts 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 Shorts.

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

Hard cap on Shorts 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. The source's own Shorts sort controls are used when available.

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

Optional exact date or relative period such as `2026-01-01`, `7 days`, or `2 weeks`. Date filtering fetches Short detail pages so the cutoff uses the exact publish timestamp.

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

Keep a Short 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 Short when its title, description, or hashtags contain any of these case-insensitive phrases. Filtering happens before dataset writes.

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

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

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

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

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

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

## Actor input object example

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

# Actor output Schema

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

Short URL, title, views, publish time, likes, duration, hashtags, 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-shorts-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-shorts-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": [
    "@Apify"
  ],
  "publishedAfter": "",
  "titleKeywords": [],
  "excludeKeywords": []
}' |
apify call schnellscrapers/youtube-shorts-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/q0OHDrP47lfJ2KTR3/builds/nfdTqTjgzCo08hqnz/openapi.json