# Youtube Shorts Scraper (`scraperoka/youtube-shorts-scraper`) Actor

📹 YouTube Shorts Scraper pulls trending Shorts data fast—titles, views, hashtags & creators. ⚡ Great for market research, content ideas & competitor tracking. 🔎 Efficient, reliable scraping—built for growth teams.

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

## Pricing

from $1.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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 ⚡

Manually visiting channel pages to collect YouTube Shorts metadata wastes hours you don’t have. **YouTube Shorts Scraper** automatically scrapes Shorts details from one or more YouTube channels, saving marketers, recruiters, and growth teams time at scale. This YouTube Shorts scraper tool helps you scrape YouTube Shorts, including titles, thumbnails, view counts, engagement, and channel context in a single run. You can process multiple channels and capture structured results in minutes—great for bulk research, outreach lists, and content analytics workflows.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "title": "10 Editing Tricks You Can Use Today",
  "type": "shorts",
  "id": "abcdEFGhijk",
  "url": "https://www.youtube.com/shorts/abcdEFGhijk",
  "thumbnailUrl": "https://i.ytimg.com/vi/abcdEFGhijk/hqdefault.jpg",
  "viewCount": 125430,
  "date": "2025-05-10",
  "likes": 9876,
  "channelName": "CreativeEditsLab",
  "channelUrl": "https://www.youtube.com/channel/UC1234567890ABCDEF",
  "channelUsername": "CreativeEditsLab",
  "channelDescription": "Weekly Shorts on editing, motion design, and creator workflows.",
  "channelAvatarUrl": "https://yt3.googleusercontent.com/abc123",
  "channelTotalVideos": 240,
  "channelTotalViews": null,
  "numberOfSubscribers": 182000,
  "isChannelVerified": false,
  "inputChannelUrl": "https://www.youtube.com/@CreativeEditsLab/shorts",
  "isAgeRestricted": false,
  "duration": "00:00:45",
  "commentsCount": 612,
  "order": 1,
  "commentsTurnedOff": false,
  "hashtags": ["#editing", "#shorts", "#creator"],
  "isPaidContent": false,
  "fromYTUrl": "https://www.youtube.com/@CreativeEditsLab/shorts",
  "input": "https://www.youtube.com/@CreativeEditsLab/shorts"
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `title` | string | The Shorts title you can reuse in reporting, summaries, and content audits |
| `type` | string | Confirms the record type as `shorts` for easy filtering downstream |
| `id` | string | The Shorts video id for linking back to the exact asset |
| `url` | string | Direct link to the Shorts for verification and manual follow-up |
| `thumbnailUrl` | string | A ready-to-use thumbnail URL for dashboards and creator outreach previews |
| `viewCount` | number | How much reach the Shorts has accumulated (good for scoring and ranking) |
| `date` | string | Upload/publish date value as captured by the actor |
| `likes` | number | Engagement signal for creator performance comparisons |
| `channelName` | string | Creator brand name for building clean channel lists |
| `channelUrl` | string | Direct channel link for quick context in your workflow |
| `channelUsername` | string | null | Handle (when available) for consistent identity mapping |
| `channelDescription` | string | null | Bio/description text to support segmentation and niche classification |
| `channelAvatarUrl` | string | null | Avatar image URL for enriched reporting |
| `numberOfSubscribers` | number | null | Channel audience size to estimate potential impact |
| `commentsCount` | number | Conversation volume for content resonance checks |
| `hashtags` | array | Detected hashtags pulled from title and description to speed up topic analysis |
| `order` | number | Position within the scraped list so you can track processing order |
| `fromYTUrl` | string | The input channel URL context used to build the Shorts list |
| `input` | string | The actual starting URL you provided for this run |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why YouTube Shorts Scraper?

There are a lot of ways to pull data from YouTube — here’s what sets YouTube Shorts Scraper apart.

#### Shorts-first metadata extraction

YouTube Shorts Scraper focuses on Shorts records and returns structured fields like `title`, `thumbnailUrl`, `viewCount`, `likes`, and `duration`, making it practical for YouTube Shorts metadata scraper workflows and bulk reporting.

