YouTube Shorts Scraper

Export public YouTube Shorts metadata from known channel Shorts tabs, handles or direct Shorts URLs. Retain stable video identity, titles, source links, thumbnails and available public labels for separate research and reporting. The Actor does not download media, collect comments or expose private analytics.

Quick start

Choose a known Shorts tab with a small result cap. The existing YouTube channel example is:

{
  "startUrls": [
    { "url": "https://www.youtube.com/@YouTube/shorts" }
  ],
  "maxItems": 20,
  "resumeFromCheckpoint": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

• Scrape YouTube official channel Shorts — Collect a small sample from a public channel Shorts tab.
• Scrape a direct YouTube Short — Retrieve metadata for one known Shorts link.

What you get

One saved Short row with videoId, canonical shortUrl, title, sourceUrl, output position and collection time. Channel identity, thumbnail, public view label, relative publish text and duration are conditional source fields. Position is saved output order rather than a stable YouTube-wide popularity rank.

Who is it for?

• Content teams preparing source-linked short-form idea sheets.
• Creator researchers reviewing bounded channel publishing samples.
• Agencies retaining observed Shorts metadata for client reports.
• Data developers handing known Shorts IDs to separate detail or comment workflows.

How you can use the data

• Inspect a YouTube channel-tab sample. Use the existing @YouTube/shorts URL with a low cap and retain videoId, title and sourceUrl. Review original links rather than assuming the export covers every upload or the whole niche.
• Resolve one known Short deliberately. Use the existing ssjBTBCO8cE Shorts URL and keep its video ID and available metadata. Missing views or dates are unknown, and a public link does not provide media-use rights.
• Build your own topic review sheet. Export titles and channel context for manual classification or a separate analysis step. The Actor does not apply topic or minimum-like filters to your sample or produce built-in trend rankings.
• Compare recurring samples in your destination. Store videoId and scrapedAt, deduplicate repeated exports and inspect source gaps before marking an item removed. Scheduled runs create new observations rather than a certified complete historical archive.

Input settings

Setting	JSON key	What to enter
Start URLs	startUrls	Public Shorts URLs or channel Shorts tab URLs.
Maximum items	maxItems	Saved-row cap across all sources, from 1 to 1000.
Resume from checkpoint	resumeFromCheckpoint	Use pending source URLs from a saved checkpoint in the same key-value store when present.
Proxy configuration	proxyConfiguration	Optional managed or custom connection settings. See field help for costs and limitations.

Accepted URL types

✅ Public channel Shorts tabs, for example https://www.youtube.com/@YouTube/shorts.

✅ Direct Shorts URLs, for example https://www.youtube.com/shorts/ssjBTBCO8cE.

✅ Handle shorthand in inputs, for example @YouTube.

The actor is built for public data.

It does not access private channels, private videos, member-only videos, or account-only analytics.

Output data

The existing illustrative row contains historical view text and collection time rather than a current video measurement:

{
  "shortUrl": "https://www.youtube.com/shorts/ssjBTBCO8cE",
  "videoId": "ssjBTBCO8cE",
  "title": "Kizzy the Parrot makes a BIG prediction",
  "channelName": "YouTube",
  "channelUrl": "https://www.youtube.com/@YouTube",
  "viewCountText": "6.9K views",
  "thumbnailUrl": "https://i.ytimg.com/vi/ssjBTBCO8cE/frame0.jpg",
  "publishedTimeText": null,
  "durationText": null,
  "position": 1,
  "sourceUrl": "https://www.youtube.com/@YouTube/shorts",
  "scrapedAt": "2026-06-17T00:00:00.000Z"
}

The actor returns one row per YouTube Short.

Field	Description
shortUrl	Canonical YouTube Shorts URL
videoId	YouTube video identifier
title	Short title or caption text when available
channelName	Channel name when available
channelUrl	Channel URL when available
viewCountText	Public view count label such as 14K views
thumbnailUrl	Thumbnail image URL
publishedTimeText	Published date text when available
durationText	Duration text when available
position	Result position in the actor output
sourceUrl	Input URL that produced the row
scrapedAt	ISO timestamp for the scrape

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

The start event is charged after input validation, connection setup and runtime checks. A started run can incur this charge even when no Shorts are returned.

Each saved Short is followed by a result event. Unavailable sources do not create fabricated paid rows. The Actor stops extracting when the result-event budget cannot cover another row.

See the live Pricing tab for current rates and discounts. Platform usage can also apply. Repeated scheduled runs or checkpoint re-entry can incur another start event and charges for repeated saved rows.

Tips for best results

• Use a channel Shorts tab for a channel sample. Keep the first export small and inspect source attribution.
• Use a direct Shorts URL for one known video. A source must resolve to the requested identity rather than an unrelated page.
• Keep stable video IDs. Deduplicate your own repeated exports and keep sourceUrl and scrapedAt for comparisons.
• Inspect optional fields. Listing pages and direct pages expose different duration, publish and view metadata.
• Read pending and error records. A cutoff or continuation failure can leave useful rows without complete source coverage.

Limits and caveats

• Public metadata only. No login-only data, private analytics, comments or video downloads are included. Layout and regional differences can reduce coverage.
• Optional fields stay unknown. Missing views, dates, duration or channel information remain null rather than estimates.
• Bounded samples are not archives. The saved-row cap, charge budget and time allowance can stop a run before all channel pages are collected. Review source links before drawing conclusions about missing uploads.
• Keep supported run memory. Use 256 or 512 MiB. Larger allocations do not extend the result or time allowance. Unusually large or complex responses and stalled later pages stop with an extraction error rather than a claim of complete coverage.
• Resumption is limited. Checkpoint help explains the same-store behavior. It does not recover a different run automatically or deduplicate across independent runs.
• Unavailable is not deleted. An unavailable public Shorts tab, an explicitly private or removed video, or a supported login-required response can finish with an empty dataset and a reason in RUN_SUMMARY. HTTP 404/410 targets are also skipped. The Actor does not infer privacy or deletion from a generic access failure.
• Inspect partial results. Blocked, mismatched or unparseable sources and failed later pages remain extraction errors, even if another source returned useful rows. With no saved rows and unresolved extraction errors, the run fails. A matched page without trusted Shorts data still needs investigation rather than being labelled a genuine empty channel.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its defaultDatasetId to fetch the results.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~youtube-shorts-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.youtube.com/@YouTube/shorts"}],
    "maxItems": 20
  }'

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/youtube-shorts-scraper').call({
  startUrls: [{ url: 'https://www.youtube.com/@YouTube/shorts' }],
  maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('fetch_cat/youtube-shorts-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.youtube.com/@YouTube/shorts'}],
    'maxItems': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

