Pricing

Pay per event

YouTube Shorts Scraper

Scrape YouTube Shorts from any channel. Get exact view counts, likes, comments, publish dates, descriptions, and thumbnails. Pure HTTP — no browser overhead. Supports multiple channels per run. Export JSON, CSV, Excel.

Pricing

Pay per event

Rating

0.0

(0)

Developer

Stas Persiianenko

Actor stats

Bookmarked

Total users

Monthly active users

a day ago

Last modified

What does YouTube Shorts Scraper do?

YouTube Shorts Scraper extracts detailed data from every Short published on any YouTube channel. Provide channel URLs or handles and get structured records including video titles, exact view counts, like counts, comment counts, publish dates, duration, descriptions, hashtags, and thumbnails — one item per Short, ready to export.

The actor uses a fast pure HTTP approach with YouTube's InnerTube API — no browser, no Playwright, no Puppeteer. This keeps costs low and speeds high. Supports bulk extraction across multiple channels in a single run, with automatic pagination to fetch all Shorts from a channel's history.

Try it free: go to YouTube Shorts Scraper on Apify Store and click Try for free.

Who is YouTube Shorts Scraper for?

Social media analysts and data teams

📊 Track view count and engagement trends for Shorts across multiple competitor channels
📈 Build benchmarking datasets: median views, likes per view, comment-to-view ratios
🔁 Schedule weekly runs to monitor channel growth and content velocity

Content creators and YouTubers

🎬 Research which Short formats and topics drive the most views in your niche
🏆 Identify top-performing Shorts from competitor channels to reverse-engineer what works
📅 Analyze publish frequency and optimal posting times across successful channels

Marketing teams and brand managers

📣 Monitor brand mentions in Short descriptions and hashtags across channels
🎯 Identify influencers with strong Shorts engagement for partnership outreach
📋 Generate competitive intelligence reports on rivals' short-form content strategy

Researchers and academics

🎓 Study short-form video virality patterns and engagement mechanics on YouTube
📰 Collect longitudinal engagement data for media consumption research
🌐 Analyze how hashtags, topics, and posting cadence correlate with viewership

Developers and automation engineers

🤖 Feed Shorts metadata into content recommendation or discovery systems
⚡ Power dashboards and alerts for channel monitoring at scale
🧩 Integrate with CRM or marketing platforms via Apify's API and webhooks

Why use YouTube Shorts Scraper?

✅ Actually works — pure HTTP with InnerTube API; not dependent on a headless browser that breaks when YouTube updates its UI
💸 Low cost — $0.002/Short (Free tier), $0.0017 on Starter; competitors charge $0.003–$0.005
⚡ Fast — no browser startup overhead; processes approximately 20 Shorts per minute
📦 Multi-channel — pass multiple channels in one run, results from all combined in one dataset
🔢 Exact counts — returns both numeric viewCount (e.g., 3519541) and display text viewCountText (e.g., "3.5M views")
📄 Rich metadata — full descriptions, hashtags, channel subscriber counts, verified status, and channel handle
🔗 Flexible input — @handle URLs, full /channel/UC... URLs, or raw channel IDs all work
📤 All export formats — JSON, CSV, Excel, XML via Apify's built-in dataset tools

What data can you extract?

Field	Type	Description
`videoId`	string	YouTube video ID
`title`	string	Short title
`url`	string	Direct link to the Short
`thumbnailUrl`	string	Thumbnail image URL
`viewCount`	number	Exact numeric view count
`viewCountText`	string	Abbreviated display text (e.g., "1.2M views")
`date`	string	Publish date (ISO 8601)
`likes`	number	Exact like count
`commentsCount`	number	Comment count
`duration`	string	Video duration (MM:SS format)
`description`	string	Full video description text
`hashtags`	array	Hashtags extracted from the description
`channelId`	string	Channel's UC-prefixed ID
`channelName`	string	Channel display name
`channelUrl`	string	Full URL to the channel
`channelUsername`	string	Channel handle without the @ symbol
`numberOfSubscribers`	number	Channel subscriber count at time of scrape
`isChannelVerified`	boolean	Whether the channel has a verification checkmark

How much does it cost to scrape YouTube Shorts?

This Actor uses pay-per-event pricing — you pay only for what you scrape. No monthly subscription. All platform costs (compute, proxy, storage) are included.

	Free	Bronze ($29/mo)	Silver ($199/mo)	Gold ($999/mo)