#### Channel context included (not just the video)

In addition to each Shorts video, the actor captures related channel details such as `channelName`, `channelUsername`, `channelDescription`, `numberOfSubscribers`, and `channelUrl`, which helps when you want more than just a link scraper.

#### Resilient scraping with retries and fallbacks

It includes retry handling and fallback extraction paths to improve reliability when some page data is missing or formatted differently. This keeps your “scrape YouTube Shorts” jobs producing consistent output.

#### Designed for automation and scale

You can feed in multiple `startUrls` and cap results with `limit`, letting you run automated YouTube Shorts scraper jobs for analytics, research, and outreach pipelines—without manual copy/paste.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "startUrls": [
    "https://www.youtube.com/@AIDIGICHAOS/shorts",
    "https://www.youtube.com/shorts/abcdEFGhijk"
  ],
  "limit": 30
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `startUrls` | ✅ | A list of YouTube channel Shorts URLs to scrape (or a single Shorts URL included as an entry) |
| `limit` | ⬜ | Maximum number of shorts to scrape per channel (default: `30`, minimum: `1`) |

***

### Core Capabilities

#### Scrape Shorts from channels (or single Shorts URLs)

YouTube Shorts Scraper accepts channel-style inputs (like `.../shorts` for a channel) and also detects a single Shorts URL when you provide one. This makes the tool handy for both bulk research and targeted YouTube shorts video downloader-style lookups.

#### Complete Shorts record fields for analytics

Each scraped Shorts item returns a consistent JSON object including `title`, `id`, `url`, `thumbnailUrl`, `viewCount`, `date`, `likes`, `commentsCount`, and `duration`. That “YouTube Shorts video extraction” output is ready for spreadsheets, dashboards, or downstream processing.

#### Channel metadata enrichment

For each Shorts item, the actor attaches channel-level context such as `channelDescription`, `numberOfSubscribers`, and `channelTotalVideos` when available. This improves quality for “YouTube Shorts API scraper”-style datasets where you want enrichment beyond the video itself.

#### Built-in resilience for real-world pages

It uses retries and fallback extraction when some fields are not present in the first parse. The goal is to keep your results usable even when pages vary.

#### Hashtag detection for faster topic research

Detected `hashtags` are extracted from the Shorts `description` and `title`. This supports use cases like YouTube Shorts analytics scraper workflows and quick topic clustering.

***

### Who Gets the Most Out of This

Here's how different teams put YouTube Shorts Scraper to work:

**Influencer and creator marketing teams** — Use the YouTube Shorts metadata scraper output to build creator shortlists with engagement context like `viewCount`, `likes`, `commentsCount`, and channel audience size. You can move from “finding creators” to “evaluating performance” without opening each Shorts page manually.

**Sales development and partnerships** — When you’re compiling outreach targets, this tool helps you scrape YouTube Shorts from relevant channels and keep channel-level details together with each Shorts URL, so your prospect lists stay consistent and easier to deduplicate.

**Content strategists and growth teams** — Use the extracted titles, hashtags, and duration to identify what themes and formats are performing across your competitor set. Then export the dataset and run your own analysis in the tool of your choice.

**Freelance researchers and data analysts** — You can automate YouTube Shorts search scraper tasks by providing multiple `startUrls`, capping output with `limit`, and exporting structured JSON for cleaning and analysis. It’s well suited for building repeatable datasets instead of one-off manual collection.

**Automation developers and data engineers** — Integrate the YouTube Shorts scraper tool into your pipelines using Apify dataset exports and API access, so your “scrape YouTube Shorts” jobs can run as part of scheduled refresh cycles for dashboards or BI workflows.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run YouTube Shorts Scraper from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open “YouTube Shorts Scraper”.
2. **Enter your inputs** — add your channel Shorts URLs (and optionally a single Shorts URL) in `startUrls`, and set `limit` if you want fewer than the default `30`.
3. **Configure proxy settings** — enable proxy support for better reliability on larger batches.
4. **Hit Run and watch the live log** — monitor progress as Shorts are processed and saved.
5. **View results in the dataset tab** — each Shorts record is pushed into the dataset as it’s completed.
6. **Export as JSON, CSV, or Excel** — download or connect your results to the next step in your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, YouTube Shorts Scraper plugs directly into your existing workflow.

