YouTube Shorts Scraper: Up to 1,000 Free Results a Month (2026)

Each Short record comes with a dedicated set of 12 fields, including engagement counts and upload metadata. This Actor extracts views, likes, commentsCount, and channel-level attributes directly from YouTube Shorts tabs or hashtag pages. It can be tried free using monthly platform credits. Built for video analysts, marketing teams, and content researchers looking for raw performance metrics. This is not for teams that require creator email addresses, as contact details are not included in the output.

Try it: open YouTube Shorts Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try YouTube Shorts Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of YouTube Shorts Scraper a month, before run-start charges and platform usage.

The example request further down caps maxShorts at 3, so a first run returns at most 3 results and costs at most $0.015 in result charges. That is enough to see the real shape of the data before deciding anything.

YouTube Shorts Scraper was last updated on 2026-06-22. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 680,173 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run YouTube Shorts Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.05 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The result cap control, maxShorts, dictates your primary usage charges alongside the total count of channel URLs or hashtags provided. Adding nested channel details to each record does not alter the per-result pricing. Test initial parameters by keeping maxShorts low, such as 3 records, before running large discovery jobs.

How do you run YouTube Shorts Scraper from the API?

None of its 6 controls is strictly required, so the defaults below produce a valid run on their own. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~youtube-shorts-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"inputMode":"channel","channelUrls":["https://www.youtube.com/@MrBeast"],"hashtags":["#shorts"],"maxShorts":3,"oldestPostDate":"","market":"US"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "inputMode": "channel",
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "hashtags": [
    "#shorts"
  ],
  "maxShorts": 3,
  "oldestPostDate": "",
  "market": "US"
}

run = client.actor("crawlerbros~youtube-shorts-scraper").call(run_input=run_input)

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

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "inputMode": "channel",
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "hashtags": [
    "#shorts"
  ],
  "maxShorts": 3,
  "oldestPostDate": "",
  "market": "US"
}

