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

🎥 YouTube Shorts Scraper instantly extracts Shorts data—titles, links, hashtags & more—so creators, marketers, and analysts can research trends fast. 🚀 Save time, boost insights, and scale content strategy with precision! 🔍

- **URL**: https://apify.com/solid-scraper/youtube-shorts-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Videos, Social media, SEO 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 🔍

**YouTube Shorts Scraper** is an Apify actor that extracts Shorts metadata from YouTube channels and saves structured results in your Apify dataset. If you’re looking for a **YouTube Shorts scraper tool** for lead generation, research, or content analysis, this **YouTube Shorts metadata scraper** helps you collect video-level details at scale—along with useful channel context—so you can move faster than manual work.

Whether you’re a marketer, data analyst, or researcher, this **YouTube Shorts scraper** automates gathering the information you need from **public web data**, saving you hours of manual work.

***

### Why choose YouTube Shorts Scraper?

| Feature | Benefit |
|---|---|
| ✅ All-in-one shorts extraction | Collects Shorts URLs and video details from channel Shorts feeds in one run |
| ✅ Reliability with built-in resilience | Includes retries and fallbacks for improved scraping stability |
| ✅ Structured output (dataset-ready) | Produces consistent JSON fields that are easy to analyze or import |
| ✅ Scale-friendly batching | Handles multiple input URLs and processes multiple Shorts per channel |
| ✅ Automation-friendly results | Saves each result immediately to the default dataset for safer long runs |
| ✅ Built-in proxy support | Works with Apify proxy configuration to help with reliable data collection |

***

### Key features

- 🔍 **YouTube Shorts metadata scraping**: Extracts Shorts title, view count, date, duration, likes, comments, and hashtags.
- 🌐 **Shorts URL support**: Accepts channel Shorts URLs (or a single Shorts URL) via `startUrls`.
- 🧠 **Channel context included**: Saves channel name, channel URL, username, description, subscriber count, and totals when available.
- 📦 **Structured JSON results**: Outputs a consistent object per Shorts video with clear field names for downstream workflows.
- 🛡️ **Resilient fetching**: Uses retries and robust fallbacks when extracting data.
- 💾 **Dataset live saving**: Each scraped result is pushed to the Apify dataset immediately during the run.
- 🔄 **Batch processing with limits**: Scrapes up to your specified `limit` per channel to keep runs predictable.
- 🏷️ **Hashtag extraction**: Extracts hashtags from the Shorts description and/or title.

***

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `startUrls` | ✅ | A list of YouTube channel Shorts URLs (e.g., `https://www.youtube.com/@AIDIGICHAOS/shorts`) or a single YouTube Shorts video URL. |
| `limit` | ❌ | Maximum number of Shorts to scrape per channel. Default is `30` (minimum is `1`). |

***

### Output

The actor saves each Shorts result as a JSON object into the default Apify dataset.