Export formats include **JSON, CSV, and Excel**, available from the Apify dataset tab.

You can also use **Apify API access** to pull results programmatically, connect to tools like **Zapier** or **Make**, and trigger follow-up steps when the run completes using **webhooks**. For additional setup details, refer to Apify’s documentation at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

YouTube Shorts Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. There’s typically enough allowance on the free tier for several test runs, so you can validate the YouTube Shorts downloader and scraper output before scaling up. For bigger workflows, you can use Apify’s pay-as-you-go compute model and upgrade to higher plans when your volume grows. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting issues | Uses resilient request handling so jobs keep moving |
| Page variability | Applies fallback parsing when certain fields aren’t available |
| Request failures | Includes retry behavior for improved completion rates |
| Dataset readiness | Saves results as they are processed (so you don’t lose everything on an interruption) |
| Batch scale | Supports multiple `startUrls` with a per-channel `limit` cap |

Limitations: This actor focuses on publicly accessible Shorts and channel pages. If a page doesn’t expose the expected metadata, some fields may be `null` even though the Shorts record is still returned. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier on the platform, so you can try YouTube Shorts Scraper with a small test run before scaling.

#### Do I need to log in to YouTube to use this?

No. The actor is designed to work with publicly accessible data, without requiring a login for the run.

#### How accurate is the data?

The accuracy depends on what’s available on the public Shorts and channel pages at the time of scraping. It extracts values into the dataset fields such as `title`, `viewCount`, `likes`, and `commentsCount` when those data points are present.

#### How many results can I get per run?

You control this with the `limit` input. `limit` defines the maximum number of shorts to scrape per channel (minimum `1`, default `30`).

#### How often is the data updated / how fresh is it?

The dataset reflects the moment your run is executed. If you need fresher YouTube shorts metadata scraper data, schedule runs or re-run the actor on your cadence.

#### Is this legal? Does it comply with GDPR / CCPA?

YouTube Shorts Scraper is intended for **publicly available data**, but compliance (including GDPR/CCPA and any platform Terms) depends on your use case and handling of the data. You’re responsible for using the results lawfully and appropriately.

#### Can I export results to Google Sheets or Excel?

Yes. You can export directly from the Apify dashboard to JSON, CSV, or Excel. From there, you can move the dataset into your spreadsheet or automation workflow.

#### Can I run this on a schedule automatically?

Yes. You can schedule actor runs on Apify so your YouTube Shorts scraper tool refreshes datasets automatically.

#### Can I access this via API?

Yes. Apify supports API access so you can trigger runs and retrieve dataset results programmatically.

#### What happens if the actor hits an error?

If a specific request fails, retries and fallbacks help improve reliability. For each completed Shorts item, results are pushed to the dataset, so partial progress is preserved even if something fails later.

***

### Need Help or Have a Request?

Got a question about YouTube Shorts Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor and welcome requests like batch CSV upload improvements or webhook notifications on completion. If you’re building a YouTube Shorts scraper workflow and want to adjust the output for your pipeline, message us with your needs.

***

### Disclaimer & Responsible Use

*YouTube Shorts Scraper is the fastest, most reliable way to extract YouTube Shorts video and channel metadata — start your free run today.*

**publicly available data** is the basis for this actor’s results, and it does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your usage complies with GDPR, CCPA, applicable privacy laws, and platform Terms of Service. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `startUrls` (type: `array`):

List of YouTube channel shorts URLs (e.g., https://www.youtube.com/@AIDIGICHAOS/shorts or a single short URL).

## `limit` (type: `integer`):

Maximum number of shorts to scrape per channel.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@AIDIGICHAOS/shorts"
    }
  ],
  "limit": 30
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.youtube.com/@AIDIGICHAOS/shorts"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/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 = { "startUrls": [{ "url": "https://www.youtube.com/@AIDIGICHAOS/shorts" }] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@AIDIGICHAOS/shorts"
    }
  ]
}' |
apify call scraperoka/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

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