const run = await client.actor('crawlerbros~youtube-shorts-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which YouTube Shorts Scraper inputs matter, and which can you skip?

The inputMode setting determines whether the run consumes channelUrls or hashtags. For creator checks, leave inputMode set to channel and provide explicit channel handles or IDs. The oldestPostDate control is optional and only filters records when running in channel mode.

• inputMode (string): Source to scrape Shorts from. 'channel' scrapes from a channel's Shorts tab. 'hashtag' scrapes Shorts from a hashtag page. Default: "channel".
• channelUrls (array): YouTube channel URLs, handles (@username), or channel IDs (UCxxx). Required when inputMode is 'channel'. Default: ["https://www.youtube.com/@MrBeast"].
• hashtags (array): Hashtags to scrape Shorts from (e.g. #cooking, sports). Required when inputMode is 'hashtag'. Include or omit the # prefix.
• maxShorts (integer): Maximum number of shorts to scrape per channel or hashtag. Default: 3.
• oldestPostDate (string): Only scrape shorts published on or after this date. Format: YYYY-MM-DD. Leave empty to scrape all shorts. Applies to channel mode only.
• market (string): YouTube market/region for localized content. Affects the language of metadata returned. Default: "US".

Fixed-choice controls: inputMode accepts channel (Channel Shorts Tab), hashtag (Hashtag Shorts); market accepts 31 values (default US), including US (United States), GB (United Kingdom), CA (Canada), AU (Australia).

What does YouTube Shorts Scraper return?

Returned records combine video performance stats like viewCount, likes, and commentsCount with full creator profiles like subscriber counts and channel verification status. They do not contain transcripts or contact emails. Use these fields to calculate engagement rates and analyze content performance.

Short fields

• title: string - "Mind-blowing space facts"
• type: string - "shorts"
• id: string - "abc123xyz"
• url: string - "https://www.youtube.com/shorts/abc123xyz"
• thumbnailUrl: string - Thumbnail image URL
• viewCount: integer - 1500000
• likes: integer - 85000
• commentsCount: integer - 320
• commentsTurnedOff: boolean - false
• order: integer - 0
• hashtag: string - "#shorts" (set only in hashtag mode)
• scrapedAt: string - "2026-02-12T12:00:00.000000+00:00"

Channel fields (included in each row)

• channelName: string - "NASA"
• channelUrl: string - "https://www.youtube.com/@NASA"
• channelId: string - "UCLA_DiR1FfKNvjuUpBHmylQ"
• channelUsername: string - "NASA"
• numberOfSubscribers: integer - 14200000
• isChannelVerified: boolean - true
• channelAvatarUrl: string - Avatar image URL
• channelBannerUrl: string - Banner image URL
• channelTotalVideos: integer - 5200
• aboutChannelInfo: object - Nested object with full channel details

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open YouTube Shorts Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select the inputMode in the configuration, setting it to channel for targeted creator lists or hashtag for topic research.
2. Populate channelUrls with valid YouTube channel handles, channel IDs, or complete channel URLs when operating in channel mode.
3. Populate hashtags with the target search terms if operating in hashtag mode, omitting or keeping the # prefix as needed.
4. Set maxShorts to cap the returned items per target, keeping it small on initial tests to limit billing exposure.
5. Set oldestPostDate using the YYYY-MM-DD format if you are running in channel mode and need to filter out historical uploads.
6. Select the market parameter to ensure localized titles and descriptions match your intended geographic region.
7. Execute the run and review the dataset output to ensure returned fields such as viewCount, likes, and channelId contain valid values.

How do you apply it? Three worked playbooks

These are YouTube Shorts Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Viral Shorts discovery

Outcome: Find the most-viewed Shorts from top creators

Configure: Set inputMode to 'channel', channelUrls to ['@MrBeast', '@nasa'], maxShorts to 50, and market to 'US'.

Working method: Execute the run across a designated list of high-performing channels. Sort the output dataset by viewCount in descending order to isolate top performing content patterns.

Deliverable: A structured dataset containing the highest-performing Shorts grouped by creator with view and like counts.

Stop condition: The execution returns records where viewCount is missing or null across multiple channels.

Use case 2: Influencer benchmarking

Outcome: Compare Shorts engagement across multiple channels

Configure: Set inputMode to 'channel', channelUrls to ['@MrBeast', '@mkbhd'], maxShorts to 100, and oldestPostDate to '2025-01-01'.

Working method: Collect all Shorts for candidate channels published after the specified oldestPostDate. Calculate average engagement rates per channel by comparing likes and commentsCount against viewCount.

Deliverable: An engagement matrix comparing average views, likes, and comment rates across selected channels.

Stop condition: The returned channelTotalVideos or numberOfSubscribers fields return null for target creators.

Use case 3: Trend monitoring

Outcome: Track Shorts volume for trending hashtags over time

Configure: Set inputMode to 'hashtag', hashtags to ['#shorts', '#tech'], maxShorts to 200, and market to 'US'.

Working method: Run scheduled extractions on a repeating timeline for selected hashtags. Track the volume of newly scraped video IDs and compare engagement distributions across runs.

Deliverable: A historical time-series report showing engagement trends and posting volume for target hashtags.

Stop condition: Output rows fail to populate the hashtag field when inputMode is configured for hashtag monitoring.

What breaks, and how do you design around it?

Hashtag mode does not support date filtering natively via oldestPostDate. When tracking recent hashtag trends, fetch the latest batch and filter out older uploads in your downstream data pipeline. If a channel handle cannot be located, fall back to explicit channel IDs starting with UC to minimize query ambiguity.

When should you not use YouTube Shorts Scraper?

Do not use this Actor if you need transcript text or full video downloads. For captions and video transcriptions, use YouTube Transcript Scraper instead. If your task requires downloading the raw media files rather than metadata, use YouTube Video Downloader.

What should you check before trusting the output?

• Verify that viewCount and likes return non-null numeric values across fetched rows.
• Confirm that commentsCount returns zero or higher, and check if commentsTurnedOff is set to true when commentsCount is zero.
• Validate that channelId begins with UC in channel mode rows to ensure complete creator context was extracted.
• Check that the hashtag string field is populated on every record when inputMode is set to hashtag.
• Monitor for empty datasets when applying oldestPostDate to avoid running automated schedules against zero-matching channels.

None of this proves a record is correct. It gives a scheduled YouTube Shorts Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to scrape 1,000 YouTube Shorts?

It costs $5.00 per 1,000 results on the free plan. Apify's free plan includes $5.00 of monthly platform usage, covering up to 1,000 results each month.

Can I filter YouTube Shorts by publication date?

Yes, but only in channel mode. Set the oldestPostDate input using YYYY-MM-DD format to exclude older content. Hashtag mode does not support date filtering.

Does this scraper collect creator email addresses?

No. The output contains channel metadata like subscriber counts and total videos, but no email addresses. Use YouTube Email Scraper for contact extraction.

What is the maximum number of Shorts I can fetch per run?

You can scrape up to 2,000 Shorts per channel or hashtag per run by adjusting the maxShorts configuration field.

What input formats are supported for channels?

You can supply full URLs like https://www.youtube.com/@MrBeast, channel handles like @MrBeast, or explicit channel IDs starting with UC.

Where to go next

When you are ready to run it, open YouTube Shorts Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the YouTube Shorts Scraper Actor page for the current input schema, pricing tier, and run history.

It is part of the YouTube Scraping Suite, which puts every related Actor on one page with its price and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Comment scrapers covers 37 Actors in this family.

Other Actors we maintain for related data:

• YouTube Hashtag Scraper: Scrape YouTube videos and Shorts by hashtag.
• YouTube Video Downloader: Download YouTube videos, playlists, and entire channels in your preferred quality from 360p all the way up to the best available resolution.
• YouTube Channel Scraper: Scrape YouTube channel info and video listings.
• YouTube Comment Scraper: Scrape YouTube video comments with full metadata.
• YouTube Email Scraper: Extract emails from YouTube channels without CAPTCHA bypass.
• YouTube Transcript Scraper: Extract transcripts and captions from YouTube videos with language selection support.
• YouTube Playlist Scraper: Scrape all videos from YouTube playlists.

Related guides:

• YouTube Video Downloader: 24 Data Fields, Up to 500 Free Results/Month
• Deploying YouTube Channel Scraper for Targeted Creator Intelligence
• YouTube Search Scraper: Up to 1,000 Free Results a Month (2026)
• Automating YouTube Research: Complete Four-Actor Pipeline Guide

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-27.

• Actor last updated by its maintainers on 2026-06-22.

• Run outcome figures cover the 30 day public window ending 2026-09-27.

• YouTube Shorts Scraper on Apify