Start fee	$0.005	$0.005	$0.005	$0.005
Per Short	$0.002	$0.002	$0.0016	$0.0012
100 Shorts	$0.205	$0.205	$0.165	$0.125
1,000 Shorts	$2.005	$2.005	$1.605	$1.205
10,000 Shorts	$20.005	$20.005	$16.005	$12.005

Higher-tier plans (Platinum, Diamond) get additional volume discounts.

Real-world cost examples:

Input	Shorts scraped	Duration	Cost (Free tier)
1 channel, 10 Shorts	10	~30s	~$0.025
3 channels, 30 each	90	~5 min	~$0.185
1 large channel, 500 Shorts	500	~25 min	~$1.005

On the free $5 credit that every new Apify account gets, you can extract approximately 2,500 Shorts.

How to scrape YouTube Shorts

Go to YouTube Shorts Scraper on Apify Store
Click Try for free (no credit card required for the free $5 credit)
Enter one or more YouTube channel URLs in the Channel URLs field
Set the Max Shorts per channel limit (start with 10–50 to test)
Click Start and wait for results
Download your data as JSON, CSV, or Excel

Example inputs:

Minimal — single channel:

{
    "channelUrls": ["https://www.youtube.com/@MrBeast"],
    "maxShortsPerChannel": 50
}

Multiple channels in one run:

{
    "channelUrls": [
        "https://www.youtube.com/@MrBeast",
        "https://www.youtube.com/@NileRed",
        "UCq-Fj5jknLsUf-MWSy4_brA"
    ],
    "maxShortsPerChannel": 100
}

All Shorts from a channel (unlimited):

{
    "channelUrls": ["https://www.youtube.com/@mkbhd"],
    "maxShortsPerChannel": 0
}

Input parameters

Parameter	Type	Default	Description
`channelUrls`	array	required	YouTube channel URLs, `@handles`, or raw channel IDs
`maxShortsPerChannel`	integer	`100`	Max Shorts per channel. Set to `0` for all Shorts
`maxRequestRetries`	integer	`3`	Retry attempts for failed requests (0–10)

Output examples

{
    "videoId": "vUeY-SU4i04",
    "title": "Dissolving glass in scary hydrofluoric acid",
    "url": "https://www.youtube.com/shorts/vUeY-SU4i04",
    "thumbnailUrl": "https://i.ytimg.com/vi/vUeY-SU4i04/oardefault.jpg",
    "viewCount": 3519541,
    "viewCountText": "3.5M views",
    "date": "2026-01-18T16:49:28.000Z",
    "likes": 185514,
    "commentsCount": 5100,
    "duration": "02:34",
    "description": "For a while now, I've wanted to test the power of hydrofluoric acid...\n\n#shorts",
    "hashtags": ["#shorts"],
    "channelId": "UCFhXFikryT4aFcLkLw2LBLA",
    "channelName": "NileRed",
    "channelUrl": "https://www.youtube.com/channel/UCFhXFikryT4aFcLkLw2LBLA",
    "channelUsername": "NileRed",
    "numberOfSubscribers": 10500000,
    "isChannelVerified": false
}

Tips for best results

🔗 Use @handle format — channel URLs with @handle are the most reliable and easiest to find on YouTube
🔀 Mix URL formats freely — @MrBeast, full /channel/UC... URLs, and raw channel IDs all work
🔢 Set a limit first — for large channels (1,000+ Shorts), start with maxShortsPerChannel: 50 to verify the data before running the full extraction
💰 Batch multiple channels — putting 10 channels in one run is far cheaper than 10 separate runs (you pay one start fee instead of ten)
📅 Schedule weekly runs — set up a scheduled run with the same channels to track engagement changes over time
⚡ Speed expectations — each Short requires 2 additional API calls for enrichment data (likes, dates, duration); expect ~20 Shorts/minute

Integrations

Connect YouTube Shorts Scraper with your analytics and marketing tools:

