YouTube Shorts Scraper

Export a public YouTube channel's Shorts as clean JSON, from a channel URL, @handle, or channel ID. No YouTube Data API key, no quota, no browser.

The contract is simple: a bad channel never fails your run, and you only pay for Shorts delivered. Misspell a handle, paste a video URL by mistake, or hit a channel that has never posted a Short, and it comes back as a success: false row while the rest of the batch keeps going. Pay-per-result at $0.40 per 1,000 shorts. Failed channels cost $0.

See one run

Input:

{ "channelUrls": ["@MrBeast", "@totally-wrong-handle"], "maxResults": 5 }

What comes back:

• 5 success: true Short rows from @MrBeast, billed
• 1 success: false row, code: CHANNEL_NOT_FOUND, for the bad handle, not billed
• Run status: SUCCEEDED
• Charged: 5 shorts = $0.002

That is the whole contract. Good input returns billed rows, bad input returns free error rows in the same dataset, and the run still succeeds so one typo never costs you a batch.

Why this Actor

• A bad channel never breaks the batch. Every channel that cannot be resolved, or that has no Shorts, returns a success: false record with a machine-readable code (CHANNEL_NOT_FOUND, NO_SHORTS, VALIDATION_FAILED, RESOLVE_TIMEOUT, CHANNEL_SHORTS_TIMEOUT, DEADLINE_EXCEEDED). Branch on code without parsing English.
• You pay only for Shorts. Billing fires on an explicit per-Short event, not on dataset writes, so failure rows sit in your dataset for free. There is no per-run start fee, so a run that returns zero Shorts costs zero.
• No YouTube Data API key, no quota. The official YouTube Data API needs a Google key and rations a daily quota per call. This reads public data directly, so there is no Google key to provision and no daily Data API quota to ration. (You still run it with your normal Apify account, like any Actor.)

Best for

Data and AI workflows that turn channels into Shorts datasets: short-form trend tracking, creator and competitor monitoring, content-enrichment pipelines, and collecting Short video IDs to feed transcript or comment jobs. The failure-free billing and machine-readable error rows matter most when the extraction runs unattended inside a larger pipeline, where one bad channel should never take down the batch. It works fine for one-off manual pulls too.

Input example

A single channel:

{
  "channelUrl": "https://www.youtube.com/@MrBeast",
  "maxResults": 30
}

A batch, mixing URL, @handle, and channel ID forms:

{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast",
    "@mkbhd",
    "UCX6OQ3DkcsbYNE6H8uQQuVA"
  ],
  "maxResults": 100
}

channelUrl and channelUrls are merged and de-duplicated. Up to 50 unique channels run per job. Each channel is walked newest-first up to maxResults shorts (default 30).

Output example

One record per Short. The channel's id and name are copied onto every row so each row stands alone:

{
  "success": true,
  "channel_id": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "channel_title": "MrBeast",
  "video_id": "LgbyEFILLJI",
  "title": "$1 vs $10,000 Cake",
  "url": "https://www.youtube.com/shorts/LgbyEFILLJI",
  "type": "short",
  "view_count": "2M views",
  "thumbnail_url": "https://i.ytimg.com/vi/LgbyEFILLJI/oardefault.jpg",
  "author": "MrBeast"
}

A channel that cannot be resolved lands in the same dataset and is not charged:

{
  "success": false,
  "channel_url": "@totally-wrong-handle",
  "code": "CHANNEL_NOT_FOUND",
  "error": "Could not resolve YouTube channel: @totally-wrong-handle",
  "request_id": "req_911f37d2e55644ff9d9e4a3f",
  "status_code": 404
}

Split hits from misses on the success field. Quote request_id in any support issue and we can trace the exact request.

What you get

Every Short is one record with success: true:

Field	Type	What it is
success	boolean	true for a Short (billed), false for a channel that could not be listed (not billed).
channel_id	string	The UC... channel ID the Short belongs to.
channel_title	string	The channel's display name.
video_id	string	The 11-character YouTube video ID of the Short.
title	string	Short title.
url	string	Canonical Short URL, https://www.youtube.com/shorts/<video_id>.
type	string	Content type. Always short.
view_count	string	View count as a display string (for example 2M views). May be empty.
thumbnail_url	string	URL of the largest available thumbnail.
author	string	Channel author name.

