# YouTube Shorts Scraper (`vakitek/youtube-shorts-scraper`) Actor

Get the Shorts of any YouTube channel with views, likes, comment count, duration, description and exact publish date. 2 USD per 1,000 Shorts, no minimum charge per run.

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

## Pricing

from $2.00 / 1,000 short 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/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 Shorts Scraper

Give it YouTube channels, get back their Shorts with views, likes, comment count, duration, description and the exact publish date. One row per Short.

The channel's Shorts tab only shows a title and a rounded view count. We open each Short to get the rest.

### What people use it for

- **Short-form trend research.** See which Shorts of a creator, or of your competitors, get the most views and engagement.
- **Influencer vetting.** Check how a creator's Shorts actually perform (views, likes, comments) before you pay for one.
- **Reporting.** Track your own channel's Shorts week after week with exact dates.
- **Cross-platform analysis.** Put YouTube Shorts next to your TikTok and Reels data with the same fields: views, likes, comments, date, duration.

### How to use it

1. Add channels in **Channels**, one per line: `@MrBeast`, a channel URL, or a `UC...` id. Use the `@handle` when in doubt.
2. Set **Max Shorts per channel** (default 20).
3. Optional: **Oldest post date** to stop at a date (`2026-01-01` or `30 days`).
4. Click **Start**. Export as JSON, CSV or Excel, or pull the results through the API.

```json
{
  "channels": ["@MrBeast", "@mkbhd"],
  "maxResultsShorts": 50,
  "oldestPostDate": "30 days"
}
```

### What you get

```json
{
  "id": "2QcaDwpvl7s",
  "title": "Try Not To Laugh | Never-Before-Seen Footage (Part 3/3)",
  "url": "https://www.youtube.com/shorts/2QcaDwpvl7s",
  "viewCount": 799000,
  "likes": 42000,
  "commentsCount": 1300,
  "publishedAt": "2026-09-01T08:15:30.000Z",
  "duration": "0:47",
  "durationSeconds": 47,
  "text": "Never-before-seen footage from the challenge...",
  "channelName": "MrBeast",
  "numberOfSubscribers": 300000000,
  "isMembersOnly": false,
  "type": "short"
}
```

- Likes, comment count, duration, description and exact date are included on every Short, at no extra cost.
- `text` is often empty: most creators don't write a description on a Short, YouTube just has nothing to give back.
- `commentsTurnedOff` is `true` when the creator disabled comments.
- `isMembersOnly` flags Shorts reserved to channel members.

### Pricing

**2 USD per 1,000 Shorts**, all fields included.

There is no minimum charge per run: 20 Shorts from one channel cost 0.04 USD. Error rows are free, and there's no monthly fee or Apify platform usage on top.

Example: the last 50 Shorts of 20 channels (1,000 Shorts) costs 2 USD.

### Good to know

- Once in a while YouTube refuses to show a Short's page. That Short still comes back and is billed normally, but without its duration and description, and with a date to the day instead of to the second.
- This actor doesn't download the videos. For captions, use our [YouTube Transcript Scraper](https://apify.com/vakitek/youtube-transcript), which also takes Shorts links.
- Need the channel's long videos too? Our [YouTube Channel Scraper](https://apify.com/vakitek/youtube-channel-videos) gets videos, Shorts and streams with channel stats.
- You don't need a proxy, a YouTube account or a YouTube API key.

### Use it from n8n, Make or an API

- **Small inputs**: call `run-sync-get-dataset-items` and read the items back directly. Set **Time budget (seconds)** (default 240) to how long you are willing to wait: the actor stops picking up new channels before that point and returns what it already has, so you never hit Apify's 300 second run-sync limit and lose the whole run. Any channel left unfinished comes back as a `TIME_BUDGET_EXCEEDED` row instead of being silently dropped.
- **Big inputs**: start the run with `POST /v2/acts/vakitek~youtube-shorts-scraper/runs`, poll `GET /v2/actor-runs/<runId>` (or add `waitForFinish=60`) until the status is `SUCCEEDED`, then read `GET /v2/datasets/<datasetId>/items`. Set **Time budget (seconds)** to `0` (no limit) for this pattern.