```json
{
  "title": "string",
  "type": "shorts",
  "id": "string",
  "url": "string",
  "thumbnailUrl": "string",
  "viewCount": 123,
  "date": "string",
  "likes": 456,
  "channelName": "string",
  "channelUrl": "https://www.youtube.com/channel/string",
  "channelUsername": "string",
  "channelId": "string",
  "channelDescription": "string",
  "channelAvatarUrl": "string",
  "channelTotalVideos": 0,
  "channelTotalViews": 0,
  "numberOfSubscribers": 0,
  "isChannelVerified": false,
  "inputChannelUrl": "string",
  "isAgeRestricted": false,
  "duration": "00:00:00",
  "commentsCount": 0,
  "order": 1,
  "commentsTurnedOff": false,
  "hashtags": ["#example"],
  "isPaidContent": false,
  "fromYTUrl": "string",
  "input": "string"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `title` | string | The Shorts title text found on the video page. |
| `type` | string | Always set to `"shorts"`. |
| `id` | string | The Shorts video identifier used to build the Shorts URL. |
| `url` | string | The full URL to the Shorts video. |
| `thumbnailUrl` | string | Thumbnail image URL (when found). |
| `viewCount` | number | View count for the Shorts video (cleaned to numeric). |
| `date` | string | null | Upload date (derived from microformat fields when available). |
| `likes` | number | Like count (cleaned to numeric). |
| `channelName` | string | Channel name associated with the Shorts video. |
| `channelUrl` | string | null | Channel page URL when `channelId` is available. |
| `channelUsername` | string | null | Channel username (when available from extracted channel metadata). |
| `channelId` | string | null | Channel identifier. |
| `channelDescription` | string | null | Channel description (when available). |
| `channelAvatarUrl` | string | null | Channel avatar image URL (when available). |
| `channelTotalVideos` | number | null | Total videos count for the channel (when available). |
| `channelTotalViews` | number | null | Total views count for the channel (when available). |
| `numberOfSubscribers` | number | null | Subscriber count for the channel (when available). |
| `isChannelVerified` | boolean | Always set to `false` in the current output payload. |
| `inputChannelUrl` | string | The starting URL you provided for the channel (or the detected input). |
| `isAgeRestricted` | boolean | Always set to `false` in the current output payload. |
| `duration` | string | null | Duration in `HH:MM:SS` format or another available duration representation. |
| `commentsCount` | number | Number of comments (cleaned to numeric; uses multiple fallbacks). |
| `order` | number | Shorts index within the scraped list for that input (starts from `1`). |
| `commentsTurnedOff` | boolean | Always set to `false` in the current output payload. |
| `hashtags` | array | List of hashtags extracted from the description and/or title. |
| `isPaidContent` | boolean | Always set to `false` in the current output payload. |
| `fromYTUrl` | string | Derived from the `startUrls` input to indicate the Shorts feed source. |
| `input` | string | The original input URL used for this run. |

*Note:* The actor pushes results as it goes, so you can export to JSON or CSV from the Apify dataset after the run completes (or even while it’s running).

***

### How to use YouTube Shorts Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the **Actors** page.

2. **Find YouTube Shorts Scraper**\
   Search for **YouTube Shorts Scraper** and open the actor details page.

3. **Go to the INPUT tab**\
   Use the built-in form to enter your `startUrls`.

4. **Add one or more channel Shorts URLs**\
   Paste URLs like `https://www.youtube.com/@AIDIGICHAOS/shorts`. You can also provide a single `shorts` video URL.

5. **Set the `limit` per channel**\
   Enter how many Shorts you want to scrape from each channel. The default is `30` (minimum `1`).

6. **(Optional) Proxy configuration**\
   The run uses `proxyConfiguration` internally. If proxy settings are not enabled, it defaults to Apify Proxy behavior.

7. **Click Run**\
   Start the actor and monitor logs. You’ll see progress per input URL and per Shorts video.

8. **Open OUTPUT (dataset results)**\
   After the run, open the default dataset to preview and export your scraped Shorts data (JSON/CSV).

No coding required—get accurate results in minutes with **YouTube Shorts scraper** automation.

***

### Advanced features & SEO optimization

- 🚀 **Engineered for YouTube Shorts scraper tool workflows**: Built for batch extraction of Shorts metadata scraper outputs, not just single-page scraping.
- 🔄 **Rate-limit friendly resilience**: Uses retries and fallbacks to improve completion rates during large runs.
- 🧾 **Input normalization by type**: Detects whether your input is a channel Shorts feed or a single Shorts URL and processes accordingly.
- 📝 **Detailed dataset-ready fields**: Structured output supports downstream analytics for **YouTube Shorts analytics scraper** use cases.
- 🌐 **Automation-friendly results**: Saves each video result immediately, making **YouTube Shorts automation tool** runs safer and easier to resume.

***

### Best use cases

