YouTube Shorts Scraper: Channel Shorts with Views in JSON

A hosted youtube shorts scraper that pulls every Short from any YouTube channel as structured JSON, view counts, like counts, publish dates, durations, and thumbnails included. Point it at channel URLs, @handles, or UC channel IDs and it returns the Shorts through YouTube's own InnerTube web API, so there's no API key, no quota, and no Chrome to run yourself.

What you get

• One clean row per Short: video ID, /shorts/ URL, title, description, channel name, channel ID, channel URL, and channel subscriber count.
• Engagement metrics: view count (both the raw integer and the localized "1.2M views" text), like count, and comment count when fetch_details is on.
• Publish date and duration: exact publish date and duration_seconds for every Short, so you can sort by recency or filter by length.
• Up to 1,000 Shorts per channel: paginated through YouTube's continuation tokens, so long back-catalogues come through in a single run.
• No YouTube Data API quota: the Actor uses the same internal web API the YouTube client calls, so you never touch your 10,000 daily quota units.
• Country and language control: set the storefront country and language to get view counts and dates formatted for the market you care about.
• Timing metadata: every row carries fetched_in_seconds and the input that produced it, so runs are auditable.

Why scrape YouTube Shorts

YouTube Shorts has no official public API. The YouTube Data API v3 exposes regular videos, but it has no dedicated Shorts endpoint, no reliable Shorts flag, and it silently mixes Shorts in with long-form uploads. If you want a clean list of just the Shorts a channel has posted, the official API leaves you guessing. This Actor reads the channel's Shorts tab directly, the same feed a viewer sees, so what you get back is exactly the Shorts, nothing else.

The engagement data is the second problem. View counts, like counts, and publish timing for Shorts live inside the mobile-first Shorts player, and they're formatted for display ("1.2M views", "3 days ago") rather than served as clean numbers. Pulling that at scale by hand means scrolling an endless vertical feed and reading labels off the screen. This Actor does it server-side and hands you both the abbreviated text and, where available, the exact numeric values, so you can chart trends instead of screenshotting them.

The third reason is quota and maintenance. Anyone who has tried a youtube shorts downloader browser extension or a homegrown Python scraper knows the drill, they break every time YouTube ships a UI change, and the Data API route caps you at 10,000 units a day. This Actor runs against the InnerTube API on hosted infrastructure that's patched as YouTube evolves, and it bills per Short instead of per month.

Input

Field	Type	Default	Description
channels	array	required	One or more channel identifiers, full URLs (youtube.com/@handle, youtube.com/channel/UC…), bare @handles, or UC… channel IDs.
max_results	integer	100	Shorts to collect per channel (1–1,000). Newest first.
fetch_details	boolean	false	When true, makes an extra request per Short to add like_count, comment_count, the exact published_date, and duration_seconds.
country	string	US	Storefront country code, affects how view counts and dates are localized.
language	string	en	Interface language for titles, descriptions, and date text.

Output

Every run pushes results to the Apify dataset as JSON, one record per Short:

{
  "video_id": "abc123XYZ",
  "url": "https://www.youtube.com/shorts/abc123XYZ",
  "title": "How we hit 1M subs in 90 days",
  "description": "The full breakdown of our short-form strategy.",
  "channel_name": "Creator Studio",
  "channel_id": "UCBR8-60-B28hp2BmDPdntcQ",
  "channel_url": "https://www.youtube.com/channel/UCBR8-60-B28hp2BmDPdntcQ",
  "channel_subscribers": "1.4M",
  "published_date": "2026-06-28",
  "view_count": 2380194,
  "view_count_text": "2.3M views",
  "like_count": 84200,
  "comment_count": 1130,
  "duration_seconds": 47,
  "thumbnail_url": "https://i.ytimg.com/vi/abc123XYZ/oardefault.jpg",
  "input": "https://www.youtube.com/@creatorstudio",
  "fetched_in_seconds": 2.9
}

Notes on the fields:

• view_count is the numeric value, view_count_text is the raw label YouTube shows ("2.3M views"), kept unchanged so you can verify it against the page.
• like_count, comment_count, exact published_date, and duration_seconds are populated when fetch_details is true. With details off, they may be absent or approximate.
• channel_subscribers comes through in YouTube's abbreviated form ("1.4M"), trivial to parse downstream if you need an integer.

You can download the dataset as JSON, JSONL, CSV, or Excel from the Apify console, stream it via the Apify API, or pipe it to webhooks, S3, BigQuery, and Apify's other integrations.

Use cases

Short-form content strategists use it to reverse-engineer what works on a channel. Pull a competitor's last 300 Shorts, sort by view_count, and the outliers tell you which hooks, topics, and durations actually broke out. Because duration_seconds and published_date come through per Short, you can correlate length and posting cadence against views instead of guessing.