### Errors

A bad input never crashes the run. It becomes a row with an `error` code, and you are not charged for it.

| `error` | What happened | Retry? |
| --- | --- | --- |
| `NOT_FOUND` | The handle, URL or id doesn't match a real channel | No |
| `NO_RESULTS` | The channel has no Shorts, or none newer than your oldest post date | No |
| `INVALID_INPUT` | An option value is invalid | No |
| `BLOCKED` | YouTube refused us for now, usually an age-restricted channel, even after trying every proxy tier | Yes |
| `UPSTREAM_ERROR` | Something went wrong on YouTube's side or ours | Yes |
| `UPSTREAM_UNAVAILABLE` | Our API was unreachable | Yes |
| `TIME_BUDGET_EXCEEDED` | The time budget ran out before this channel finished | Yes |

Some rows also carry a `legacyError` field with the old, pre-unification code name (for example `CHANNEL_NOT_FOUND` or `LOGIN_REQUIRED`) so a pipeline still matching on it keeps working while it migrates to `error`.

### Reliability

Success rate, last 30 days: 99.8 % of 659 results across 27 runs (updated 2026-10-10). Failures counted: blocks, errors on our side, and runs that failed or timed out. Not counted: videos with no captions, private or deleted videos, bad links.

### FAQ

**How many Shorts can I get per channel?**
All of them. Set **Max Shorts per channel** as high as you need.

**I already use another YouTube Shorts actor. Do I have to change my code?**
Probably not. The input `channels` and `maxResultsShorts` and the output field names follow the most used Shorts scraper on the Store.

**Can I call it from my code or from an AI agent?**
Yes, like any Apify actor: REST API, the Python and JavaScript clients, or the Apify MCP server. The examples are in the API tab.

**Something broke or a field is missing?**
Open an issue on this page. We read every one and usually answer within a day.

# Changelog

This Actor's version history is a separate document: https://apify.com/vakitek/youtube-shorts-scraper/changelog.md

# Actor input Schema

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

YouTube channels: @handle (e.g. @MrBeast), full channel URL, or channel id (UC...). A bare name without @ only resolves if the channel still has a matching legacy vanity URL, which most channels no longer have; use @handle when in doubt.

## `maxResultsShorts` (type: `integer`):

Maximum number of Shorts to scrape per channel.

## `oldestPostDate` (type: `string`):

Stop scraping a channel once its Shorts are older than this date (by exact publish date, from each Short's own page). ISO date (e.g. 2026-01-01) or a relative number of days (e.g. "30 days"). Leave empty to only limit by count. An unparseable value is a free INVALID_INPUT error item, not silently ignored.

## `language` (type: `string`):

Interface language (hl) requested from YouTube, as an ISO 639-1 code (e.g. fr, de, ja). Controls which language translated captions/descriptions come back in. It does NOT change the transcript or video content language, only YouTube's own UI strings.

## `country` (type: `string`):

Geolocation (gl) requested from YouTube, as an ISO 3166-1 alpha-2 code (e.g. FR, DE, JP).

## `timeBudgetSecs` (type: `integer`):

Stop and return what is ready after this many seconds, so n8n/Make run-sync calls never time out. 0 = no limit.

## Actor input object example

```json
{
  "channels": [
    "@MrBeast"
  ],
  "maxResultsShorts": 20,
  "language": "en",
  "country": "US",
  "timeBudgetSecs": 240
}
```

# Actor output Schema

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

Shorts of each channel, with views, likes, comment count and publish date. Error items carry an `error` code and the `input` that failed.

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

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

# Run the Actor and wait for it to finish
run = client.actor("vakitek/youtube-shorts-scraper").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": [
    "@MrBeast"
  ]
}' |
apify call vakitek/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vakitek/youtube-shorts-scraper"
        }
    }
}
```

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/SZ0SUQ0BdWY2vhB2a/builds/padA5s2Of2ylJszlg/openapi.json