# YouTube Shorts Scraper (views, likes, channels, search) (`scrapemole/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts from Shorts search and channel Shorts tabs: title, link, views, channel and subscribers, with optional full details (exact views, likes, comment count, publish date, duration, description, tags). No login or API key. Pay only per Short delivered.

- **URL**: https://apify.com/scrapemole/youtube-shorts-scraper.md
- **Developed by:** [ScrapeMole](https://apify.com/scrapemole) (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 $0.60 / 1,000 short delivereds

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: views, likes, channels and search

Scrape **YouTube Shorts** from **keyword searches** and **channel Shorts tabs** without an API key or quota. Every row has the Short's link, title, **views**, channel and thumbnail. Channel rows also carry the **subscriber count**. Turn on **full details** to add **likes, comment count, exact publish date, length, category, description and hashtags**.

**You only pay for Shorts delivered.** Channels without Shorts, channels that don't exist, invalid links and rate-limited requests are reported as clear error rows and never charged.

### Why this Shorts scraper

- **Real Shorts only.** Searches use YouTube's own *Shorts* filter, so you get Shorts, not regular videos that happen to be short. In our tests 25 of 25 search results were Shorts.
- **No browser, no API key.** It reads the same JSON the YouTube app loads, so a 50-Short search takes a few seconds.
- **Every Short from a channel.** Channel Shorts tabs are paged to the end (or to your limit), newest first.
- **Retries with backoff and a fresh IP** on rate limits. Residential IPs are used only as a capped fallback.
- **Clear errors**: `NOT_FOUND`, `NO_DATA` (for example, a channel with no Shorts), `INVALID_INPUT`, `BLOCKED`.

### What you get

| Field | Description |
|---|---|
| `videoId`, `url`, `title` | The Short (a `/shorts/` link) |
| `channelName`, `channelHandle`, `channelId`, `channelUrl` | Who published it |
| `channelSubscribers` | Channel sources |
| `viewCount`, `viewCountText` | Views as a number and as shown |
| `isShort`, `thumbnailUrl`, `position`, `sourceType`, `searchQuery` | Format and where it was found |
| `likeCount`, `commentCount`, `publishDate`, `durationSeconds`, `category`, `description`, `keywords` | **Full details** mode |

E-mail addresses in descriptions are replaced with `[email removed]`: we don't collect personal data.

### How to scrape YouTube Shorts

1. Add **search keywords** (for example `espresso`), **channels** (`@handle`, channel URL or ID) and/or single **Shorts** links.
2. Set **Max Shorts per search or channel** (default 50).
3. Optional: sort searches, filter by upload date, choose language and country, or turn on **Full details** for likes and exact dates.
4. Click **Start** and download JSON, CSV or Excel, or use the API.

#### Input example

```json
{
  "searchQueries": ["espresso", "latte art"],
  "channels": ["@mkbhd"],
  "maxResultsPerSource": 100,
  "scrapeVideoDetails": true
}
```

#### Output example (full details)

```json
{
  "status": "ok",
  "sourceType": "search",
  "searchQuery": "espresso",
  "videoId": "74J0uiZk29k",
  "url": "https://www.youtube.com/shorts/74J0uiZk29k",
  "title": "…",
  "channelName": "…",
  "viewCount": 1250000,
  "likeCount": 48000,
  "commentCount": 310,
  "publishDate": "2026-10-02T09:00:12-07:00",
  "durationSeconds": 38,
  "isShort": true
}
```

### Pricing

Pay per event, no start fee:

| Event | Free | Starter (Bronze) | Scale (Silver) | Business (Gold) |
|---|---|---|---|---|
| `video`: Short from a search or channel | $0.0015 | $0.001 | $0.0008 | $0.0006 |
| `video-details`: Short with likes, comments and exact date | $0.003 | $0.002 | $0.0016 | $0.0012 |

1,000 Shorts with full details cost $2.00 on the Starter plan. Errors and duplicates are free. Set a maximum cost per run and the Actor stops cleanly at that budget.

### Use cases

- **Trend and hook research:** which Shorts win for a keyword, and how many views they get.
- **Creator and influencer discovery:** Shorts channels in a niche, with subscriber counts.
- **Competitor tracking:** every Short a brand posts, with views and likes, on a schedule.
- **Datasets for AI:** titles, hashtags and engagement. Pair with the ScrapeMole YouTube Transcript Scraper for the spoken text.

### API, Python and AI agents

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("scrapemole/youtube-shorts-scraper").call(run_input={"searchQueries": ["espresso"], "maxResultsPerSource": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["url"], item.get("viewCount"))
```

Works with schedules, webhooks, Make, Zapier, n8n and Apify's MCP server for AI agents.

### FAQ

**Do I need a YouTube API key?** No key and no quota.

**Can I get regular videos too?** Use the ScrapeMole YouTube Scraper (search, channels, playlists) or the YouTube Channel Scraper. This Actor returns Shorts only.

**Why is `publishedText` empty in list mode?** YouTube doesn't show upload times for Shorts in lists. Turn on full details for the exact publish date.

**Is this legal?** The Actor collects publicly available video data and no personal data. You are responsible for how you use the data; check YouTube's terms and the laws that apply to you.

### More from ScrapeMole

ScrapeMole builds focused, reliable scrapers for public data: pay per result, no start fees, clear error rows that are never charged, and a `RUN_SUMMARY` on every run.

- [YouTube Transcript & Subtitles Scraper](https://apify.com/scrapemole/youtube-transcript-scraper)
- [Google Trends Scraper](https://apify.com/scrapemole/google-trends-scraper)
- [YouTube Scraper](https://apify.com/scrapemole/youtube-video-channel-scraper)
- [YouTube Comments Scraper](https://apify.com/scrapemole/youtube-comments-scraper)
- [Telegram Channel Scraper](https://apify.com/scrapemole/telegram-channel-scraper)
- [Amazon Product & Search Scraper](https://apify.com/scrapemole/amazon-product-scraper)
- [Google Jobs Scraper](https://apify.com/scrapemole/google-jobs-scraper)
- [YouTube Channel Scraper](https://apify.com/scrapemole/youtube-channel-scraper)
- [ATS Jobs Scraper: Greenhouse, Lever, Ashby, Workable](https://apify.com/scrapemole/ats-jobs-scraper)

Building an AI agent with its own wallet? The YouTube and Google Trends data is also sold per call over [x402](https://www.x402.org) (USDC on Base, no account): see [scrapemole.pages.dev](https://scrapemole.pages.dev). Questions or a missing field? Open an issue on this Actor. ScrapeMole is the maker of this Actor.

# Actor input Schema

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

Search YouTube Shorts like the Shorts filter in the search box. Returns Shorts in result order with views and title.

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

@handles (e.g. @mkbhd), channel URLs or channel IDs. Returns the channel's Shorts tab, newest first, with channel name and subscriber count on every row.

## `shorts` (type: `array`):

Shorts URLs (youtube.com/shorts/...) or video IDs. Always returns full details: exact views, likes, comment count, publish date, description and tags.

## `maxResultsPerSource` (type: `integer`):

Stop after this many Shorts for each search keyword and channel.

## `scrapeVideoDetails` (type: `boolean`):

Also open each Short to add exact views, likes, comment count, exact publish date, duration, description and tags. Shorts lists show rounded views and no date, so turn this on when you need them. Charged as a 'Short with details'.

## `sortBy` (type: `string`):

Order of search results.

## `uploadDate` (type: `string`):

Only Shorts uploaded in this period (YouTube's filter).

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

Language code for YouTube texts such as '3 days ago' (e.g. en, de, es). Keep 'en' if you use the parsed numbers and dates.

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

Two-letter country code. Affects search ranking and which videos are available.

## `maxConcurrency` (type: `integer`):

How many sources or videos to scrape at once.

## `maxRetries` (type: `integer`):

Retries for rate limits, timeouts and server errors, each with a fresh proxy IP.

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

Apify Proxy (datacenter) works well. If YouTube rate-limits, the Actor switches to residential IPs automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "espresso"
  ],
  "channels": [
    "@mkbhd"
  ],
  "maxResultsPerSource": 50,
  "scrapeVideoDetails": false,
  "sortBy": "relevance",
  "uploadDate": "any",
  "language": "en",
  "country": "US",
  "maxConcurrency": 4,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All dataset rows (status ok or error).

## `runSummary` (type: `string`):

JSON summary: processed/ok/failed counts, error codes, events charged, HTTP stats.

# 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 = {
    "searchQueries": [
        "espresso"
    ],
    "channels": [
        "@mkbhd"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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