YouTube Shorts Scraper: Channel Shorts with Views, Likes and Dates

This YouTube Shorts scraper collects the public Shorts of any YouTube channel and returns one structured row per Short: title, URL, view count, like count, comment count, duration, publish date, description and thumbnail. Supply channel URLs, @handles, bare handles or UC channel IDs. Use the results for YouTube Shorts analytics across channels you do not own, competitor tracking, creator research and content planning, without a YouTube Data API key or quota.

How to scrape YouTube Shorts from a channel

1. Add one or more channels to channels, for example @mkbhd, https://www.youtube.com/@mkbhd or UCBJycsmduvYEL83R_U4JriQ.
2. Set max_results to the number of Shorts you want per channel.
3. Keep fetch_details on for likes, comments, duration and exact publish dates, or switch it off for the basic Shorts-tab fields only.
4. Start the run and download the dataset as JSON, CSV or Excel, or read it through the API.

You can also schedule the actor to collect the same channels daily or weekly and compare view counts between runs.

YouTube Shorts scraper input

The actor reads each channel’s Shorts tab. It does not search across all of YouTube, download video files, or collect individual comments. Channel inputs are processed in the supplied order. Within a channel, results follow the order returned by its Shorts tab. If several inputs point to the same videos, each video ID is delivered once and retains the first input that found it.

Field	Type	Default	Description
channels	array of strings	required	Public channel URLs, @handles, bare handles, or UC channel IDs. At most 50 channels are processed.
max_results	integer	20	Maximum Shorts per channel, from 1 to 1,000.
fetch_details	boolean	true	Load available descriptions, duration, publication dates, likes, comments and subscriber counts.
country	string	US	Country passed to YouTube for regional results.
language	string	en	Interface language passed to YouTube; affects localized text such as view labels.

The default input uses @mkbhd with twenty results and details enabled. The result limit applies separately to each channel. A channel with fewer public Shorts returns fewer rows. Unavailable channels and channels without Shorts do not prevent other supplied channels from being processed.

YouTube Shorts output: views, likes and dates

Each dataset row contains video_id, the public /shorts/ URL, title, view_count, the original view_count_text, thumbnail_url, the originating input, and fetched_in_seconds. Channel name, channel ID and channel URL are included when channel metadata is available.

With details enabled, available fields include description, duration_seconds, keywords, is_live, published_date, upload_date, category, like_count, channel_subscribers and comment_count. Missing detail fields are omitted. A missing counter is not automatically zero. An empty description or keywords list can be a real source value.

The following complete row is from a real run on the default input (@mkbhd). Counts are a snapshot and change as viewers interact with the Short.

{
  "video_id": "R6yNUnRXZ64",
  "url": "https://www.youtube.com/shorts/R6yNUnRXZ64",
  "title": "iPhone Duo is here",
  "view_count": 7419885,
  "view_count_text": "7.4M views",
  "thumbnail_url": "https://i.ytimg.com/vi/R6yNUnRXZ64/frame0.jpg",
  "channel_name": "Marques Brownlee",
  "channel_id": "UCBJycsmduvYEL83R_U4JriQ",
  "channel_url": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
  "input": "@mkbhd",
  "description": "What to know about iPhone Duo",
  "duration_seconds": 70,
  "keywords": [],
  "is_live": false,
  "published_date": "2026-09-10T00:02:22-07:00",
  "upload_date": "2026-09-10T00:02:22-07:00",
  "category": "Science & Technology",
  "like_count": 202856,
  "channel_subscribers": 21300000,
  "comment_count": 4400,
  "fetched_in_seconds": 12.09
}

view_count_text preserves YouTube’s displayed label. Without details, the integer view_count is parsed from that label and can be approximate. With details, it is replaced by the exact view count returned for the video. The two values can therefore differ without indicating an error. Subscriber counts are integers parsed from the displayed subscriber label and can also be rounded.

Publication and upload dates are strings and can include a time and timezone offset. They are not guaranteed to be date-only values. Added fields such as posted_at represent the publication time in UTC. Added common fields include source, fetched_at, platform, post_url, post_id, and available author or engagement fields; existing fields retain their names and JSON types.

