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

List Shorts videos from any YouTube channel. Title, view count, thumbnails, video ID.

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

## Pricing

from $0.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Enumerate the vertical Shorts feed of any YouTube channel — title, view-count text, video ID, direct Shorts URL, and thumbnails — in bulk, with one clean JSON record per Short.

### Why use this actor

- **Channel-level Shorts feed** — pulls only the Shorts tab, not regular long-form videos, so you do not have to filter the output yourself.
- **Flexible input** — accepts handles (`@MrBeast`), channel IDs (`UCX6OQ3DkcsbYNE6H8uQQuVA`), or full channel URLs in the same list.
- **Auto-pagination** — walks the entire Shorts catalog for each channel (or stops at `maxItems`) without you managing cursors.
- **Vertical thumbnails included** — every Short comes with multiple 9:16 thumbnail resolutions ready for previews, dashboards, or multimodal training sets.
- **View-count signal** — surface the `viewCountText` YouTube shows on the Shorts shelf (e.g. `"106M views"`) for quick performance benchmarking.
- **Stable JSON output** suitable for pipelines, spreadsheets, and databases — every row carries `_input`, `_channelId`, `_source`, and `_scrapedAt` envelope fields so you can join results back to your input list.
- **No account / no login / no API key** — just paste the channel list and run.

### How it works

1. You provide a list of YouTube channels — handles, IDs, or full URLs all work.
2. The actor resolves each handle to its channel ID, opens the channel's Shorts tab, and reads each Shorts item the same way the YouTube web app does.
3. Pagination continues automatically until the channel's Shorts feed is exhausted or `maxItems` is reached.
4. Results stream into your dataset, ready to download as JSON, CSV, or Excel.

You do not need to manage scrapers, browsers, or rotating IPs — all handled internally.

### Input

```json
{
  "channels": [
    "@MrBeast",
    "@khaby.lame"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `channels` | array | List of YouTube channels to scrape. Accepts handles (`@MrBeast`), channel IDs (`UCX6OQ3DkcsbYNE6H8uQQuVA`), or full channel URLs. |
| `maxItems` | integer | Maximum Shorts to return **per channel**. Default `50`. Set `0` for unlimited. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter works for most channels; switch to residential for very large jobs. |

### Output

Input: `@MrBeast`, `maxItems: 3`

```json
{
  "videoId": "dqpCvSU-ECE",
  "url": "https://www.youtube.com/shorts/dqpCvSU-ECE",
  "title": "If This Goes In You Have To Subscribe",
  "viewCountText": "2.8M views",
  "thumbnails": [
    {
      "url": "https://i.ytimg.com/vi/dqpCvSU-ECE/oardefault.jpg?sqp=-oaymwEdCJUDENAFSFWQAgHyq4qpAwwIARUAAIhCcAHAAQY=&rs=AOn4CLAQV3EwU-zVRfZjyXYsuw8bub2ZrQ&usqp=CCk",
      "width": 405,
      "height": 720
    },
    {
      "url": "https://i.ytimg.com/vi/dqpCvSU-ECE/oardefault.jpg?sqp=-oaymwEgCJUDEOAESFWQAgHyq4qpAw8IARUAAIhCcAHAAQbIAQE=&rs=AOn4CLCEfSlsJpHS4bVo4xt_JVYtX0xOrg&usqp=CCk",
      "width": 405,
      "height": 608
    }
  ],
  "_input": "@MrBeast",
  "_channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:44:44.812131+00:00"
}
```

| Field | Type | Description |
|---|---|---|
| `videoId` | string | YouTube's 11-character video ID. Combine with `https://www.youtube.com/shorts/{videoId}` or pass to the YouTube Video Detail actor for full metadata. |
| `url` | string | Canonical Shorts player URL — ready to paste into a browser or feed to a downstream scraper. |
| `title` | string | Title of the Short as shown on the channel's Shorts shelf. |
| `viewCountText` | string | View count as YouTube renders it (e.g. `"2.8M views"`, `"106M views"`). Text, not numeric — parse if you need an integer. |
| `thumbnails` | array | Vertical (9:16) thumbnail variants. Each entry has `url`, `width`, `height`. Pick the largest for previews, the smallest for grids. |
| `_input` | string | The channel exactly as you supplied it. Use this to join results back to your input list. |
| `_channelId` | string | Resolved canonical channel ID (`UC...`). Stable across handle changes. |
| `_source` | string | Internal tag for the path used to fetch the record. `S1-primary` means the fastest path; values starting with `S2-` would indicate a fallback. |
| `_scrapedAt` | string | ISO-8601 UTC timestamp when the record was scraped. |