Channels that could not be listed carry success: false, channel_url, a machine-readable code, a human-readable error, the service request_id, and the HTTP status_code. They are not charged.

Pricing

Pay-per-result. One charge per Short delivered: $0.0004 each, which is $0.40 per 1,000 shorts. The charge fires only after a Short row lands in your dataset.

• 1,000 delivered shorts cost $0.40.
• A run that hits ten dead handles and returns zero shorts costs $0.
• There is no per-run start fee, so an empty run is genuinely free.

Apify subscriber discounts apply automatically: roughly $0.32 per 1,000 on the Scale plan and $0.24 per 1,000 on Business. Platform compute is included in the per-Short price. Cap the maximum spend of a single run from Apify's Run Limits panel; the Actor honors the cap and stops cleanly mid-walk when the budget runs out.

What this Actor does not do

Honest scope, so you know before you run it:

• It reads the channel's Shorts tab, not regular videos. That keeps output focused on Shorts and avoids mixing formats. For long-form uploads, use the YouTube Channel Scraper.
• It returns what the Shorts tab exposes: title, view count, and thumbnail. The Shorts tab does not carry a duration or a publish date, so those fields are not in the output. Likes, comments, and descriptions require opening each Short and are out of scope here.
• It returns Shorts newest first. There is no sort by popularity or oldest.
• Public channels only. Private and unavailable channels return success:false.

How to use this Actor

1. Open the Actor in the Apify Console.
2. Set channelUrl (single), channelUrls (a list), or both. Each accepts a full channel URL, an @handle, or a UC... channel ID. Up to 50 unique channels run per job.
3. Set maxResults to cap how many Shorts to return per channel, newest first. Default is 30.
4. Click Start. Each Short is one success: true record. Channels that cannot be listed produce one success: false record and do not stop the run. Only Shorts are charged.

The Actor is also callable from the Apify API and every official integration (Make, Zapier, n8n, Slack, webhooks). The API tab in the Console has ready-to-paste JavaScript, Python, and curl snippets.

Reliability

A bad channel never fails the batch. A misspelled handle, a video URL pasted by mistake, or a channel with no Shorts becomes a success: false record with a specific code. The run keeps going and finishes successfully.

You never pay for a failure. Billing fires on an explicit per-Short charge event, not on dataset writes, so success: false records are free. There is no per-run start fee either.

Hard 30-second deadline per page request. Each page of a channel is fetched under a 30-second deadline. If YouTube or the proxy network stalls, that channel returns a 504 with code: DEADLINE_EXCEEDED as a success: false record instead of hanging your run.

FAQ

Do I need a YouTube Data API key?

No. The Actor reads YouTube's public data directly and does not consume Google API quota.

What channel formats are accepted?

A full channel URL (https://www.youtube.com/@MrBeast or .../channel/UC...), an @handle, or a bare UC... channel ID. A video URL or unrecognizable input comes back as a success: false record with code: VALIDATION_FAILED, not a rejected run.

How many Shorts do I get per channel?

Up to maxResults, newest first. The Actor walks the channel's Shorts tab page by page until it reaches maxResults or the channel runs out. Set maxResults higher to go deeper.

Why is there no duration or publish date?

The YouTube Shorts tab does not expose them. It gives the title, view count, and thumbnail per Short, and that is what this Actor returns. Pulling a duration or exact date would mean opening every Short individually, which is a different, slower, more expensive job.

Does this include regular videos?

No. This Actor lists a channel's Shorts. For long-form uploads, use the YouTube Channel Scraper.

Can I get transcripts too?

Not from this Actor. Use it to collect a channel's Short video IDs, then run the YouTube Transcript Scraper on those IDs to pull captions.

Can I use this Actor from my own code?

Yes. Use the Apify API or one of the official SDKs (Node.js: apify-client, Python: apify-client). The Console shows ready-to-paste code samples on the API tab.

How does billing know a channel failed?

Billing fires on an explicit per-Short charge event, not on dataset writes. The Actor only fires it when a Short is delivered, so success: false records sit in your dataset for free. You get every result in one place and still branch on success and code, with a request_id for support correlation.

Found a bug or want a feature?

Open an issue on this Actor's Issues tab and include the request_id from any error record you saw. We respond within one business day.