Results are stored in the default Apify dataset. Download them as JSON, JSONL, CSV or Excel, or read them through the Apify dataset API. The default key-value store contains a summary record with item and error counts. An errors record is written when errors occurred. The OUTPUT record provides run counts and status information, including free-plan delivery information.

Use cases for YouTube Shorts data

• Shorts analytics for any channel. YouTube Studio only shows analytics for your own channel. This actor gives you public views, likes and comment counts for any channel, so you can benchmark against peers.
• Competitor tracking. Follow how often rival brands or creators publish Shorts, which topics they pick and which Shorts reach the most views.
• Influencer and creator research. Compare engagement across candidate creators before a campaign, using like and comment counts relative to views and subscribers.
• Content planning. Find the Shorts that performed best on a channel, read their titles and descriptions, and see the length that works.
• Trend and research datasets. Build a time series of YouTube Shorts views by running the same channels on a schedule.

Compared with other ways to get YouTube Shorts data

Option	What you get	Limits
This YouTube Shorts scraper	Every public Short of a channel with views, likes, comments, duration and dates, as a dataset	Channel input only; no media download
YouTube Studio analytics	Detailed analytics, including retention	Only for channels you own
YouTube Data API	Video statistics	Needs an API key, has a daily quota, and has no documented filter for a channel's Shorts
Copying by hand	Whatever you read on the page	Slow, and view labels are rounded
Shorts downloaders	The video file	No structured metadata or counts

Other YouTube Shorts scrapers in the Apify Store also take hashtags or search terms, and some use tiered prices per plan. This actor focuses on channels and charges one flat price per delivered Short on every plan.

Pricing

The existing pay-per-event price is $0.0032 per delivered Short, plus Apify’s $0.002 actor-start event per GB of memory, with a minimum of one. Enabling details does not add a separate detail event or change the price per Short. At the existing 1 GB run setting, a run delivering twenty Shorts records twenty short events and one start event. A run returning no Shorts records no short events; the platform start event still applies.

Free-plan users receive at most ten Shorts per run. The numeric result limit is capped at ten per channel and total dataset delivery is capped at ten. Only delivered rows are charged. Paying users retain the requested result limit. Charges are based on the delivered rows after deduplication, so supplying the same channel twice does not double-charge the same video.

Limits and troubleshooting

This actor collects public information available to the YouTube web client. Removed, private, restricted or unavailable videos can have incomplete details. A channel’s tab may return fewer Shorts than requested or repeat a page; duplicate results are discarded and a page containing no new Shorts stops that channel. The maximum input limit does not guarantee that every channel has that many public videos.

Longer collections are processed in resumable pieces automatically. Dataset delivery preserves input and tab order. If collection cannot finish within the actor’s overall timeout, completed results remain available and the run reports that some requested work was not completed. Detail failures retain the Short and report an incomplete enrichment instead of discarding the row. Check the summary, status and errors when a run delivers fewer results than expected.

FAQ

Can I supply a channel ID instead of a handle?

Yes. A UC channel ID and a /channel/UC… URL can be used directly. Public @handle URLs, legacy channel URLs and bare handles are also accepted. Supply channels rather than individual video URLs: this actor reads the channel’s Shorts tab.

Why does the exact YouTube Shorts view count differ from the displayed label?

YouTube abbreviates displayed labels, for example using thousands or millions. With details enabled, the actor also reads an exact video counter and uses it for view_count. The original label remains available in view_count_text for comparison.

Does disabling details change the price?

No. Each delivered Short has the same per-result event price. Disabling details reduces the additional source requests and returns the basic Shorts-tab fields. Fields that depend on detail responses are omitted.

Can I download the videos or all their comments?

This actor returns metadata and public video links. It does not download media files or export individual comments. comment_count, when available, is the source’s total counter rather than a list of collected comments.

Is this a YouTube Shorts downloader?

No. It exports metadata and the public /shorts/ link of each Short. It does not save video or audio files.

Do I need a YouTube API key?

No. You only supply channels. There is no API key to create and no daily quota to manage.

How much does a typical run cost?

With the default input, twenty Shorts cost 20 × $0.0032 = $0.064, plus the Apify start event of $0.002 at the default memory setting: $0.066 in total.

What happens when a channel is unavailable?

The channel contributes no rows and produces an error record. Other supplied channels continue normally. If no Shorts are delivered, there are no per-Short charges; Apify’s platform start event remains applicable.