📊 YouTube Shorts → Google Sheets — schedule daily channel monitoring and append new Shorts to a live spreadsheet; track view growth week over week
📣 YouTube Shorts → Slack — use Make or Zapier to alert your team when a competitor publishes a Short that hits 100K views within 24 hours
📧 YouTube Shorts → Email digest — build a weekly competitive intelligence email summarizing top Shorts by view count from your tracked channels
🔔 Webhook on completion — trigger downstream processing (trend analysis, hashtag extraction, keyword monitoring) as soon as a run finishes
📈 Shorts → BI dashboard — pipe data into BigQuery, Looker Studio, or Tableau for long-term engagement trend visualization

Learn more about Apify integrations.

Using the Apify API

You can run YouTube Shorts Scraper programmatically using the Apify API.

Node.js:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/youtube-shorts-scraper').call({
    channelUrls: ['https://www.youtube.com/@MrBeast'],
    maxShortsPerChannel: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} Shorts`);
items.forEach(item => console.log(`${item.title}: ${item.viewCount} views`));

Python:

from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/youtube-shorts-scraper').call(run_input={
    'channelUrls': ['https://www.youtube.com/@MrBeast'],
    'maxShortsPerChannel': 50,
})

items = list(client.dataset(run['defaultDatasetId']).iterate_items())
print(f"Scraped {len(items)} Shorts")
for item in items:
    print(f"{item['title']}: {item['viewCount']} views")

cURL:

curl -X POST "https://api.apify.com/v2/acts/automation-lab~youtube-shorts-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "channelUrls": ["https://www.youtube.com/@MrBeast"],
    "maxShortsPerChannel": 50
  }'

Use with AI agents via MCP

YouTube Shorts Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/youtube-shorts-scraper"

Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/youtube-shorts-scraper"
        }
    }
}

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts

Once connected, try asking your AI assistant:

"Use automation-lab/youtube-shorts-scraper to get the top 50 Shorts from @mkbhd sorted by view count"
"Scrape all Shorts from @NileRed and @MarkRober — show me which topics get the most views"
"Get the last 100 Shorts from @MrBeast and calculate the average engagement rate (likes divided by views)"

Learn more in the Apify MCP documentation.

Is it legal to scrape YouTube Shorts?

YouTube Shorts Scraper accesses only publicly available data — the same information any logged-out visitor sees on YouTube. It does not require authentication, bypass access controls, or collect data from private channels.

Automated collection of public web data is generally lawful, consistent with the US Court of Appeals ruling in hiQ Labs v. LinkedIn. That said, you should review YouTube's Terms of Service and applicable laws in your jurisdiction. For data involving personal information, ensure compliance with GDPR, CCPA, and similar privacy regulations. Read more about the legality of web scraping.

FAQ

Can I scrape Shorts from multiple channels at once? Yes. Add as many channel URLs as you need to channelUrls. All channels are processed in one run and combined into a single dataset. This is much cheaper than running separate jobs.

What channel URL formats work? All three formats are supported: @handle URLs (youtube.com/@MrBeast), full channel URLs (youtube.com/channel/UC...), and raw channel IDs (UCX6OQ3DkcsbYNE6H8uQQuVA). The @handle format is recommended as it's easiest to find and most stable.

Does this scraper use a browser? No. It uses pure HTTP requests to YouTube's InnerTube API — faster and more reliable than browser-based approaches that break when YouTube changes its UI.

How many Shorts can I scrape? No hard limit. Set maxShortsPerChannel: 0 to scrape all Shorts. Very large channels may have 1,000+ Shorts — budget and time accordingly.

What's the difference between viewCount and viewCountText? viewCount is the exact numeric count (e.g., 177870215) for sorting and math. viewCountText is the abbreviated text YouTube shows in its UI (e.g., "177M views").

How accurate are the like and comment counts? Like counts are exact numbers. Comment counts may be approximate (rounded to the nearest thousand for very large counts) — this is a limitation of YouTube's InnerTube API response.

The scraper returns 0 results for a channel. What's wrong? First verify the channel actually has Shorts — some channels post only regular videos. Also check that the URL is correct: handles are case-sensitive (@MrBeast, not @mrbeast). If you're confident the channel has Shorts, try switching to the full /channel/UC... URL format instead of the @handle.

The scraper is slower than I expected. Is that normal? Yes. Each Short requires 2 additional API calls to fetch enrichment data (likes, publish date, duration). This is by design — it's what ensures you get complete data. Processing speed is approximately 20 Shorts per minute. For time-sensitive monitoring, use a lower maxShortsPerChannel limit.