# YouTube Shorts Scraper - Short Video Data (`benthepythondev/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts from channel URLs: short title, URL, views, duration, thumbnail and channel metadata.

- **URL**: https://apify.com/benthepythondev/youtube-shorts-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Social media, Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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 Shorts Scraper - Short Video Data

Scrape YouTube Shorts from public channel URLs and export structured short-video metadata in one run. Get the short title, URL, views, duration, thumbnail, channel name, channel id, channel URL and source URL. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the YouTube Shorts Scraper?

YouTube Shorts is one of the fastest-moving content surfaces on the web. Brands, creators, agencies and researchers need a practical way to monitor what channels publish without manually opening every Shorts tab. This actor turns one or more public YouTube channel Shorts pages into clean datasets you can analyze, compare or sync into another workflow.

The actor uses `yt-dlp` flat extraction. It does not download videos. It only reads public short-video metadata, which keeps runs lightweight and practical for repeatable monitoring.

#### What data does it extract?

- **Short metadata:** short id, title, URL, duration, view count and thumbnail.
- **Channel metadata:** channel name, channel id, channel URL, handle and follower count when available.
- **Source context:** the Shorts URL that produced each row.

### Input

Paste one or more YouTube channel URLs or Shorts tab URLs into `channelUrls`. If you paste a normal channel URL, the actor automatically checks the `/shorts` tab. Set `maxResults` to control how many Shorts are returned per channel.

#### Example input

```json
{
  "channelUrls": ["https://www.youtube.com/@Apify/shorts"],
  "maxResults": 25
}
````

### Output

Each dataset row can include:

```json
{
  "channel": "Apify",
  "channel_id": "UCTgwcoeGGKmZ3zzCXN2qo_A",
  "channel_url": "https://www.youtube.com/channel/UCTgwcoeGGKmZ3zzCXN2qo_A",
  "channel_handle": "@Apify",
  "channel_follower_count": 14800,
  "short_id": "P1jBbKrD_Po",
  "url": "https://www.youtube.com/shorts/P1jBbKrD_Po",
  "title": "Apify went flying through the sky...",
  "view_count": 597,
  "duration_seconds": 23,
  "thumbnail": "https://i.ytimg.com/...",
  "source_url": "https://www.youtube.com/@Apify/shorts"
}
```

### Use cases

📱 **Short-form competitor monitoring:** Track which Shorts competitors publish and compare titles, thumbnails and view counts over time.

🎬 **Creator research:** Find which short-video topics and formats are appearing across creator channels in your niche.

📈 **Social analytics:** Export Shorts metadata into a dashboard and monitor output cadence, view counts and content angles.

🧲 **Influencer prospecting:** Build shortlists of active Shorts creators and enrich their channel URLs later with contact or website data.

🧠 **Trend discovery:** Watch a group of channels weekly and surface newly posted Shorts for manual review, tagging or AI summarization.

### Workflow ideas

Create one saved task for each niche, competitor set or client. Run it weekly and export the dataset to a spreadsheet or database. Compare new short ids against previous runs to detect fresh content. For agencies, combine Shorts metadata with comment scraping or transcript extraction when a specific short needs deeper analysis.

Because every row includes source channel context, you can run several channels in one task and still filter the output later. This is useful for social media teams watching a portfolio of brands or for researchers comparing publication patterns across many creators.

### Reliability notes

The actor does not use a YouTube API key and does not download media. It extracts public metadata. YouTube may change page behavior, and some channels may not have a Shorts tab or may expose only limited metadata.

For large monitoring jobs, split channel lists into separate tasks. That makes retries easier and keeps run logs clear.

### Data quality tips

Use public channel URLs or direct Shorts tab URLs. Handles such as `https://www.youtube.com/@Apify` are supported because the actor automatically checks the `/shorts` tab. If a channel changed its handle, use the current public URL shown by YouTube.

Shorts metadata can be sparse compared with long-form video pages. Some rows may have a title and views but no duration, or a thumbnail but limited channel detail. The actor keeps those rows because even partial Shorts metadata is useful for monitoring publication cadence and discovering new short-form content.

For competitive analysis, keep one task per market or client. That makes it easy to compare a consistent set of channels over time, spot newly published Shorts, and avoid mixing unrelated niches in the same dataset.

### Pricing

This actor uses pay-per-result pricing. You are charged for each short pushed to the dataset, plus a tiny actor-start event.

### FAQ

#### Does it download Shorts videos?

No. It only extracts metadata.

#### Does it need a YouTube API key?

No. It uses public metadata extraction through `yt-dlp`.

#### Can I use normal channel URLs?

Yes. If the URL does not already include `/shorts`, the actor appends it automatically.

#### Can I scrape multiple channels?

Yes. Add multiple channel URLs in one run.

#### Does it include views?

It returns `view_count` when YouTube exposes it for the Shorts page.

#### Can I schedule it?

Yes. Save a task and run it daily, weekly or monthly to monitor new Shorts.

#### Is it legal?

This actor extracts publicly available metadata. You are responsible for using the output lawfully, respecting YouTube's terms, copyright, privacy rules and compliance requirements.

#### How is this different from a normal channel scraper?

It focuses on the Shorts tab and short-form videos, which are often analyzed separately from long-form uploads.

#### Does it include comments or transcripts?

No. This actor extracts Shorts metadata. Use a comments or transcript actor separately when you need deeper analysis for a specific short.

#### Can I use it for influencer research?

Yes. It is a discovery and monitoring step: find active Shorts creators, then review or enrich promising channels separately.

### You might also like

- YouTube Search Results Scraper - scrape videos by keyword
- YouTube Comments Scraper - export public comments
- YouTube Transcript Scraper - extract transcripts
- YouTube Playlist Extractor - export playlist videos

### Keywords

YouTube Shorts scraper, YouTube Shorts API, YouTube short video data, Shorts metadata extractor, YouTube creator research, short-form video scraper, YouTube channel Shorts, social media monitoring, influencer discovery, YouTube trend research.

# Actor input Schema

## `channelUrls` (type: `array`):

YouTube channel URLs or /shorts URLs to extract Shorts from.

## `maxResults` (type: `integer`):

Maximum number of Shorts to return from each channel.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@Apify/shorts"
  ],
  "maxResults": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "channelUrls": [
        "https://www.youtube.com/@Apify/shorts"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/youtube-shorts-scraper").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 = {
    "channelUrls": ["https://www.youtube.com/@Apify/shorts"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/youtube-shorts-scraper").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 '{
  "channelUrls": [
    "https://www.youtube.com/@Apify/shorts"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Shorts Scraper - Short Video Data",
        "description": "Scrape YouTube Shorts from channel URLs: short title, URL, views, duration, thumbnail and channel metadata.",
        "version": "1.0",
        "x-build-id": "K0icDa5If3R0gGTwH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~youtube-shorts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-youtube-shorts-scraper",
                "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/benthepythondev~youtube-shorts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-youtube-shorts-scraper",
                "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/benthepythondev~youtube-shorts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-youtube-shorts-scraper",
                "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": {
                    "channelUrls": {
                        "title": "Channel URLs",
                        "type": "array",
                        "description": "YouTube channel URLs or /shorts URLs to extract Shorts from.",
                        "default": [
                            "https://www.youtube.com/@Apify/shorts"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max shorts per channel",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of Shorts to return from each channel.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```