Trend researchers scrape a basket of channels in one niche to spot format shifts early. When the same visual gimmick starts showing up across ten creators inside a week, the publish dates make the wave visible before it hits mainstream. Running the same channel list on a schedule turns that into a rolling trend tracker.

Influencer analysts vet creators before a sponsorship. Real reach shows up in the spread between view_count and channel_subscribers, and authentic engagement shows up in the like_count and comment_count ratios. A channel whose Shorts pull views far below its subscriber count, or whose likes don't track its views, tells you fast where the audience is soft.

Brand monitors watch for their product showing up in creator Shorts. Point the Actor at the channels that cover your category, then filter titles and descriptions for mentions. The comment and like counts tell you which of those mentions actually landed, so you can prioritize outreach to the creators whose Shorts about you are performing.

How it compares

	This Actor	streamers/youtube-shorts-scraper
Price per 1,000 Shorts	$3.20	$4.00
Date filter / publish date	Bundled in base event	Separate add-on, +$0.0013 per Short
Likes, comment count, duration	Bundled in base event	Charged as extras
Pricing model	Pay-per-event	Pay-per-event
API key or quota	None (InnerTube)	None (InnerTube)

We undercut streamers by 20% on the base rate ($3.20 versus $4.00 per 1,000 Shorts). They also meter a separate $0.0013-per-Short charge for date filtering, we fold likes, comment count, publish date, and duration into the single per-Short event, so there's no surprise line item.

Pricing

Pay-per-event. You pay $0.0032 per Short returned ($3.20 per 1,000 Shorts), plus a $0.002 actor-start fee each time a run begins. No monthly subscription, no minimum. A run that pulls 500 Shorts costs about $1.60 in event fees plus the fractional start fee. Enabling fetch_details doesn't change the per-Short price, it adds requests behind the scenes but bills at the same rate.

Limits and gotchas

• Channel input only. The Actor scrapes the Shorts feed of a channel. It does not take a single /shorts/ URL as input, if you already have specific Short IDs, this isn't the tool for looking them up one by one.
• fetch_details adds requests per Short. With it on, each Short triggers an extra fetch for likes, comments, exact date, and duration. Runs take longer on large max_results, though the per-Short price is unchanged.
• Free-tier runs are capped at 10 Shorts. Apify free-plan users get up to 10 results per run so they can test the output shape. Paid Apify users run to the full max_results.
• Abbreviated numbers where YouTube abbreviates. channel_subscribers and view_count_text come through in YouTube's short form ("1.4M"). view_count itself is numeric.
• Newest first, and that's the only order. Shorts return in reverse-chronological order. There's no server-side sort by views or engagement, sort the dataset downstream.
• Localized output follows country and language. View-count text and dates are formatted for the market you set. Change them and the display strings change with them.
• Private, deleted, or members-only Shorts are skipped. Only publicly visible Shorts on the channel's Shorts tab come through.

FAQ

How do I scrape YouTube Shorts from a channel?

Paste the channel's URL, @handle, or UC ID into the channels field, set max_results to how many Shorts you want (up to 1,000), and run. The Actor reads the channel's Shorts tab and returns one JSON row per Short. You can pass several channels at once and it processes them in sequence.

Can I get Shorts view and like counts?

Yes. Every Short comes back with view_count (numeric) and view_count_text (the "2.3M views" label). Turn on fetch_details to also get like_count and comment_count, along with the exact publish date and duration_seconds for each Short.

Do I need a YouTube API key or quota?

No. The Actor calls YouTube's internal InnerTube web API, the same one the YouTube site uses, so there's no API key to obtain and none of your YouTube Data API quota gets consumed.

How many Shorts can I pull per channel?

Up to 1,000 per channel per run, set via max_results. They come back newest first. Free-tier Apify accounts are capped at 10 results per run for testing, paid accounts get the full count.

Why are some engagement fields empty unless I enable fetch_details?

Likes, comment count, exact publish date, and duration aren't in the lightweight Shorts feed, they need an extra request per Short. To keep default runs fast and cheap the Actor fetches them only when fetch_details is true. View counts and titles are always included either way.

Can I run this on a schedule to track a channel over time?

Yes. Apify has built-in scheduling. Point it at your channel list on a daily or weekly cadence and diff each run against the last to watch view counts climb and catch new Shorts as they post.

Related Actors

• Youtube Scraper - Scrape YouTube videos by search term, channel, or video URL.
• Youtube Comments - Scrape all comments from any YouTube video.
• Free Youtube Transcript - Get the full transcript of any YouTube video.