# YouTube Shorts Data Scraper (`code-node-tools/yt-shorts-data-scraper`) Actor YouTube Shorts Data Scraper extracts YouTube Shorts metadata by channel or keyword. Fast, concurrent, and low-bandwidth scraping with real-time dataset streaming for analytics, research, lead generation, and content discovery. - **URL**: https://apify.com/code-node-tools/yt-shorts-data-scraper.md - **Developed by:** [CodeNodeTools](https://apify.com/code-node-tools) (community) - **Categories:** Videos, Social media, Lead generation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.40 / 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. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use 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 Scrape **YouTube Shorts** data at scale — by channel or by search term — without the official YouTube API or any video downloads. The **YouTube Shorts Scraper** collects rich metadata for every Short (title, views, likes, comments, upload date, channel info, thumbnail and more) and streams it straight to your dataset. Just give it a [YouTube](https://www.youtube.com) channel handle or a search keyword and set how many Shorts you want. Built on the Apify platform, it comes with proxy rotation, scheduling, a clean API, monitoring, and integrations out of the box — so a one-line input turns into reliable, structured data you can export anywhere. ### What can the YouTube Shorts Scraper do? - 🎯 **Scrape Shorts by channel** — pass a username (without `@`) or a channel URL (e.g. `https://www.youtube.com/c/Apify`). - 🔎 **Scrape Shorts by search term** — find Shorts across YouTube for any keyword, no channel needed. - ⚡ **Fast and concurrent** — extracts many Shorts in parallel with a configurable concurrency limit. - 🚿 **Streaming output** — results land in your dataset the moment they're scraped, so you can consume them while the run continues. - 💸 **Low bandwidth by design** — metadata only, never video files. A `liteMode` option strips the run down to the cheapest possible fetch. - 📅 **Filter and sort** — limit results, filter by upload date, and sort channel Shorts by newest, most popular, or oldest. - 🌍 **Proxy rotation** — uses Apify residential proxies to scrape YouTube reliably. - 📦 **Export anywhere** — download as JSON, CSV, Excel, or HTML, or pull via API. ### What data can the YouTube Shorts Scraper extract? | Field | Description | | ----------------------------------- | --------------------------------------------------- | | `title` | Title of the Short | | `url` | Direct link to the Short (`youtube.com/shorts/...`) | | `viewCount` | Number of views | | `likeCount` | Number of likes | | `commentCount` | Number of comments | | `uploadDate` | Publication date (`YYYY-MM-DD`) | | `duration` | Length in seconds | | `channel` / `channelUrl` | Channel name and link | | `channelFollowerCount` | Subscriber count of the channel | | `description`, `tags`, `categories` | Text metadata | | `thumbnail`, `width`, `height` | Thumbnail URL and video dimensions | ### Why scrape YouTube Shorts data? YouTube Shorts is one of the fastest-growing short-form video formats, and its public metadata is a goldmine for: - 📈 **Creator and competitor analysis** — track which Shorts perform best by views and engagement. - 🧠 **Content research** — discover trending topics and formats in any niche via search-term scraping. - 📊 **Social media monitoring** — follow a channel's output over time on a schedule. - 🤖 **Datasets for AI/ML** — build training or analytics datasets of short-form video metadata. ### How to scrape YouTube Shorts You can run the YouTube Shorts Scraper in a few clicks — no coding required: 1. Click **Try for free** to open the YouTube Shorts Scraper. 2. Add one or more channels under **Name(s) of the channel**, or enter a **Search term**. 3. Set **Maximum number of shorts** to control how many results you get. 4. (Optional) Set **Scrape shorts published after [date]** and choose a **Sort** order. 5. Click **Start** and watch results stream into the **Output** tab. 6. Export your data as JSON, CSV, Excel, or HTML — or grab it through the Apify API. ### How much does it cost to scrape YouTube Shorts? This Actor uses a **pay-per-event** pricing model, so you pay for the data you actually get rather than for runtime. The main charge is per Short written to your dataset, with a small per-run start fee and an optional surcharge when you filter by date. To keep costs down: - Use **`liteMode`** when you only need core fields (id, title, views, thumbnail) — it uses almost no proxy bandwidth. - Keep **`maxResultsShorts`** tight to scrape only what you need. - `NEWEST` sorting is the cheapest because it stops as soon as it has enough results. Check the pricing shown on the Actor's page for exact per-1,000-result rates on your plan. ### Input The YouTube Shorts Scraper has the following input options. Click the **Input** tab for the interactive form. | Field | Type | Description | | --------------------- | ------- | ----------------------------------------------------------------------------------------------- | | `channels` | array | Channel usernames (without `@`) or links. Required unless `searchTerm` is set. | | `searchTerm` | string | Search YouTube for Shorts matching this term. If set, `channels` is optional. | | `maxResultsShorts` | integer | Max Shorts per channel / search term. | | `oldestPostDate` | string | Only Shorts uploaded on/after this date (`YYYY-MM-DD` or a number of days). Forces NEWEST sort. | | `sortChannelShortsBy` | string | `NEWEST`, `POPULAR`, or `OLDEST` (channel mode only). | | `liteMode` | boolean | Return lightweight fields only — the cheapest, lowest-bandwidth option. | | `maxConcurrency` | integer | Number of Shorts to extract in parallel. | | `proxyConfiguration` | object | Proxy settings. Defaults to Apify residential. | #### Input example ```json { "channels": ["MrBeast"], "maxResultsShorts": 20, "oldestPostDate": "2026-01-01", "sortChannelShortsBy": "NEWEST", "liteMode": false, "maxConcurrency": 10, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } } ```` ### Output You can download the dataset extracted by the YouTube Shorts Scraper in various formats such as JSON, CSV, Excel, or HTML. Here's a simplified example of one Short scraped from the input above: ```json { "id": "y1UVAtHALaA", "url": "https://www.youtube.com/shorts/y1UVAtHALaA", "title": "I Surprised a Random Subscriber With $10,000", "viewCount": 231128819, "likeCount": 5141203, "commentCount": 61000, "uploadDate": "2026-05-29", "duration": 35, "channel": "MrBeast", "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA", "channelFollowerCount": 504000000, "thumbnail": "https://i.ytimg.com/vi/y1UVAtHALaA/maxresdefault.jpg", "width": 2160, "height": 3840, "isShort": true } ``` In `liteMode`, only `id`, `url`, `title`, `duration`, `viewCount`, `channel`, `thumbnail` and `isShort` are returned. ### Tips for scraping YouTube Shorts - 🏎️ Increase `maxConcurrency` for faster runs on large channels; lower it if you hit rate limits. - 💰 Combine `liteMode` with a small `maxResultsShorts` for the cheapest possible monitoring runs. - 📅 Use `oldestPostDate` (e.g. `7` for the last week) to scrape only recent Shorts on a schedule. - 🔁 Schedule the Actor to track a channel's Shorts over time and feed the data into Slack, Google Sheets, or your database via Apify integrations. ### Frequently asked questions #### Is it legal to scrape YouTube Shorts? Our scrapers are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our scrapers, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. #### Do I need the YouTube API to scrape Shorts? No. The YouTube Shorts Scraper works without the official YouTube Data API, so there are no API keys, quotas, or Google Cloud setup to manage. #### Can I scrape Shorts by keyword instead of by channel? Yes. Provide a `searchTerm` and leave `channels` empty. Search results are filtered to short-form videos on a best-effort basis. #### Why are POPULAR and OLDEST sorting more expensive than NEWEST? YouTube doesn't let tools re-sort a channel's Shorts tab, so for `POPULAR` and `OLDEST` the Actor must enumerate the full Shorts list before sorting. `NEWEST` is native and stops early, making it the fastest and cheapest option. #### Some Shorts are missing from search results — why? YouTube search isn't Shorts-specific, so the Actor filters candidates down to short-form videos (≤ 180 seconds, vertical). A few near-misses can be filtered out. For complete coverage of a creator, scrape by channel instead. #### Where can I get help or report a bug? Open the **Issues** tab on the Actor's page. We welcome feedback, feature requests, and bug reports, and we're happy to discuss custom solutions. # Actor input Schema ## `channels` (type: `array`): Enter a username of a channel (without @ sign) or a link to it (e.g. https://www.youtube.com/c/Apify). Required unless 'searchTerm' is provided. ## `searchTerm` (type: `string`): Search YouTube for Shorts matching this term. If provided, 'channels' is not required. Best-effort: results are filtered to short-form videos (<= 180s). ## `maxResultsShorts` (type: `integer`): Limit the number of Shorts videos you want to crawl from the channel (or per search term). ## `oldestPostDate` (type: `string`): Only posts uploaded after or on this date will be scraped. Alternatively, specify how old the scraped videos should be in days. Putting 1 day will get you only today's posts, 2 days - yesterday's and today's, and so on. Note: if you select this, the sorting parameter is auto-reset to NEWEST. ## `sortChannelShortsBy` (type: `string`): Maps to the three sorting buttons on the top of the channel shorts page. Ignored for search-term runs. ## `liteMode` (type: `boolean`): Skip the per-video detail pass and return only lightweight metadata (id, url, title, views, thumbnail) from the cheap flat listing. Dramatically reduces proxy bandwidth and cost, at the expense of fields like description, likes, exact upload date and tags. ## `maxConcurrency` (type: `integer`): Number of videos to extract metadata for in parallel. Higher is faster but uses more resources and may trigger rate limiting. ## `proxyConfiguration` (type: `object`): Proxy settings. Residential proxies are strongly recommended for YouTube (datacenter IPs are usually blocked). Residential costs more bandwidth, so switch to datacenter only if it works for your targets. ## Actor input object example ```json { "channels": [ "MrBeast" ], "maxResultsShorts": 20, "oldestPostDate": "2024-01-01", "sortChannelShortsBy": "NEWEST", "liteMode": false, "maxConcurrency": 10, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `dataset` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "channels": [ "MrBeast" ] }; // Run the Actor and wait for it to finish const run = await client.actor("code-node-tools/yt-shorts-data-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "channels": ["MrBeast"] } # Run the Actor and wait for it to finish run = client.actor("code-node-tools/yt-shorts-data-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).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": [ "MrBeast" ] }' | apify call code-node-tools/yt-shorts-data-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=code-node-tools/yt-shorts-data-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "YouTube Shorts Data Scraper", "description": "YouTube Shorts Data Scraper extracts YouTube Shorts metadata by channel or keyword. Fast, concurrent, and low-bandwidth scraping with real-time dataset streaming for analytics, research, lead generation, and content discovery.", "version": "0.1", "x-build-id": "jZxx2YhkAp0fmGM5G" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/code-node-tools~yt-shorts-data-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-code-node-tools-yt-shorts-data-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/code-node-tools~yt-shorts-data-scraper/runs": { "post": { "operationId": "runs-sync-code-node-tools-yt-shorts-data-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/code-node-tools~yt-shorts-data-scraper/run-sync": { "post": { "operationId": "run-sync-code-node-tools-yt-shorts-data-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "channels": { "title": "Name(s) of the channel", "type": "array", "description": "Enter a username of a channel (without @ sign) or a link to it (e.g. https://www.youtube.com/c/Apify). Required unless 'searchTerm' is provided.", "items": { "type": "string" } }, "searchTerm": { "title": "Search term", "type": "string", "description": "Search YouTube for Shorts matching this term. If provided, 'channels' is not required. Best-effort: results are filtered to short-form videos (<= 180s)." }, "maxResultsShorts": { "title": "Maximum number of shorts per search term", "minimum": 1, "maximum": 999999, "type": "integer", "description": "Limit the number of Shorts videos you want to crawl from the channel (or per search term).", "default": 3 }, "oldestPostDate": { "title": "Scrape shorts published after [date]", "type": "string", "description": "Only posts uploaded after or on this date will be scraped. Alternatively, specify how old the scraped videos should be in days. Putting 1 day will get you only today's posts, 2 days - yesterday's and today's, and so on. Note: if you select this, the sorting parameter is auto-reset to NEWEST." }, "sortChannelShortsBy": { "title": "Sort shorts by", "enum": [ "NEWEST", "POPULAR", "OLDEST" ], "type": "string", "description": "Maps to the three sorting buttons on the top of the channel shorts page. Ignored for search-term runs.", "default": "NEWEST" }, "liteMode": { "title": "Lite mode (minimize bandwidth)", "type": "boolean", "description": "Skip the per-video detail pass and return only lightweight metadata (id, url, title, views, thumbnail) from the cheap flat listing. Dramatically reduces proxy bandwidth and cost, at the expense of fields like description, likes, exact upload date and tags.", "default": false }, "maxConcurrency": { "title": "Max concurrency", "minimum": 5, "maximum": 18, "type": "integer", "description": "Number of videos to extract metadata for in parallel. Higher is faster but uses more resources and may trigger rate limiting.", "default": 10 }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "Proxy settings. Residential proxies are strongly recommended for YouTube (datacenter IPs are usually blocked). Residential costs more bandwidth, so switch to datacenter only if it works for your targets.", "default": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```