MCP and AI agents

You can ask your AI assistant to collect data with YouTube Shorts Scraper and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's YouTube Shorts Scraper. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

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

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use YouTube Shorts Scraper by Fetch Cat, or give it the identifier fetch_cat/youtube-shorts-scraper.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Collect five Shorts from YouTube’s official channel and put their titles and source links in a review sheet.”
• “Get the public metadata for this Shorts link so I can review its title and thumbnail without downloading the video.”
• “Collect a small sample from these two channel Shorts tabs and keep the video IDs and collection times so I can compare them with my earlier export.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

FAQ

Can I scrape several channels in one run?

Yes. Add multiple channel Shorts URLs to startUrls.

Can I scrape only one Short?

Yes. Add a direct Shorts URL, such as https://www.youtube.com/shorts/ssjBTBCO8cE.

Does the actor scrape comments?

No. This actor focuses on Shorts listing metadata. Use a comments-focused actor when you need comment data.

Does the actor download video files?

No. It returns metadata and links, not media files.

Can I use the output in spreadsheets?

Yes. Export the dataset as CSV or Excel from Apify Console.

Can I run it on a schedule?

Yes. Use Apify schedules to run it automatically.

Is login required?

No. The actor is designed for public pages visible without a YouTube account.

What should I put in maxItems?

Use a small value such as 20 for a quick test. Increase it for larger monitoring jobs.

Troubleshooting

Why did I get fewer Shorts than requested?

The channel may have fewer public Shorts than your maxItems value.

The input may point to a channel page instead of the /shorts tab.

Try opening the URL in a browser and confirm that public Shorts are visible.

Why are some fields null?

YouTube does not show every metadata field in every page context.

For example, listing pages usually show title, URL, thumbnail, and view label, while direct video pages may expose different metadata.

The actor returns optional fields only when they are publicly available.

Should I change connection settings?

Direct access varies by region and target. Review the advanced input help before choosing an existing managed or custom proxy configuration. No connection option guarantees that YouTube will return the requested data.

Related Actors

• YouTube Channel Videos Scraper — Collect recent public YouTube channel video metadata, without promising a complete historical archive.
• YouTube Comments Scraper — Collect available public YouTube video comments and exposed replies.
• YouTube Search Results Scraper — Collect public YouTube search-result metadata for supported video, channel or playlist searches.
• YouTube Transcript Scraper — Collect available YouTube caption text and conditional timing from known video URLs.
• YouTube Video Details Scraper — Collect public YouTube video metadata and available engagement from known video URLs.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