- 📈 **Marketing teams building influencer shortlists**: Collect Shorts metadata (views, likes, comments) to shortlist creators for campaigns.
- 🧪 **Researchers analyzing content trends**: Scrape YouTube Shorts metadata scraper-style fields to study engagement patterns over time.
- 💼 **Sales and lead generation workflows**: Use the channel context (name, username, description) to enrich contact research pipelines.
- 🗂️ **Content audit & competitive analysis**: Batch scrape YouTube Shorts content scraper outputs to benchmark engagement and topics via hashtags.
- 🧰 **Data analysts creating datasets**: Turn scraped results into analysis-ready tables (views, likes, duration, upload date).
- 🧑‍💻 **Developer pipelines**: Feed structured JSON into your own processing or enrichment steps as part of a larger automation.
- 📰 **RSS-style monitoring & discovery**: Build “what’s new” lists by repeatedly running the **YouTube Shorts RSS scraper**-like workflow with updated `startUrls`.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `startUrls` accepts:
    - YouTube channel Shorts URLs (e.g., `https://www.youtube.com/@name/shorts`)
    - A single YouTube Shorts video URL
  - ✅ `limit` (integer, minimum `1`, default `30`)

- **Proxy Support**
  - ✅ Uses `proxyConfiguration` and is designed to work with Apify proxy configuration.
  - ✅ Built-in proxy support for more reliable scraping.

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks when fetching channel and video pages.
  - ✅ Designed to improve stability during longer runs.

- **Dataset Structure**
  - ✅ One dataset record per successfully scraped Shorts video
  - ✅ Records include fields like `title`, `url`, `viewCount`, `likes`, `commentsCount`, `hashtags`, and channel metadata fields

- **Rate Limits & Performance**
  - ⚠️ Performance depends on your `limit`, network conditions, and how quickly pages respond.
  - ✅ The actor inserts a polite delay between video requests.

- **Limitations**
  - ❌ Data completeness can vary when certain fields are not available on the page (some channel metrics may be missing).
  - ❌ Private/restricted content isn’t guaranteed—results rely on what’s accessible from public web pages.

***

### FAQ

#### Does YouTube Shorts Scraper work for a single Shorts video URL?

✅ Yes. If you pass a Shorts video URL in `startUrls`, the actor detects it and processes it as a single target, returning the same kind of structured Shorts metadata record.

#### What does the `limit` parameter control?

`limit` controls the maximum number of Shorts scraped per channel URL. For channel inputs, the actor collects Shorts URLs up to that limit and then scrapes details for each one.

#### Can I scrape multiple channels in one run?

✅ Yes. Add multiple items to `startUrls`. The actor will process each input and scrape up to `limit` Shorts per channel.

#### What kind of YouTube Shorts downloader outputs does it provide?

This actor is focused on scraping metadata and returning structured dataset records. It outputs video details like `title`, `url`, `thumbnailUrl`, `viewCount`, `likes`, `commentsCount`, and `hashtags`—useful if you’re building downstream “YouTube Shorts downloader” or “YouTube Shorts video downloader” workflows.

#### Do I need an API or Python to use it?

❌ No. You can use it directly in Apify Console by filling in `startUrls` and `limit`. The dataset output is already in JSON form and can be exported.

#### How do I export the results?

After the run finishes, open the default dataset in Apify Console and export the records. Since results are saved to the dataset as they’re scraped, you can also monitor progress during longer runs.

#### Is it legal to scrape publicly available data from YouTube?

✅ The actor collects information from **publicly accessible sources**. You’re responsible for following applicable laws (including GDPR/CCPA where relevant), platform policies, and any applicable terms about data usage.

***

### Support & feature requests

Want to improve **YouTube Shorts Scraper** or request enhancements to your **YouTube Shorts scraper tool** workflow? 💡\
Feature Requests can include additions like improved exports (CSV/JSON variants), more output fields, or adjustments to how results are normalized for analytics and CRM pipelines.

For help, reach out at <dataforleads@gmail.com>. Your feedback helps shape the roadmap for this **YouTube Shorts metadata scraper**.

***

*If you need a reliable **YouTube Shorts scraper** for metadata extraction at scale, this is built to help you get results faster—without the manual grind.*

***

### Disclaimer

This tool accesses **publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content.

You are responsible for ensuring your use complies with applicable laws (including GDPR/CCPA), platform terms, and any relevant regulations—especially for contact and outreach workflows.

For data removal requests, contact <dataforleads@gmail.com>. Use **YouTube Shorts Scraper** responsibly, ethically, and for legitimate purposes only.

# 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("solid-scraper/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("solid-scraper/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 solid-scraper/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

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