# YouTube Shorts Scraper (Channels & Hashtags) (`juliob.rangel/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts from any channel or hashtag: title, views, likes, comments, publish date, duration, description and hashtags. No API key, no quota. Export to Excel, CSV or JSON.

- **URL**: https://apify.com/juliob.rangel/youtube-shorts-scraper.md
- **Developed by:** [Julio Barcellos Rangel](https://apify.com/juliob.rangel) (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 $1.05 / 1,000 short scrapeds

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

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 (Channels & Hashtags)

YouTube Shorts Scraper collects the Shorts of any YouTube channel or hashtag with title, views, likes, comment count, publish date, duration, description, hashtags and tags. It is made for creators, agencies, marketers and researchers who want to find viral Shorts, track competitors and export YouTube Shorts data to Excel, CSV or JSON, with no YouTube API key and no login.

### What does YouTube Shorts Scraper do?

You give it channels, hashtags, or both. For each **channel**, the robot opens the channel's Shorts tab. For each **hashtag**, it opens the hashtag's Shorts page. It then reads the list of Shorts page by page until it reaches your limit per source.

With **Include likes, comments, date and description** turned on (the default), it also opens every Short to add the exact view count, likes, comment count, publish date, duration, description, hashtags, tags and channel. Turned off, you get a fast list with title, views and link only.

Channels can be given as:

- `@handles`: `@MrBeast`
- Handles without the `@`: `MrBeast`
- Channel URLs: `https://www.youtube.com/@MrBeast` or `https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA`
- Channel IDs: `UCX6OQ3DkcsbYNE6H8uQQuVA`

Hashtags can be given as `cooking`, `#cooking` or `https://www.youtube.com/hashtag/cooking`.

What comes out: one row per Short, with the source it came from (channel or hashtag) and the Short's data.

### What data can you extract?

| Field | What it means | Example |
|---|---|---|
| `source` | The channel or hashtag this Short was found on, as you typed it (hashtags start with `#`) | `#cooking` |
| `sourceType` | `channel` or `hashtag` | `hashtag` |
| `videoId` | 11-character video ID of the Short | `N0zC0CpwiZc` |
| `title` | Title of the Short | `Fire Paan` |
| `url` | Link to the Short | `https://www.youtube.com/shorts/N0zC0CpwiZc` |
| `views` | View count as a number (exact with details on, see Tips) | `45927810` |
| `viewsText` | View count as shown in the Shorts list | `45M views` |
| `thumbnail` | Thumbnail image URL | `https://i.ytimg.com/vi/N0zC0CpwiZc/hqdefault.jpg` |
| `channelName` | Channel that posted the Short (details) | `Nick DiGiovanni` |
| `channelId` | Channel ID (details) | `UCMyOj6fhvKFMjxUCp3b_3gA` |
| `durationSeconds` | Length in seconds (details) | `26` |
| `description` | Full description of the Short (details) | `#cooking #streetfood #viral` |
| `hashtags` | Hashtags found in the description (details) | `["#cooking", "#streetfood", "#viral"]` |
| `keywords` | Tags the creator set on the video (details) | `["Chef", "Cook", "Learn To Cook"]` |
| `likes` | Like count, rounded as YouTube shows it (details) | `595000` |
| `comments` | Comment count, rounded as YouTube shows it (details) | `3700` |
| `published` | Publish date as YouTube shows it (details) | `Aug 25, 2026` |
| `scrapedAt` | When the row was collected (ISO 8601, UTC) | `2026-10-08T20:18:10.724Z` |
| `error` | Only on error items: why a source gave nothing | `Channel or hashtag not found` |

Fields marked "(details)" are only filled when `includeDetails` is on. With it off, each row has `source`, `sourceType`, `videoId`, `title`, `url`, `views`, `viewsText`, `thumbnail` and `scrapedAt`.

The default table view shows `source`, `channelName`, `title`, `views`, `likes`, `comments`, `published`, `durationSeconds` and `url`. All fields are in the full JSON, CSV and Excel exports.

### How to use YouTube Shorts Scraper

1. Open the robot in Apify Console and go to the **Input** tab.
2. In **Channels**, add one channel per line. In **Hashtags**, add one hashtag per line. Both lists come pre-filled with an example (`@MrBeast` and `cooking`), so **delete the example you don't want**.
3. Set **Max Shorts per channel or hashtag** (default 20).
4. Keep **Include likes, comments, date and description** on for full data, or turn it off for a fast list.
5. Click **Start**. Shorts appear in the **Output** tab while the robot works.
6. Click **Export** to download JSON, CSV, Excel, HTML or XML, or read the dataset through the API.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `channels` | array of strings | `["@MrBeast"]` | @handles, channel URLs or `UC…` channel IDs. Their Shorts tab is scraped. |
| `hashtags` | array of strings | empty (the form shows `cooking` as an example) | Hashtags with or without `#`, or `youtube.com/hashtag/…` URLs. Shorts using the hashtag are scraped. |
| `maxShortsPerSource` | integer, minimum 1 | `20` | Stop after this many Shorts for each channel or hashtag. |
| `includeDetails` | boolean | `true` | Open each Short to add exact views, likes, comment count, publish date, duration, description, hashtags and tags. |
| `proxy` | object | `{ "useApifyProxy": true }` | Apify Proxy settings. |

Example input for channels only (note the empty `hashtags` list, so the default hashtag is not added):

```json
{
  "channels": ["@MrBeast", "https://www.youtube.com/@NickDiGiovanni"],
  "hashtags": [],
  "maxShortsPerSource": 50,
  "includeDetails": true,
  "proxy": { "useApifyProxy": true }
}
```

### Output example

One real item from a recent run on the hashtag `cooking` (the `keywords` list is shortened here):

```json
{
  "source": "#cooking",
  "sourceType": "hashtag",
  "videoId": "N0zC0CpwiZc",
  "title": "Fire Paan",
  "url": "https://www.youtube.com/shorts/N0zC0CpwiZc",
  "views": 45927810,
  "viewsText": "45M views",
  "thumbnail": "https://i.ytimg.com/vi/N0zC0CpwiZc/hqdefault.jpg",
  "channelName": "Nick DiGiovanni",
  "channelId": "UCMyOj6fhvKFMjxUCp3b_3gA",
  "durationSeconds": 26,
  "description": "#cooking #streetfood #viral",
  "hashtags": ["#cooking", "#streetfood", "#viral"],
  "keywords": ["Chef", "Cook", "Learn To Cook", "Cooking", "Food"],
  "likes": 595000,
  "comments": 3700,
  "published": "Aug 25, 2026",
  "scrapedAt": "2026-10-08T20:18:10.724Z"
}
```

If a channel or hashtag can't be found, you get an error item:

```json
{
  "source": "@this-channel-does-not-exist",
  "error": "Channel or hashtag not found"
}
```

### How much does it cost?

The robot uses pay per event pricing. You pay only for the Shorts returned, and Apify platform usage is already included in the price.

| Event | Price (Free plan) |
|---|---|
| Short scraped | $0.0015 per Short, which is **$1.50 per 1,000 Shorts** |

The price is the same with details on or off. Paid Apify plans get a discount:

| Plan | Price per 1,000 Shorts |
|---|---|
| Free | $1.50 |
| Bronze (-10%) | $1.35 |
| Silver (-20%) | $1.20 |
| Gold and higher (-30%) | $1.05 |

Worked examples on the Free plan:

- The default input (1 channel + 1 hashtag, 20 Shorts each) = 40 Shorts: **$0.06**.
- 100 channels × 50 Shorts = 5,000 Shorts: **$7.50** ($5.25 on Gold).
- 10,000 Shorts from hashtags: **$15.00** ($13.50 on Bronze, $12.00 on Silver, $10.50 on Gold).

What is NOT charged:

- Error items (`Channel or hashtag not found`, `No Shorts found`).
- The same Short seen twice on one channel or hashtag page (it is saved once).

### Use cases

- **Find viral Shorts in your niche**: scrape a hashtag and sort by `views` or `likes` to see which formats and topics work.
- **Track competitors**: schedule daily runs on competitor channels and compare views, likes and comments over time.
- **Influencer discovery**: collect the channels that post under a hashtag (`channelName`, `channelId`) and build an outreach list.
- **Engagement analysis**: compute likes per view and comments per view for each Short or each creator.
- **Content planning**: study titles, descriptions, hashtags and tags (`keywords`) of the top Shorts before you publish your own.
- **Brand monitoring**: follow a campaign hashtag and see who uses it and how the Shorts perform.
- **Feed other tools**: pass the Shorts URLs to a transcript or comments scraper for AI analysis.

### Tips and limits

- **Clear the example you don't need.** In the Console form both lists come pre-filled. From the API, `channels` defaults to `["@MrBeast"]`, so send `"channels": []` for a hashtag-only run; `hashtags` is empty unless you send it.
- **Details are slower.** With `includeDetails` on, the robot opens each Short (about 3 at a time). Turn it off when you only need titles, links and views.
- **Some detail fields can be missing.** The exact `views`, `durationSeconds` and `keywords` come from YouTube's video player data, which YouTube does not always return. When it is missing, `durationSeconds` is `null`, `keywords` is empty and `views` keeps the rounded number from the Shorts list (for example `50M views` becomes `50000000`). Likes, comments, date and description come from a second source and are usually still filled.
- **Likes and comments are rounded** the way YouTube shows them: `856K` becomes `856000`.
- **`published` is a date text** such as `Sep 27, 2026`, not an ISO date.
- **`keywords` are the creator's tags.** Many Shorts have none, so an empty list is normal.
- **`hashtags` come from the description.** If a Short has no hashtags in its description, the list is empty.
- **Order.** Shorts are returned in the order YouTube lists them on the channel's Shorts tab or the hashtag page.
- **No hard cap.** `maxShortsPerSource` has no upper limit in the input. The robot stops when YouTube serves no more Shorts for that source, so you may get fewer.
- **Error items** are pushed for `Channel or hashtag not found` and `No Shorts found`. They are free.
- **Proxy.** Requests go through Apify Proxy, with retries on new IPs and a last try on the Residential proxy group when your account has access to it.

### Use it from the API, Python or JavaScript

JavaScript (Node.js):

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const input = {
  channels: ['@MrBeast'],
  hashtags: [],
  maxShortsPerSource: 50,
  includeDetails: true,
};
const run = await client.actor('juliob.rangel/youtube-shorts-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'Shorts');
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run_input = {
    'channels': [],
    'hashtags': ['cooking', 'recipe'],
    'maxShortsPerSource': 50,
    'includeDetails': True,
}
run = client.actor('juliob.rangel/youtube-shorts-scraper').call(run_input=run_input)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(len(items), 'Shorts')
```

You can also call it over plain HTTP with the Apify API (for example the `run-sync-get-dataset-items` endpoint of `juliob.rangel~youtube-shorts-scraper`).

It works with Make, Zapier, n8n, Google Sheets export, webhooks and AI agents through the Apify MCP server.

### FAQ

**Do I need a login, cookies or a YouTube API key?**
No. The robot reads public Shorts pages the way a logged-out visitor sees them.

**Can I export YouTube Shorts data to Excel or CSV?**
Yes. Click **Export** in the Output tab and choose Excel, CSV, JSON, HTML or XML.

**How many Shorts can I get per channel or hashtag?**
Up to your `maxShortsPerSource` value, as long as YouTube keeps serving more Shorts for that page.

**Why are `durationSeconds` or `keywords` empty on some rows?**
YouTube did not return its player data for that Short during the run. The other fields (likes, comments, date, description) come from a second request and are usually still filled, and `views` falls back to the rounded number from the list.

**Can I scrape regular (long) videos with it?**
No. It reads Shorts tabs and hashtag Shorts pages only. For long videos, use the channel videos or video details scrapers below.

**Why did I get an error item?**
The channel or hashtag could not be resolved (`Channel or hashtag not found`), or the page had no Shorts (`No Shorts found`). Check the spelling of the handle or hashtag. Error items are not charged.

**Is scraping YouTube Shorts legal?**
The robot only collects publicly available data. You are responsible for complying with YouTube's terms and with privacy laws such as GDPR and LGPD. If you store personal data, you need a legitimate reason.

### Related scrapers

- [YouTube Video Details Scraper (Views, Likes, Comments)](https://apify.com/juliob.rangel/youtube-video-details)
- [YouTube Channel Videos Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-channel-videos)
- [YouTube Comments Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-comments-fast)
- [YouTube Transcript Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-transcript-fast)
- [TikTok Video Scraper (Views, Likes, Comments, Shares)](https://apify.com/juliob.rangel/tiktok-video-scraper-fast)
- [Instagram Posts Scraper (Reels, Likes, Views, Captions)](https://apify.com/juliob.rangel/instagram-posts-scraper-fast)

***

## YouTube Shorts Scraper (PT-BR)

Coleta **Shorts do YouTube** de qualquer **canal** ou **hashtag**: visualizações, curtidas, comentários, data, duração, descrição e hashtags. Sem chave de API e sem login. Você paga só por Short retornado. Exporte para Excel, CSV ou JSON.

# Actor input Schema

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

@handles, channel URLs (youtube.com/@name, /channel/UC...) or channel IDs. Their Shorts tab is scraped.

## `hashtags` (type: `array`):

Hashtags (with or without #) or youtube.com/hashtag/... URLs. Shorts using the hashtag are scraped.

## `maxShortsPerSource` (type: `integer`):

Stop after this many Shorts for each source.

## `includeDetails` (type: `boolean`):

Opens each Short to add exact views, likes, comment count, publish date, duration, description and hashtags. Turn off for a faster list with title and views only.

## `proxy` (type: `object`):

Apify Proxy settings.

## Actor input object example

```json
{
  "channels": [
    "@MrBeast"
  ],
  "hashtags": [
    "cooking"
  ],
  "maxShortsPerSource": 20,
  "includeDetails": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "channels": [
        "@MrBeast"
    ],
    "hashtags": [
        "cooking"
    ],
    "maxShortsPerSource": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("juliob.rangel/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"],
    "hashtags": ["cooking"],
    "maxShortsPerSource": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("juliob.rangel/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"
  ],
  "hashtags": [
    "cooking"
  ],
  "maxShortsPerSource": 20
}' |
apify call juliob.rangel/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,juliob.rangel/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/wdK3jIHY5bBLctYXn/builds/cqwao6LHDsXMeqnjO/openapi.json