# YouTube Trending Shorts Scraper (`data_minds/youtube-trending-shorts-scraper`) Actor

Collect trending YouTube Shorts for any search term, hashtag or link. Get title, link, views, likes, comments, channel, publish date, length and keywords. Filter by country and time, sort by popularity. No login. Bulk input, auto proxy. Export JSON, CSV or Excel.

- **URL**: https://apify.com/data_minds/youtube-trending-shorts-scraper.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 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/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

### What is YouTube Trending Shorts Scraper?

**YouTube Trending Shorts Scraper** is a YouTube trending shorts scraper that collects the Shorts people watch for any search term, hashtag or YouTube hashtag link. Add your topics, choose a country, a time window and a sort order, and get one row per Short with title, link, views, likes, comments, publish date, length, keywords and channel. **From $0.0022 per Short on the Gold plan ($2.20 per 1,000)**, platform usage billed in addition. [🚀 Try it free](https://apify.com/data_minds/youtube-trending-shorts-scraper)

- **Trend research:** run YouTube Shorts trend analysis to see which formats gain views in your niche this week, this month or this year.
- **Hashtag research:** compare how Shorts under different hashtags perform, which makes YouTube Shorts hashtag research quick before you pick yours.
- **Content ideas:** get YouTube Shorts content ideas from the titles and keywords of top Shorts, and use them for YouTube Shorts content research.
- **Creator discovery:** YouTube Shorts creator discovery lists the channels behind popular Shorts, with handle and link, for outreach.
- **Engagement benchmarking:** compare views, likes and comments across topics and countries for YouTube Shorts engagement analysis.
- **Competitor analysis:** watch the Shorts in rival niches for YouTube Shorts competitor research.

Because it runs on Apify, you also get an API, scheduling, webhooks, integrations and export to JSON, CSV, Excel, XML or HTML. Visit [YouTube](https://www.youtube.com) to find the topics and hashtags you want to track.

#### What can YouTube Trending Shorts Scraper do?

- 🔎 **Search in bulk:** add search terms, hashtags or YouTube hashtag and search links, one per line. Each entry is collected separately.
- 🌍 **Rank by country:** choose a two-letter country code such as US, GB, IN, DE or BR.
- 📅 **Filter by upload time:** keep Shorts from the last hour, today, this week, this month, this year or any time.
- 🔃 **Sort your way:** order Shorts by popularity, relevance or newest.
- 💬 **Optional comment counts:** turn them off when you want a faster run.
- ⚡ **Live results:** every Short is saved to the dataset as soon as it is ready.
- 📊 **Ready-made tables:** switch between overview, engagement, channel and details views.

Analysts use it as a YouTube Shorts trend scraper and YouTube Shorts finder, while agencies run it as a bulk YouTube Shorts scraper and hand the rows to clients.

Results arrive as a YouTube Shorts dataset that works as a YouTube Shorts extractor for spreadsheets and as a YouTube Shorts analytics scraper for dashboards.

Research teams treat it as a YouTube Shorts research tool, and with a schedule it becomes a YouTube Shorts monitoring tool for a hashtag.

Marketers use it as a YouTube trends scraper, or as a viral YouTube Shorts scraper pointed at topics such as #viral.

Type keywords and it works as a YouTube Shorts search scraper. Type hashtags and it becomes a YouTube hashtag Shorts scraper.

Every row is ready YouTube Shorts trending data, so the YouTube Shorts data extractor step needs no extra work, and you can find viral Shorts at a glance.

***

### What data can YouTube Trending Shorts Scraper extract?

Each dataset row is one Short. The fields below are in every row.

| Data | Fields |
|---|---|
| 🎬 Short | `id`, `url`, `title`, `description`, `thumbnailUrl` |
| 👀 Views | `viewCount`, `viewCountText` |
| 👍 Likes | `likeCount`, `likeCountText` |
| 💬 Comments | `commentCount`, `commentCountText` |
| 📅 Publish date | `publishedAt` (ISO 8601 with the video's own offset), `publishedDateText` |
| 📺 Channel | `channel` with `id`, `url`, `handle` and `title` |
| 🔖 Keywords | `keywords` (the keywords set by the creator) |
| 🕒 Length | `durationMs`, `durationText` (hh:mm:ss) |
| 🔎 Search | `query` (the search term or hashtag the Short was found under) |

Use the YouTube Shorts view count to rank topics, and the YouTube Shorts like count to see what resonates.

The YouTube Shorts comment count shows how much discussion a Short starts.

Each row also has YouTube Shorts channel data and the YouTube Shorts publish date. The creator's YouTube Shorts keywords are included too.

> **Note:** Fields that YouTube does not provide for a Short are empty, for example `description`, `likeCount` or `channel.handle`. `commentCount` and `commentCountText` are empty when `includeCommentCount` is off or comments are disabled.

#### What data can't YouTube Trending Shorts Scraper extract?

- Comment text and replies: you get the comment count only.
- Subscriber counts and other channel statistics: you get the channel id, handle, link and title. For channel-level Shorts data, try [YouTube Shorts Scraper](https://apify.com/data_minds/youtube-shorts-scraper).
- Long videos: only Shorts are collected.

***

### How to scrape YouTube trending Shorts

The Actor is designed for an easy start, even if you have never extracted data from the web before.

1. [Create a free Apify account](https://console.apify.com/sign-up) with your email.
2. Open [YouTube Trending Shorts Scraper](https://apify.com/data_minds/youtube-trending-shorts-scraper).
3. Add search terms, hashtags or YouTube hashtag links to `urls`, one per line.
4. Set `maxItems` to how many Shorts you want for each entry.
5. Pick the `country`, the `timeRange` and the `sort` order.
6. Turn `includeCommentCount` off if you want a faster run.
7. Click **Start**, then download your data in JSON, CSV, Excel, XML or HTML.

***

### How much does it cost to scrape YouTube Shorts?

This Actor uses **pay-per-event** pricing: you pay for each Short saved to the dataset. Platform usage is billed in addition. Prices depend on your Apify plan:

| Plan | Price per Short | Price per 1,000 Shorts |
|---|---|---|
| Free | $0.003 | $3.00 |
| Bronze | $0.0027 | $2.70 |
| Silver | $0.0025 | $2.50 |
| Gold | $0.0022 | $2.20 |

Each run also has a start event of $0.00005 per GB of memory, minimum one. The default memory is 1 GB, so a run starts with 1 event, which is $0.00005.

For example, 1,000 Shorts on the Gold plan cost $2.20, plus the $0.00005 start event and platform usage. On the Free plan, 100 Shorts cost $0.30 before platform usage.

#### Is scraping YouTube Shorts free?

You can start for free. The Apify Free plan includes $5 in monthly credit, which covers about 1,666 Shorts at the Free price of $0.003 per Short, before platform usage. See the [pricing tab](https://apify.com/data_minds/youtube-trending-shorts-scraper/pricing) for all events.

***

### Input

To run the Actor you need **`urls`** (and the network setting, which is prefilled). Set the input in the Actor's interface or send it as JSON through the API. This example collects 10 Shorts for each of two entries from the last week:

```json
{
  "urls": ["#viral", "https://www.youtube.com/hashtag/funny"],
  "maxItems": 10,
  "includeCommentCount": true,
  "country": "US",
  "timeRange": "week",
  "sort": "popularity",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

See the [input schema](https://apify.com/data_minds/youtube-trending-shorts-scraper/input-schema) for the full description of every field.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `urls` | array | Yes | prefill `#viral` and a hashtag link | Search terms, hashtags or YouTube hashtag/search links, one per line. |
| `maxItems` | integer | No | 10 (50 if the field is left out of an API call) | Shorts to collect for each entry (0 to 100000). 0 collects everything available. |
| `includeCommentCount` | boolean | No | `true` | Adds the number of comments to every Short. Turn off for a faster run. |
| `country` | string | No | `US` | Two-letter country code the results are ranked for. |
| `timeRange` | string | No | `week` | `hour`, `today`, `week`, `month`, `year` or `any`. |
| `sort` | string | No | `popularity` | `popularity`, `relevance` or `newest`. |
| `proxyConfiguration` | object | Yes | `{"useApifyProxy": true}` | Proxy settings for the run. The form prefills this field, so leave it as it is unless you need your own settings. |

#### urls

Use a plain search term, a hashtag or a YouTube hashtag or search link. Hashtag links become a lower-case hashtag, and the same entry listed twice is collected once.

- ✅ Good: `minecraft`, `#viral`, `https://www.youtube.com/hashtag/funny`
- ❌ Bad: a link to a single video or to a channel page

#### maxItems

This limit applies to each entry, not to the whole run. With three entries and `maxItems` set to 10, you can get up to 30 Shorts.

> **Warning:** `0` collects everything available for every entry, which can mean a long and costly run. Start with a small number and raise it once the results look right.

#### timeRange

Only Shorts uploaded within this window are returned. `any` removes the date filter.

- ✅ Good: `week` for fresh trends, `year` or `any` for rarer topics
- ❌ Bad: `hour` for a narrow topic, which often returns nothing

***

### Output

Results appear in the run's **Output** or **Storage** tab as a dataset. View them as a table or JSON, pick the fields you need and download them in JSON, CSV, Excel, XML or HTML. You can export YouTube Shorts to CSV with one click. The dataset has four views: Overview, Engagement, Channel and Details. A run summary is also saved to the key-value store under `RUN_SUMMARY`.

#### JSON example

Results for the input example above:

```json
{
  "id": "abc123XYZ00",
  "url": "https://example.com/watch?v=abc123XYZ00",
  "title": "Example Short #viral",
  "description": "Example description text",
  "thumbnailUrl": "https://example.com/thumbnail.jpg",
  "viewCount": 1250000,
  "viewCountText": "1,250,000",
  "likeCount": 84000,
  "likeCountText": "84000",
  "commentCount": 1600,
  "commentCountText": "1.6K",
  "publishedAt": "2026-10-28T00:53:05-07:00",
  "publishedDateText": "Oct 28, 2026",
  "channel": {
    "id": "UCexample0000000000000000",
    "url": "https://example.com/@examplechannel",
    "handle": "examplechannel",
    "title": "Example Channel"
  },
  "keywords": ["viral", "funny"],
  "durationMs": 12000,
  "durationText": "00:00:12",
  "query": "#viral"
}
```

The run summary in the key-value store holds `totalSaved`, `searches` (the status and number of Shorts for each entry), `notStarted`, `skippedShorts`, `requests` and `durationSeconds`.

#### Notes and limitations

- Only Shorts are collected, and a Short found under several entries is saved once, under the first entry that found it.
- Private or removed Shorts are skipped. They are listed in `skippedShorts` and are not charged.
- A search stops when YouTube has no more matching Shorts to list or a built-in page limit is reached, so a broad topic can return fewer Shorts than `maxItems`.
- Popularity sorting is applied to the Shorts as they are collected, in groups. For a strict ranking by views across the whole run, sort the exported data by `viewCount`.
- Views, likes and comment counts are the public numbers shown at the time of the run.
- If your spending limit is reached, the run stops and keeps the results saved so far.

***

### Tips and advanced usage

- Start with a small `maxItems` to check that the topic returns what you expect, then raise it.
- Use `newest` with `today` or `week` and a schedule to watch for fresh Shorts under a hashtag.
- Widen `timeRange` to `month`, `year` or `any` when a niche topic returns few Shorts.
- Turn `includeCommentCount` off when you only need views and likes.
- Collect YouTube Shorts by country: run the same hashtags with different `country` codes to compare markets.
- Keep `timeRange` on `week` to get YouTube Shorts uploaded this week.
- Sort by `popularity` to find the most viewed YouTube Shorts and spot trending Shorts by hashtag.
- List one topic per line for YouTube Shorts topic research and YouTube Shorts niche research.
- Schedule YouTube Shorts monitoring from the Apify Console to watch a hashtag over time.

***

### Integrations and API

#### Can I use YouTube Trending Shorts Scraper as an API?

Yes. The [Apify API](https://docs.apify.com/api/v2) gives you programmatic access to this Actor: start runs, schedule them and fetch results. Use the `apify-client` package for Node.js or Python. See the [API tab](https://apify.com/data_minds/youtube-trending-shorts-scraper/api) for ready-to-use code.

#### How to scrape YouTube Shorts with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("data_minds/youtube-trending-shorts-scraper").call(run_input={
    "urls": ["#viral", "https://www.youtube.com/hashtag/funny"],
    "maxItems": 10,
    "includeCommentCount": True,
    "country": "US",
    "timeRange": "week",
    "sort": "popularity",
    "proxyConfiguration": {"useApifyProxy": True},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Can I integrate YouTube Trending Shorts Scraper with other apps?

Yes. Connect it with Make, Zapier, Google Sheets, Slack and more through [Apify integrations](https://apify.com/integrations). Use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger an action when a run finishes, and schedule runs to keep your trending Shorts data fresh.

#### Can I use YouTube Trending Shorts Scraper with AI agents (MCP)?

Yes. Connect the Actor to Claude and other AI assistants through the Apify MCP server. Open the [MCP tab](https://apify.com/data_minds/youtube-trending-shorts-scraper/api/mcp) for setup steps.

***

### Other YouTube Shorts and search scrapers

| Actor | What it does |
|---|---|
| 🎥 [YouTube Shorts Scraper](https://apify.com/data_minds/youtube-shorts-scraper) | Collects Shorts from any channel you list: views, likes, comments, hashtags, subtitles and full channel details. |
| 🔖 [YouTube Hashtag Search Scraper](https://apify.com/data_minds/youtube-hashtag-search-scraper) | Collects videos and Shorts posted under any YouTube hashtag, with titles, views, channels, publish dates and descriptions. |
| 🔍 [YouTube Search API](https://apify.com/data_minds/youtube-search-api) | Searches YouTube for videos, channels and playlists with enriched engagement, channel and transcript data. |

***

### FAQ

#### Is it legal to scrape YouTube Shorts?

Scraping publicly available data is generally considered legal, but you must respect personal data rules such as GDPR, copyright and YouTube's terms. Only collect personal data with a legitimate reason. This is not legal advice, so read [Apify's guide to web scraping legality](https://blog.apify.com/is-web-scraping-legal/) and consult a lawyer.

#### How does YouTube Trending Shorts Scraper work?

You give it search terms, hashtags or hashtag links, plus a country, a time window and a sort order. It returns one row per Short with views, likes, comments, publish date, length, keywords and channel details. Each Short is saved as soon as it is ready, and the run stops at your limit.

#### Why scrape trending YouTube Shorts data?

Trending Shorts data shows which topics, hashtags and formats attract views right now, so you can plan content, benchmark rivals and find creators without copying numbers by hand. Marketers, agencies and creators use it for trend research, and a scheduled run keeps a spreadsheet or dashboard current.

#### Why am I getting fewer Shorts than expected?

Fewer results usually mean your topic has few Shorts inside the chosen time window, or YouTube lists no more for that search. Some Shorts may also be private or removed. Try a wider `timeRange` such as `month` or `any`, a broader search term, or another `country`, then run again.

#### How to find trending YouTube Shorts by country or hashtag?

Yes. Enter a hashtag such as `#viral` or a hashtag link in `urls` and set `country` to a two-letter code such as US, IN or BR. The results are ranked for that country within your chosen time window, and `query` shows which entry each Short was found under.

#### Do I need a YouTube account to use it?

No. You only need an Apify account to run the Actor. There is no YouTube login, cookie or key field in the input, so you add your searches, choose the options and click Start. You can run it from the Apify Console, through the API or on a schedule.

#### Is YouTube Trending Shorts Scraper not working?

If a run fails or returns nothing, check the log and the `RUN_SUMMARY` record, which has a note for each search. Make sure the term has Shorts in your time window. If the problem remains, open the [Issues tab](https://apify.com/data_minds/youtube-trending-shorts-scraper/issues/open) and describe your input, and we will look into it.

***

### Support and feedback

Found a bug or have a feature request? Please create an issue on the [Issues tab](https://apify.com/data_minds/youtube-trending-shorts-scraper/issues/open).

Need a **custom solution** or more data? Contact us at hello.dataminds@gmail.com.

Built and maintained by the [data_minds team](https://apify.com/data_minds) on Apify.

This Actor is an independent tool and is not affiliated with or endorsed by YouTube or Google. It collects publicly available data, and you are responsible for using it in line with applicable laws and the platform's terms.

# Changelog

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

# Actor input Schema

## `urls` (type: `array`):

One entry per line: a search term (minecraft), a hashtag (#viral) or a YouTube hashtag/search page URL such as https://www.youtube.com/hashtag/funny. Add as many as you like; each one is collected separately.

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

Stop after this many Shorts for each entry. Use 0 to collect everything available.

## `includeCommentCount` (type: `boolean`):

Adds the number of comments to every Short. Turn off for a faster run.

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

Two-letter country code the results are ranked for, for example US, GB, IN, DE or BR.

## `timeRange` (type: `string`):

Only Shorts uploaded within this window are returned. Any time removes the date filter.

## `sort` (type: `string`):

Popularity orders Shorts by views, Relevance keeps the search ranking, Newest orders by upload time.

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

Optional proxy settings for the run.

## Actor input object example

```json
{
  "urls": [
    "#viral",
    "https://www.youtube.com/hashtag/funny"
  ],
  "maxItems": 10,
  "includeCommentCount": true,
  "country": "US",
  "timeRange": "week",
  "sort": "popularity",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All Shorts, overview table.

## `engagement` (type: `string`):

Views, likes and comments per Short.

## `channel` (type: `string`):

Channel details per Short.

## `details` (type: `string`):

Description, keywords, publish date and length per Short.

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

Totals and status for each search.

# 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 = {
    "urls": [
        "#viral",
        "https://www.youtube.com/hashtag/funny"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_minds/youtube-trending-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 = {
    "urls": [
        "#viral",
        "https://www.youtube.com/hashtag/funny",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/youtube-trending-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 '{
  "urls": [
    "#viral",
    "https://www.youtube.com/hashtag/funny"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_minds/youtube-trending-shorts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_minds/youtube-trending-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/mUlx7IsKmKp6cGSlC/builds/RbEsBcgisxedE3biF/openapi.json