#### Error envelope

Channels that fail to resolve or fetch return a structured error instead of crashing the run:

```json
{
  "_input": "@this-handle-does-not-exist-xyz",
  "_error": "handle_resolve_failed",
  "_errorDetail": "could not resolve @this-handle-does-not-exist-xyz",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:45:02.012345+00:00"
}
```

Filter on `_error` to triage failed rows. Channels that simply have no Shorts return zero records — that is not an error.

### Pricing

This actor is billed per result: **$3.50 per 1,000 Shorts** (Tier 3). Each Short returned in your dataset = 1 result. Error rows (`handle_resolve_failed`, `fetch_failed`, `invalid_input`) are not billed.

### Other Sosmed Actors

| Platform | Actor | Best for |
|---|---|---|
| YouTube | [YouTube Channel Scraper](https://apify.com/xtracto/youtube-channel-scraper) | Channel profile, subscriber count, regular video list |
| YouTube | [YouTube Video Detail Scraper](https://apify.com/xtracto/youtube-video-detail-scraper) | Full metadata for any single Short or video by ID |
| Instagram | [Instagram Account Reels Scraper](https://apify.com/xtracto/instagram-account-reels-scraper) | Vertical reels feed for any Instagram account |
| Threads | [Threads Account Scraper](https://apify.com/xtracto/threads-account-threads-scraper) | Account-level Threads feed for short-form posts |
| Twitch | [Twitch Clips Scraper](https://apify.com/xtracto/twitch-clips) | Short clip catalog for any Twitch streamer |
| Pinterest | [Pinterest Board Scraper](https://apify.com/xtracto/pinterest-board) | Pin feed for any Pinterest board |
| Bluesky | [Bluesky Account Posts Scraper](https://apify.com/xtracto/bluesky-account-posts-scraper) | Account-level posts feed on atproto |

Browse the full catalog at [apify.com/xtracto](https://apify.com/xtracto).

### Notes

- The Shorts tab is ordered **newest-first** as YouTube serves it; ordering can shift between runs if the creator pins or unpins a Short.
- Only **public** Shorts are returned — unlisted and private Shorts are not visible on the channel's Shorts tab.
- Channels that have **never posted a Short** simply yield zero records (no error). The Shorts tab does not exist for such channels.
- `viewCountText` is text (e.g. `"1.2M views"`), not a number — parse it client-side if you need an integer.
- Thumbnails are vertical 9:16; the array contains multiple resolutions, sorted largest-first.
- Adult-oriented or age-restricted Shorts may be hidden by YouTube's default safety filter and will not appear.

# Actor input Schema

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

List of YouTube channels to scrape. Accepts handles (`@MrBeast`), channel IDs (`UCX6OQ3DkcsbYNE6H8uQQuVA`), or full channel URLs (`https://www.youtube.com/@MrBeast`).

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

Maximum number of Shorts to return per channel. Set to `0` for unlimited (returns the channel's full public Shorts catalog).

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

Apify Proxy settings. Datacenter proxy works for most channels; switch to residential for very large jobs or restricted regions.

## Actor input object example

```json
{
  "channels": [
    "@MrBeast",
    "@khaby.lame"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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",
        "@khaby.lame"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/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",
        "@khaby.lame",
    ],
    "maxItems": 50,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Shorts Scraper",
        "description": "List Shorts videos from any YouTube channel. Title, view count, thumbnails, video ID.",
        "version": "1.0",
        "x-build-id": "hiRmE9w1jdZkMLWxG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~youtube-shorts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-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/xtracto~youtube-shorts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-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/xtracto~youtube-shorts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-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",
                "required": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "YouTube channels",
                        "type": "array",
                        "description": "List of YouTube channels to scrape. Accepts handles (`@MrBeast`), channel IDs (`UCX6OQ3DkcsbYNE6H8uQQuVA`), or full channel URLs (`https://www.youtube.com/@MrBeast`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Shorts per channel",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of Shorts to return per channel. Set to `0` for unlimited (returns the channel's full public Shorts catalog).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Datacenter proxy works for most channels; switch to residential for very large jobs or restricted regions.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
