# YouTube Shorts Scraper — Views, Likes, Comments & Hashtags (`fabrikit/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts from channels, hashtags, keyword searches or Short URLs. Get exact views, likes, comment count, publish date, duration, hashtags, sound and channel for every Short. No API key, no login. From US$2.80 per 1,000 Shorts.

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

## Pricing

from $2.80 / 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.

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 — Views, Likes, Comments & Hashtags

**YouTube Shorts Scraper extracts Shorts from youtube.com** — a channel's Shorts tab, a hashtag feed, a keyword search with the Shorts filter, or a list of Short links — and returns one clean row per Short: exact views, likes, comment count, publish time, length, description, hashtags, sound, category and channel. It needs no YouTube API key and no login, and you pay per Short saved.

This Actor is the Shorts-only edition of our [YouTube Videos Scraper](https://apify.com/fabrikit/youtube-videos-scraper), which covers regular videos, playlists and channel profiles. If you only care about vertical short-form video, start here: the input is built around Shorts sources and every record carries the Shorts-specific fields (sound, comment switch, vertical thumbnail).

### What data does it return?

| Field | Example | Notes |
|---|---|---|
| `shortId`, `url` | `-62C9R_41Sc`, `https://www.youtube.com/shorts/-62C9R_41Sc` | always |
| `title` | `From the Moon to the 50-Yard Line` | always |
| `viewCount` | `47711` | exact with details; rounded (47K) in fast mode |
| `likeCount` | `902` | `null` when the creator hides likes |
| `commentCount`, `commentsDisabled` | `711`, `false` | comments switched off → `commentsDisabled: true`, `commentCount: null` |
| `publishedAt` | `2026-10-05T23:21:46.000Z` | ISO 8601, UTC |
| `durationSeconds` | `39` | |
| `description`, `hashtags` | `#ArtemisII #MoonJoy` | e-mails and phone numbers are removed from descriptions |
| `channelName`, `channelHandle`, `channelId`, `channelUrl` | `NASA`, `@NASA`, `UCLA_DiR1FfKNvjuUpBHmylQ` | |
| `soundTitle` | `Original Sound` | the audio shown on the Short |
| `category`, `keywords`, `isFamilySafe` | `Science & Technology`, `[...]`, `true` | from YouTube's metadata |
| `thumbnailUrl` | `https://i.ytimg.com/vi/<id>/frame0.jpg` | vertical first frame |
| `sourceType`, `sourceInput`, `positionInSource` | `channel`, `@NASA`, `1` | where the Short was found and its rank in that feed |
| `detailsFetched`, `scrapedAt` | `true`, ISO time | |

### Use cases

- **Creator and competitor tracking** — pull the latest or most popular Shorts of any channel and follow views, likes and comments over time with a schedule.
- **Trend research** — read a hashtag feed (`#recetas`, `#gymtok`, `#booktok`) to see which formats, sounds and lengths get traction this week.
- **Influencer discovery** — search a niche keyword with the Shorts filter and collect the channels behind the best-performing clips.
- **Content and AI datasets** — titles, descriptions, hashtags and engagement numbers as structured JSON for dashboards, LLM pipelines or model training on public metadata.
- **Campaign reporting** — paste the links of sponsored Shorts and get their current numbers in one table.

### How to use it

1. Fill one or more sources: **Channels**, **Hashtags**, **Search keywords** or **Single Short URLs**.
2. Set **Max Shorts** (total) and, optionally, **Max Shorts per channel / hashtag / search**.
3. Optional: channel order (Latest, Popular, Oldest) and **Only Shorts published after** (`2026-10-01` or `30 days`).
4. Run it and download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

#### Input example: two channels, newest Shorts from the last 30 days

```json
{
  "channels": ["@NASA", "https://www.youtube.com/@MrBeast/shorts"],
  "channelSort": "latest",
  "publishedAfter": "30 days",
  "maxItems": 100,
  "maxItemsPerSource": 50
}
```

#### Input example: hashtag feed plus a Shorts search

```json
{
  "hashtags": ["recetasfaciles"],
  "searchQueries": ["cooking hacks"],
  "maxItems": 60,
  "region": "MX"
}
```

#### Input example: fast mode for a quick view count snapshot

```json
{
  "channels": ["@NASA"],
  "channelSort": "popular",
  "includeDetails": false,
  "maxItems": 200
}
```

Fast mode skips the per-Short detail request: you get ID, title, rounded views and thumbnail (and the channel, for channel inputs) in a fraction of the time.

### Output example

A real record from a local test run on 19 October 2026 (description shortened):

```json
{
  "shortId": "-62C9R_41Sc",
  "url": "https://www.youtube.com/shorts/-62C9R_41Sc",
  "title": "From the Moon to the 50-Yard Line",
  "description": "From the Moon to the 50-yard line. Six months ago, NASA astronaut Christina Koch flew ... #ArtemisII #FlyEaglesFly #MoonJoy",
  "hashtags": ["#ArtemisII", "#FlyEaglesFly", "#MoonJoy"],
  "viewCount": 47711,
  "likeCount": 902,
  "commentCount": null,
  "commentsDisabled": true,
  "publishedAt": "2026-10-05T23:21:46.000Z",
  "durationSeconds": 39,
  "channelName": "NASA",
  "channelHandle": "@NASA",
  "channelId": "UCLA_DiR1FfKNvjuUpBHmylQ",
  "channelUrl": "https://www.youtube.com/@NASA",
  "soundTitle": "Original Sound",
  "category": "Science & Technology",
  "keywords": [],
  "isFamilySafe": true,
  "thumbnailUrl": "https://i.ytimg.com/vi/-62C9R_41Sc/frame0.jpg",
  "sourceType": "channel",
  "sourceInput": "@NASA",
  "positionInSource": 1,
  "detailsFetched": true,
  "scrapedAt": "2026-10-19T17:44:27.214Z"
}
```

A `SUMMARY` record in the key-value store lists how many Shorts each source gave, how many details were loaded, the proxy used and any errors.

### Pricing

Pay per event: **US$2.80 per 1,000 Shorts** saved (US$0.0028 each). The price is the same with or without details, and proxy costs are included.

- 100 Shorts ≈ US$0.15
- 1,000 Shorts = US$2.80
- 10,000 Shorts = US$15

Shorts filtered out by the date filter or skipped as duplicates are not charged. If you set a maximum cost per run, the Actor stops cleanly when it is reached.

### How it compares

- **YouTube Data API v3**: official, but needs a Google Cloud key and daily quota, has no "Shorts tab" or hashtag-feed listing, and does not tell you which uploads are Shorts. This Actor reads the same public pages a visitor sees.
- **Other Shorts scrapers in the Store**: the most used ones charge about US$3–4 per 1,000 Shorts. This one costs US$2.80 and returns exact numbers (57,949,054 instead of "57M") when details are on.
- **Limits**: YouTube decides how deep a hashtag or search feed goes. In our tests a hashtag feed gave 140+ Shorts over 4 pages, and channel tabs (48 Shorts per page) and Shorts searches kept paging normally. The Actor stops when YouTube stops sending pages.

### Integrations

Call it from the Apify API, the JavaScript or Python client, or schedule it in Apify Console. Connect the results to n8n, Make, Zapier, Google Sheets, Airtable or a webhook. AI agents (Claude, ChatGPT, Cursor and other MCP clients) can discover and run it through the Apify MCP server, e.g. "get the 20 most viewed Shorts of @NASA".

### FAQ

**Is it legal to scrape YouTube Shorts?** The Actor reads only public metadata that YouTube shows to logged-out visitors. Channel names and descriptions can still be personal data when a channel belongs to a private person, so laws such as GDPR, CCPA or Chile's Ley 21.719 may apply to how you store and use them; e-mails and phone numbers are stripped from descriptions. The videos themselves belong to their creators. This is not legal advice.

**Do I need a proxy?** No setup needed. The Apify datacenter proxy is used by default; if YouTube blocks it twice in a row, the run switches to Apify residential proxy (country = `region`) for the rest of the run.

**Why is `likeCount` empty for some Shorts?** The creator hid the like count; YouTube does not publish it.

**Can I get the comments themselves?** No. This Actor returns the comment count only, not comment text or commenter data.

**Does it download the video files?** No, only metadata and the thumbnail URL.

**Which languages work?** Any `language`/`region`. Exact numbers come from the details and do not depend on the language; rounded counts in fast mode are parsed most reliably with `language: en`.

### Changelog

- **2026-10-19** — First version: channel Shorts tab (latest / popular / oldest), hashtag feeds, Shorts search, single Short URLs, per-Short details, date filter, fast mode, pay per Short.

### En español

**YouTube Shorts Scraper** extrae Shorts públicos de YouTube sin API key ni login: la pestaña Shorts de un canal (recientes, populares o antiguos), el feed de un hashtag, una búsqueda con filtro Shorts o una lista de enlaces. Por cada Short entrega vistas exactas, likes, cantidad de comentarios, fecha de publicación, duración, descripción (sin correos ni teléfonos), hashtags, sonido, categoría y datos del canal. Permite filtrar por fecha ("30 days" o "2026-10-01") y tiene un modo rápido sin detalles. Cobra US$1,50 por cada 1.000 Shorts guardados, con proxy incluido. Para videos largos, listas y perfiles de canal usa nuestro [YouTube Videos Scraper](https://apify.com/fabrikit/youtube-videos-scraper).

# Actor input Schema

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

Channels whose Shorts tab you want. Accepts a handle (@NASA), a channel URL (https://www.youtube.com/@NASA/shorts, /channel/UC..., /c/..., /user/...) or a channel ID (UC...).

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

Hashtag feeds of Shorts, like youtube.com/hashtag/<tag>/shorts. Write the tag with or without # ("funny", "#recetas") or paste the hashtag URL. One word per tag, no spaces.

## `searchQueries` (type: `array`):

Keywords searched on YouTube with the Shorts filter on, e.g. "cooking hacks". A YouTube search URL (youtube.com/results?search_query=...) also works.

## `shortUrls` (type: `array`):

Specific Shorts to look up, e.g. https://www.youtube.com/shorts/Y8IJi7iP5vk, a youtu.be link or the 11-character ID.

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

Stop after this many Shorts across all inputs. You pay only for the Shorts that are saved.

## `maxItemsPerSource` (type: `integer`):

Optional cap for each single input, so one big channel does not use up the whole "Max Shorts" budget. Leave empty for no per-input cap.

## `channelSort` (type: `string`):

Order of a channel's Shorts tab: newest first, most viewed first, or oldest first (the same three buttons YouTube shows). Hashtag and search feeds keep YouTube's own order.

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

Keep only Shorts published on or after this date. Use a date (2026-10-01) or an age such as "7 days", "2 weeks", "3 months". With channel order "Latest" the Actor stops reading a channel once it reaches older Shorts. Needs the details (turned on automatically).

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

On (recommended): exact views, likes, comment count, publish date, length, description, hashtags, sound, category, tags and channel for each Short (one extra request per Short). Off: fast mode with only ID, title, rounded views and thumbnail (plus the channel for channel inputs). The price per Short is the same.

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

YouTube interface language code sent with the requests (en, es, pt, de...). Counts are parsed most reliably in English; exact numbers from the details do not depend on it.

## `region` (type: `string`):

Two-letter country code that YouTube uses to pick regional results (US, GB, MX, BR, IN...). It also sets the country of the residential fallback proxy.

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

Apify datacenter proxy is enough in most runs. If YouTube starts blocking (HTTP 403/429 or consent pages twice in a row), the Actor moves to RESIDENTIAL proxy by itself for the rest of the run.

## Actor input object example

```json
{
  "channels": [
    "@NASA"
  ],
  "maxItems": 10,
  "channelSort": "latest",
  "includeDetails": true,
  "language": "en",
  "region": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `shorts` (type: `string`):

Every Short saved during the run (views, likes, comments, date, hashtags, channel)

## `summary` (type: `string`):

Counts per source, details fetched, proxy used and any errors

# 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": [
        "@NASA"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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": ["@NASA"],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/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": [
    "@NASA"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

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