YouTube Shorts + Creator Lead Enrichment

YouTube Shorts Scraper — Views, Creator Emails and Channel Links

YouTube Shorts Scraper extracts public Shorts from any channel or keyword as structured JSON: title, viewCount, likes, duration, date, text and hashtags, plus the creator behind each Short — channelName, channelUsername, numberOfSubscribers, a best-effort public channelEmail and platform-tagged outbound links in channelLinksTyped. Every row carries 47 keys, typed and consistent across runs, with no HTML to parse. Paste handles or keywords and press Start.

What "creator lead enrichment" actually does

Read this before you plan an outreach workflow around the Actor's name. Three keys are added on top of the standard Shorts row, and they do not all work the same way.

channelLinksTyped and channelLinksText cost no extra request. For every Short, the Actor already calls YouTube's channel browse endpoint twice — once for the channel and once for its About tab — to fill in channelDescription, numberOfSubscribers, channelJoinedDate and the rest. The typed links are built by re-reading those two payloads: outbound URLs are unwrapped out of YouTube's youtube.com/redirect?q= wrapper, deduplicated, and labelled against a fixed platform list (Instagram, TikTok, Twitter/X, Facebook, Discord, Telegram, Twitch, LinkedIn, Pinterest, Snapchat, Threads, Patreon, Spotify, Linktree, Beacons, Cameo, OnlyFans, Reddit, WhatsApp, Amazon, Shopify, merch, and Website for anything unmatched). That is a reshape and a classification of data already in hand, not a new lookup.

channelEmail does cost extra requests — to Google, not to YouTube. With scrapeChannelEmails on, the Actor issues a Google search through Apify's GOOGLE_SERP proxy group in the form site:youtube.com "<handle or channel name>" ("@gmail.com" OR "@outlook.com" OR "@yahoo.com" OR "@hotmail.com" OR "@protonmail.com" OR "@icloud.com" OR "@business"), reads up to two pages of results, and pulls an address out of any result block whose visible text mentions that creator. Obvious non-contacts are filtered out — youtube.com, google.com, gstatic.com, googleapis.com, ggpht.com, ytimg.com, schema.org, w3.org, example.com, sentry.io, googleusercontent.com, youtu.be and goo.gl domains, and local parts like noreply, no-reply, abuse and postmaster. Free-provider addresses are preferred over anything else found.

YouTube's own business email is never touched. The "View email address" button on a channel's About tab is captcha-gated, and this Actor makes no attempt at it. There is no CAPTCHA solving anywhere in the code. What lands in channelEmail is therefore a heuristic match from third-party search snippets, not a value read from YouTube — treat it as a candidate to verify, not a confirmed address, and expect null for many creators.

One lookup per channel, per run. The email is cached against channelId (falling back to channelUrl), so a channel appearing across forty Shorts is looked up once and the same value is written to all forty rows. Setting freshEmailLookup to true bypasses that cache and re-queries Google for every single Short — slower, many more requests, the same answer in almost every case. Lookups are serialized behind a lock rather than run in parallel. There is no cap on how many distinct creators get looked up in a run.

The channel calls themselves are not cached. Only the email is. The two channel browse requests are repeated for every Short, so forty Shorts from one creator means eighty channel requests, not two.

A failed enrichment is still a charged row. If Google returns nothing, if the GOOGLE_SERP proxy is unavailable, or if the creator publishes no discoverable address, the row is still pushed with channelEmail: null and still bills one row_result event.

What is YouTube Shorts Scraper With Creator Lead Enrichment?

YouTube Shorts Scraper With Creator Lead Enrichment is an Apify Actor that resolves each channel handle, channel URL or search keyword you supply into a list of Shorts video IDs, fetches each Short from YouTube's own reel_item_watch endpoint, attaches the creator's public channel profile, and writes one flat dataset row per Short with 47 typed keys.

No YouTube account, login, cookie or API key is required, and none is accepted — the Actor reads what a signed-out visitor is served. It is built for influencer and creator-marketing teams building shortlists, growth teams tracking short-form performance across a niche, and developers piping Shorts metadata and creator context into an analytics or RAG pipeline.

What YouTube Shorts and channel data is publicly available to scrape?

YouTube serves a signed-out visitor the full public surface of a Short and of the creator behind it: title, description, view and like counts, comment count, duration, thumbnail, publish date, plus the channel's name, handle, description, subscriber count, join date, location, avatar, banner and every outbound link on its About tab. What it withholds is the creator's dashboard.

Data Category	Public, no login	Gated
Short title, description, hashtags, duration, thumbnail	✅	❌
View count, like count, comment count	✅	❌
Channel name, handle, ID, description, join date, location	✅	❌
Subscriber count, total video count, total channel views	✅	❌
Outbound About-tab links (website, socials, Discord, merch)	✅	❌
Channel business email behind the "View email address" button	❌	✅ captcha-gated reveal
Comment text and commenter identities	❌	✅ not requested by this Actor
Watch time, retention, traffic sources, revenue	❌	✅ creator's own YouTube Studio
Private, unlisted and members-only Shorts	❌	✅ signed-in access

YouTube Shorts Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall, and nothing behind the captcha-gated email reveal.

What data can I extract with YouTube Shorts Scraper?

Every row is one Short. All 47 keys are present on every row in a fixed order — a value the Actor could not read comes back null, false or an empty array rather than being dropped, so a CSV export has the same columns on every line.

Short identity and content fields

Field Name	Description
type	Constant "shorts" on every row
id	The 11-character YouTube video ID
url	Canonical https://www.youtube.com/shorts/<id> link
title	The Short's title, read from its description header
translatedTitle	Always null — no translation is performed
text	The Short's description; falls back to the title when the description is empty
translatedText	Always null — no translation is performed
hashtags	Array of hashtag words parsed out of the description, or the title, with the # stripped
descriptionLinks	Array of URLs found in the description, deduplicated, order preserved
thumbnailUrl	Highest-quality thumbnail YouTube offers, falling back to i.ytimg.com/vi/<id>/hqdefault.jpg
date	Publish date as YYYY-MM-DDT00:00:00.000Z — date only, midnight UTC, null if YouTube returned a relative date
duration	Runtime as HH:MM:SS, taken as the longest of every duration candidate in the payload
location	Recording location, when the Short carries one
subtitles	Array of {url, languageCode, name} caption tracks, or null when the Short has none
formats	Array of {quality, url} stream entries — see the truncation note below
collaborators	Always null

Engagement and status fields

Field Name	Description
viewCount	View count as an integer
likes	Like count as an integer
commentsCount	Comment count as an integer
commentsTurnedOff	true when the Short's comments are disabled
isMonetized	Monetization flag from the player microformat, null when absent
isAgeRestricted	Age-restriction flag
isMembersOnly	Always false
isPaidContent	Always false

viewCount, likes, commentsCount and numberOfSubscribers are returned as absolute integers, not display strings — but they are expanded from YouTube's abbreviated public text, so 1.2M becomes 1200000. Large counts carry the precision YouTube displays, not an exact figure.

Creator and channel fields

Field Name	Description
channelName	Creator's display name
channelUsername	The @handle
channelUrl	Canonical channel URL
channelId	The UC… channel ID
channelDescription	Full channel description from the About tab
channelJoinedDate	Channel creation date as YouTube writes it
channelLocation	Country listed on the About tab
channelDescriptionLinks	Flat array of outbound URL strings from the About tab
channelAvatarUrl	Channel avatar image URL
channelBannerUrl	Channel banner image URL
channelTotalVideos	Lifetime public video count on the channel
channelTotalViews	Lifetime channel view count
numberOfSubscribers	Subscriber count as an integer
isChannelVerified	Verification badge flag
inputChannelUrl	Channel URL as resolved from your input
aboutChannelInfo	Nested object repeating the 16 channel keys above as a single block, for consumers that want the creator profile in one place

Lead enrichment fields

Field Name	Description
channelEmail	Best-effort public email found via Google search, or null. Populated only when scrapeChannelEmails is on
channelLinksTyped	Array of {platform, title, url} objects — the About-tab links classified by platform and deduplicated by URL. Empty array when includeChannelLinks is off
channelLinksText	The same links flattened to one spreadsheet-friendly string, Platform: url | Platform: url, or null when there are none

Run context fields

Field Name	Description
input	The exact input string this row came from
fromYTUrl	The YouTube URL the Actor used as the referer — a channel Shorts tab or a search results URL
fromChannelListPage	"shorts" when the row came from a channel's Shorts tab, "search" when it came from keyword search
order	1-based position within that input, assigned at the moment the row is written

Two fields need a caveat before you build on them. formats[].url is deliberately truncated to the first 120 characters followed by an ellipsis — it identifies the available renditions but is not a playable or downloadable link, and the Actor downloads no media. And order reflects the sequence rows were written in, not a ranking; see the sorting note in the Input section.

🤖 Add-on: Need additional YouTube data?

If you need long-form videos rather than Shorts, YouTube Video Details Scraper returns full video metadata and transcripts, and YouTube Search Scraper covers videos, channels and playlists from a query. To build the channel list first and then feed it here, YouTube Channel Finder discovers channels by keyword or URL, and YouTube Community Posts Scraper covers the posts and polls a channel publishes between uploads.

How does YouTube Shorts Scraper differ from the official YouTube Data API?

The YouTube Data API v3 is public, documented and free to apply for, and it covers the same underlying objects — videos, channels, search. The difference is what it hands you and what it makes easy. Per Google's published API reference, videos.list returns a video's snippet and statistics and channels.list returns a channel's snippet, statistics and branding settings; there is no Shorts resource and no documented Shorts filter, and neither endpoint exposes a channel's business email, because YouTube keeps that behind an interactive reveal on the web front end.

Feature	YouTube Data API v3	YouTube Shorts Scraper
Shorts as a first-class object	No Shorts resource or filter documented; Shorts surface as ordinary videos	Reads the channel Shorts tab directly, and uses YouTube's own Shorts search filter for keywords
Setup	Google Cloud project, API key or OAuth client, quota managed per project	Apify token; nothing to register with Google
Channel profile alongside each video	Separate channels.list call you make and join yourself	Attached to every row already, including About-tab links
Creator contact detail	Not exposed by any documented endpoint	Best-effort channelEmail from public search results, plus typed About-tab links
Output shape	Nested API response you normalize yourself	Flat 47-key row, same keys every run, straight to JSON, CSV or Excel
Accounting	Per-project quota units, with search costing far more than a plain read	Charged per result row, no quota to manage

Use the official API when you are operating on your own channel, need write access, need comment threads or captions, or need a support relationship with Google. Use this Actor when you want Shorts specifically, want the creator attached to every Short without a join, and want rows you can hand to a spreadsheet or an agent without post-processing.

How to use YouTube Shorts Scraper With Creator Lead Enrichment

The Actor runs on Apify. Start it from the Apify Console or call it through the Apify API — there is no separate signup and no Google account to create.

1. Open YouTube Shorts Scraper With Creator Lead Enrichment on Apify and click Try for free
2. Fill Channels or keywords — the one required input. @MrBeast, mrbeast, https://www.youtube.com/@MrBeast, a UC… channel ID and a plain keyword like funny shorts all work, mixed freely in one list
3. Set Max Shorts per channel. It accepts 1 to 10,000 and applies per entry — read the note below on values under 10
4. Leave Find creator business email and Include typed channel links on for the lead columns, or switch the email off to skip the Google lookups entirely
5. Click Start — rows stream into the output table as each Short finishes
6. Export as JSON, CSV or Excel, or read the dataset through the Apify API

How to scale to bulk Shorts extraction

startUrls is an array, so one run handles as many channels and keywords as you list, and each entry gets its own maxResults budget — ten handles at 100 Shorts each is a 1,000-row run. Entries are processed one after another, but within an entry up to 10 Shorts are fetched concurrently. The email cache is shared across the whole run, so listing several handles that belong to the same creator costs one email lookup, not several. Video IDs are deduplicated within an entry only, so if two of your keywords surface the same Short, it is written and charged twice.

What can you do with YouTube Shorts and creator data?

• 🎯 An influencer marketer building a niche shortlist runs ten keyword entries, filters rows on numberOfSubscribers and viewCount, then works channelLinksTyped to find each creator's Instagram or Linktree before deciding who is worth approaching.
• 📈 A short-form content strategist pulls the last 100 Shorts from five competitor handles and compares viewCount against duration, date and hashtags to see which lengths and topics are actually carrying the channel.
• 🔍 A brand-safety analyst screens a creator list by reading text, hashtags and isAgeRestricted across their recent Shorts, using channelDescription and channelLocation for context before a sponsorship goes to legal.
• 💼 A partnerships researcher exports to CSV and sorts on channelLinksText, a single flat column, to triage which creators publish a Discord, a merch store or a Patreon — signals that a creator already monetizes an audience.
• 🤖 An AI engineer building a trend-summarization agent indexes text and title with viewCount, date, channelName and hashtags as metadata filters, so the agent can answer "what were the highest-viewed Shorts about this topic last month" against real rows rather than a summary.

Every one of these is callable from an agent framework over the Apify API, since the Actor is a standard HTTP-triggered run.

How does YouTube Shorts Scraper handle rate limits and blocking?

No browser is launched at any point. The Actor makes plain HTTP requests to YouTube's own internal endpoints, sending a desktop Chrome user agent, a matching referer and a client version it extracts live from the page it is about to call — so its requests look like the ones a browser makes rather than a generic script.

Every request gets up to three attempts, with an exponential backoff starting at 0.8 seconds and doubling between them. That retry covers transport failures — timeouts, dropped connections, proxy errors. A response that arrives with a non-200 status is not retried: the Short is skipped and no row is written for it. When the Actor resolves a channel's Shorts listing it pauses 1 second between listing pages and allows three attempts per page with a 2-second base delay.

Concurrency is deliberately modest: up to 10 Shorts in flight per input entry, a connection pool of 12, and a 60-second total timeout per request. Google searches for channelEmail are serialized one at a time behind a lock rather than fired in parallel.

There is no CAPTCHA solving in this Actor, and none is claimed. The only captcha it meets is YouTube's email reveal, which it does not attempt. On the Google side, a small response carrying Google's "our systems have detected unusual traffic" notice is treated as blocked and returns no email — deliberately only when the page is small, so a normal results page that merely mentions the phrase in a footer is not thrown away.

⬇️ Input

One parameter is required: startUrls. Everything else has a default, and a run with nothing else set collects Shorts from your entries with email enrichment and typed links both on.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Where to scrape Shorts from. Channel handles (@MrBeast), bare usernames (mrbeast), full channel URLs, UC… channel IDs, or search keywords. Prefilled with ["MrBeast"].	["@mkbhd", "https://www.youtube.com/@veritasium", "kitchen gadgets"]
maxResults	No	integer	Maximum Shorts per channel or keyword. Minimum 1, maximum 10000. Default 10.	50
scrapeChannelEmails	No	boolean	Look up each creator's public business email via Google through the GOOGLE_SERP proxy. Emits null when none is found. Default true.	true
freshEmailLookup	No	boolean	Bypass the per-run channel email cache and re-query Google for every Short. Default false.	false
includeChannelLinks	No	boolean	Emit channelLinksTyped and channelLinksText from the creator's About-tab links. Default true.	true
publishedAfter	No	string	Only Shorts published after this point. Accepts YYYY-MM-DD or a relative period such as 7 days. Empty includes all Shorts.	"30 days"
sortOrder	No	string	newest, popular or oldest. Default "newest".	"newest"
proxyConfiguration	No	object	Apify Proxy settings for the YouTube requests. Prefilled with {"useApifyProxy": false}.	{"useApifyProxy": true}

Eight honest notes on how these behave in the code, as opposed to how the labels read:

• maxResults below 10 has no effect. The collection target is the larger of 10 and your value, and nothing trims the list afterwards, so every entry returns at least 10 Shorts — and each one is a charged row. maxResults: 1 and maxResults: 10 produce identical runs. Values of 10 and above behave exactly as labelled. A non-numeric or sub-1 value falls back to 10.
• publishedAfter only recognises three periods. The filter matches a string containing 7 and day, 30 and day, or 1 and year — so 7 days, 30 days and 1 year work. Anything else, including the YYYY-MM-DD date the date picker produces and values such as 2 weeks or 6 months, is accepted and then silently ignored, and no date filtering happens at all. Shorts excluded by a working filter are dropped before the row is written, so a filter that does apply also reduces what you are charged.
• sortOrder does not reorder the dataset. Rows are written the moment each Short's detail request completes, and the sort is applied afterwards to the run's in-memory list — which is not re-written. Dataset order is completion order, and order numbers that same sequence. Sort client-side on date or viewCount after export; popular additionally depends on viewCount having parsed to a number.
• proxyConfiguration is only read when useApifyProxy is true, and a single proxy URL is drawn once at the start of the run and reused for every YouTube request — there is no per-request rotation. With the prefilled false, all YouTube traffic goes out directly from the Apify platform.
• Email enrichment ignores proxyConfiguration entirely. It always builds its own GOOGLE_SERP proxy configuration. If that configuration cannot be created, the run logs a warning, continues, and channelEmail is null on every row.
• freshEmailLookup is rarely worth the cost. It re-queries Google once per Short instead of once per channel, using the same query built from the same handle, so it usually returns the same answer many times over while lengthening the run.
• An empty startUrls ends the run immediately. The Actor logs that no channels or keywords were provided and exits successfully with zero rows and no charges. It does not fail.
• A handle that does not exist becomes a keyword search. If a channel's Shorts tab yields no video IDs, the Actor logs that it is falling back and re-runs the same string as a YouTube Shorts search. A typo'd handle therefore returns real, charged rows for unrelated Shorts rather than an error. Check fromChannelListPage — it reads "search" on any row that came in this way.

Undocumented aliases: although the field is a string list, each array entry may also be an object carrying a url, handle or keyword key — {"handle": "@mkbhd"} behaves exactly like "@mkbhd". Prefer the plain strings the Console produces.

Example input

{
  "startUrls": [
    "@mkbhd",
    "https://www.youtube.com/@veritasium",
    "kitchen gadgets"
  ],
  "maxResults": 50,
  "scrapeChannelEmails": true,
  "freshEmailLookup": false,
  "includeChannelLinks": true,
  "publishedAfter": "30 days",
  "sortOrder": "newest",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

⬆️ Output

Typed, normalized JSON with a stable 47-key schema across runs. Rows stream into the dataset as each Short finishes rather than arriving at the end, so a long run fills the output table while it is still going. Export as JSON, CSV or Excel, or read the dataset through the Apify API.

Every row in the dataset is a result row, and every result row is charged as one row_result event. This Actor writes no error rows, no diagnostic rows and no accounting rows: there is exactly one dataset write in the entire codebase, and it is always charged. No errorReason, status, isError, isDiagnostic, rowType, fetchOutcome, success or charged marker exists anywhere in the output, because no such row is ever produced. There is no filter expression to write and nothing to exclude — failures live in the run log, not in the data.

Be careful with type: it is a constant, not a discriminator. Every row carries "type": "shorts", including rows where enrichment came back empty.

Nothing is ever omitted. Every row carries all 47 keys in the same order. A value the Actor could not read is null, false, or an empty array — channelLinksTyped is [] when links are off or none were found, channelEmail is null when the lookup failed or was disabled. Direct key indexing is safe, and a CSV export has identical columns on every line.

Deduplication is per input entry, not per run. Video IDs are deduplicated within a single channel or keyword, so one entry never yields the same Short twice. Across entries there is no dedupe: a Short reachable from two of your keywords is written and charged twice. Creator email lookups are the exception — those are cached run-wide by channelId, so the same creator is only ever queried once unless freshEmailLookup is on.

Example output

One Short — all 47 keys:

{
  "title": "The $8 gadget that replaced my whole knife block #kitchen",
  "translatedTitle": null,
  "type": "shorts",
  "id": "kR2xTv9QpLm",
  "url": "https://www.youtube.com/shorts/kR2xTv9QpLm",
  "thumbnailUrl": "https://i.ytimg.com/vi/kR2xTv9QpLm/maxresdefault.jpg",
  "viewCount": 1400000,
  "date": "2026-07-11T00:00:00.000Z",
  "likes": 92000,
  "location": null,
  "channelName": "Prep Bench",
  "channelUrl": "https://www.youtube.com/@prepbench",
  "channelUsername": "@prepbench",
  "collaborators": null,
  "channelId": "UCq7Yh2fJ0mXwB4tLnPa8ZdQ",
  "channelDescription": "Two-minute kitchen tests, no sponsorships we haven't used ourselves. New Shorts Tuesday and Friday. Business enquiries via the links below.",
  "channelJoinedDate": "Mar 14, 2019",
  "channelDescriptionLinks": [
    "https://www.instagram.com/prepbench",
    "https://linktr.ee/prepbench",
    "https://prepbench.co/gear"
  ],
  "channelLocation": "United Kingdom",
  "channelAvatarUrl": "https://yt3.googleusercontent.com/ytc/AOPolaS-prepbench=s900-c-k-c0x00ffffff-no-rj",
  "channelBannerUrl": "https://yt3.googleusercontent.com/BsRq1-prepbench-banner=w2560-fcrop64=1,00005a57ffffa5a8-k-c0xffffffff-no-nd-rj",
  "channelTotalVideos": 412,
  "channelTotalViews": 208400000,
  "numberOfSubscribers": 894000,
  "isChannelVerified": true,
  "inputChannelUrl": "https://www.youtube.com/@prepbench",
  "isAgeRestricted": false,
  "aboutChannelInfo": {
    "channelDescription": "Two-minute kitchen tests, no sponsorships we haven't used ourselves. New Shorts Tuesday and Friday. Business enquiries via the links below.",
    "channelJoinedDate": "Mar 14, 2019",
    "channelDescriptionLinks": [
      "https://www.instagram.com/prepbench",
      "https://linktr.ee/prepbench",
      "https://prepbench.co/gear"
    ],
    "channelLocation": "United Kingdom",
    "channelUsername": "@prepbench",
    "channelAvatarUrl": "https://yt3.googleusercontent.com/ytc/AOPolaS-prepbench=s900-c-k-c0x00ffffff-no-rj",
    "channelBannerUrl": "https://yt3.googleusercontent.com/BsRq1-prepbench-banner=w2560-fcrop64=1,00005a57ffffa5a8-k-c0xffffffff-no-nd-rj",
    "channelTotalVideos": 412,
    "channelTotalViews": 208400000,
    "numberOfSubscribers": 894000,
    "isChannelVerified": true,
    "channelName": "Prep Bench",
    "channelUrl": "https://www.youtube.com/@prepbench",
    "channelId": "UCq7Yh2fJ0mXwB4tLnPa8ZdQ",
    "inputChannelUrl": "https://www.youtube.com/@prepbench",
    "isAgeRestricted": false
  },
  "duration": "00:00:47",
  "commentsCount": 3100,
  "text": "The $8 gadget that replaced my whole knife block. Full test on the main channel. #kitchen #gadgets #cooking",
  "translatedText": null,
  "descriptionLinks": [
    "https://prepbench.co/gear"
  ],
  "subtitles": [
    {
      "url": "https://www.youtube.com/api/timedtext?v=kR2xTv9QpLm&lang=en",
      "languageCode": "en",
      "name": "English (auto-generated)"
    }
  ],
  "order": 3,
  "commentsTurnedOff": false,
  "fromYTUrl": "https://www.youtube.com/@prepbench/shorts",
  "isMonetized": true,
  "hashtags": [
    "kitchen",
    "gadgets",
    "cooking"
  ],
  "formats": [
    {
      "quality": "1080p",
      "url": "https://rr3---sn-4g5e6nsz.googlevideo.com/videoplayback?expire=1784592210&ei=Uk9xZ-2QpLm..."
    }
  ],
  "isMembersOnly": false,
  "input": "@prepbench",
  "fromChannelListPage": "shorts",
  "isPaidContent": false,
  "channelLinksTyped": [
    {
      "platform": "Instagram",
      "title": "Instagram",
      "url": "https://www.instagram.com/prepbench"
    },
    {
      "platform": "Linktree",
      "title": "All links",
      "url": "https://linktr.ee/prepbench"
    },
    {
      "platform": "Website",
      "title": "Gear we use",
      "url": "https://prepbench.co/gear"
    }
  ],
  "channelLinksText": "Instagram: https://www.instagram.com/prepbench | Linktree: https://linktr.ee/prepbench | Website: https://prepbench.co/gear",
  "channelEmail": "hello@prepbench.co"
}

How does it work?

For each entry you supply, the Actor works out whether it is a channel or a keyword. A handle, username, channel URL or UC… ID becomes a channel Shorts tab URL; anything it cannot resolve becomes a Shorts search. It loads that page, lifts YouTube's own initial data and client version out of the HTML, then pages through YouTube's internal browse or search endpoint with continuation tokens until it has enough video IDs.

Each ID is then fetched from the reel watch endpoint, and the channel behind it from the browse endpoint twice — once for the channel and once for its About tab. Those payloads are parsed into the fixed 47-key row, the About-tab links are unwrapped and classified, the creator email lookup runs against Google through Apify's GOOGLE_SERP proxy, and the row is written immediately.

Requests go out directly unless you enable Apify Proxy. No browser is launched, no login is used, no cookie is sent, and only publicly visible data is collected. Because the output keys are defined by the Actor rather than by YouTube's markup, a front-end redesign can affect coverage of individual fields but never your field names or their types.

Integrations

YouTube Shorts Scraper is an Apify Actor, so it works with anything that can call the Apify API or consume a dataset — scripts, schedules, webhooks, no-code builders and agent frameworks.

Calling YouTube Shorts Scraper from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/youtube-shorts-scraper-creator-lead-enrichment").call(run_input={
    "startUrls": ["@mkbhd", "kitchen gadgets"],
    "maxResults": 50,
    "scrapeChannelEmails": True,
    "publishedAfter": "30 days",
})

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())

for row in sorted(items, key=lambda r: r["viewCount"] or 0, reverse=True):
    print(row["viewCount"], row["title"], row["channelUsername"], row["channelEmail"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request. Sort client-side, as shown, rather than relying on sortOrder.

No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node — or an HTTP Request node pointed at the Actor's run endpoint with your token — and pass the same JSON input shown above; an IF node on channelEmail splits creators with a discoverable address from the rest before a Google Sheets or Airtable step. In Make, the Apify module supports run-and-wait, so a weekly sweep of a competitor handle list can feed a spreadsheet or CRM step directly. In LangChain, wrap the run endpoint as a tool and pass title, text and hashtags straight to the model — the description is already plain text with no markup to strip. Apify schedules and webhooks cover recurrence and completion triggers.

⚠️ Is it legal to scrape YouTube Shorts and creator details?

Collecting data published on a public page, with no login bypassed and no captcha defeated, is broadly treated as permissible, and this Actor does neither — it reads only what a signed-out visitor is served. But the output is personal data about identifiable people, and where channelEmail is populated it is personal contact data. The moment you store a row, you are a data controller.

channelName, channelUsername, channelId, channelUrl, channelDescription, channelAvatarUrl, channelLocation, channelEmail, channelLinksTyped and channelLinksText identify or relate to an identifiable person, as do numberOfSubscribers and channelTotalViews once attached to them. Under GDPR and UK GDPR you need a lawful basis before you store or reuse any of it. If you rely on legitimate interest, that requires a documented balancing test completed before collection, not after a complaint. Because the data is collected indirectly rather than from the person, Article 14 transparency duties apply — you owe the creator notice of what you hold and why, within the regulation's time limits — alongside retention limits and the duty to answer access and erasure requests. Keep the channelId-to-source mapping you would need to honour one.

A creator is not automatically a business. A great many YouTube channels belong to individuals, hobbyists and sole traders operating under their own name, and in the EU and UK a sole trader's business contact detail is still that individual's personal data. A dedicated business enquiry address published for partnerships and a creator's personal inbox carry very different risk — and because channelEmail here is inferred from public search results rather than read from a labelled business field, you cannot tell which one you have got from the data alone. Verify before you use it.

Direct marketing is a separate and stricter regime from data protection. In the EU and UK, unsolicited electronic marketing is governed by the ePrivacy rules and PECR in addition to GDPR, each with its own consent and opt-out requirements. In the US, commercial email falls under CAN-SPAM alongside state-level privacy statutes such as the CCPA and CPRA. "It was published on the channel" is not, on its own, a lawful basis for emailing someone, and running this Actor does not obtain or convey anyone's permission to be contacted. Screen any list against your suppression and unsubscribe records before sending, and honour opt-outs across every list you hold rather than per campaign.

Minimise concretely: if your analysis is about content performance, drop the creator contact columns at ingestion and keep viewCount, likes, duration, date and hashtags. Consult qualified legal counsel if your use case involves bulk storage of personal data or outbound marketing.

❓ Frequently asked questions

What YouTube Shorts fields does YouTube Shorts Scraper return?

Forty-seven keys per Short. The five you will use most are title, viewCount, likes, channelUsername and channelEmail, with duration, date and hashtags close behind for performance analysis. See the data fields tables above for the full list, including the nested aboutChannelInfo object and the three enrichment keys.

Does YouTube Shorts Scraper require a YouTube account or login?

No. There is no YouTube account, cookie, session or Data API key involved, and none can be supplied. The Actor reads YouTube's public endpoints the same way a signed-out browser does, and the only credential you need is your Apify token. One consequence: the creator's business email behind YouTube's captcha-gated reveal is unreachable, which is why channelEmail is sourced from public search results instead.

How many Shorts can I extract in one run?

maxResults accepts 1 to 10,000 and applies per entry, so ten handles at 200 each is a 2,000-row target in one run. Whether you reach it depends on how many Shorts the channel actually has. Two caveats: any value below 10 is raised to 10, so a small run has a floor of 10 charged rows per entry; and if a working publishedAfter filter is set, Shorts outside the window are dropped before being written, so you may get fewer rows than you asked for.

What happens if a Short is removed or private, or the channel is unavailable?

A Short that cannot be fetched is skipped entirely — no row, no charge. If the detail request returns a non-200 status or an unparseable body, or if anything throws while parsing, the Actor drops that video and moves on. Removed and private Shorts usually never appear in the listing in the first place; a stale ID falls into this same path.

If the Short loads but the channel requests fail, the row is still written and still charged, with the channel detail fields — channelDescription, channelJoinedDate, channelId, channelAvatarUrl, channelTotalVideos and the rest — null, aboutChannelInfo present but mostly empty, channelLinksTyped [] and channelLinksText null. channelName, channelUrl and numberOfSubscribers often survive, because they also appear in the Short's own payload.

A channel handle that does not exist is the case to watch: rather than erroring, the Actor falls back to running your string as a Shorts keyword search. You get real, charged rows for Shorts that have nothing to do with the creator you meant. Check fromChannelListPage for "search" and input for the original string when auditing a run.

Can I scrape multiple YouTube channels and keywords at once?

Yes — that is the intended shape. startUrls is an array and mixes freely: channel handles, channel URLs, UC… IDs and plain keywords in the same list. Entries are processed sequentially, each with its own maxResults budget, with up to 10 Shorts fetched concurrently inside an entry. Deduplication is per entry, so overlapping keywords can produce the same Short twice.

Does YouTube Shorts Scraper work with Claude, ChatGPT and other AI agent tools?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n or a custom tool definition can invoke it and receive typed JSON. Short titles and descriptions arrive as clean plain text, so title and text go straight into an LLM context window or a vector store with no HTML stripping.

How does this compare to other YouTube creator-lead scrapers on the Apify Store?

Checked on the Apify Store on 25 July 2026, the closest listings differ mainly in what they treat as the unit of data. coregent/youtube-creator-leads-finder documents a 16-field, channel-only output — channelName, subscribers, email, instagram, contactLinks and so on — with keyword search as its only input; its README does not mention Shorts anywhere, and documents no per-video metrics, no proxy input and no sorting or date filter. scrapesage/youtube-scraper documents channel records plus optional video records, and its FAQ states that YouTube "puts the channel's 'business email' behind a CAPTCHA, so it isn't machine-readable", sourcing contacts by crawling the creator's own website instead; it mentions Shorts once, only as an accepted URL format for its video-details mode, and states no field count for its video records. kjernekode/ai-viral-shorts-creator-youtube-shorts is not a Shorts scraper despite the name — it takes one long-form video URL plus your own OpenAI key and renders vertical clips, returning no channel or creator data. None of the three documents error or failure rows.

The observable difference is the unit: this Actor returns one row per Short with the creator attached to each, so you can rank creators by the performance of their recent short-form output rather than by channel-lifetime totals. On email it lands between the other two — it agrees with scrapesage that YouTube's own reveal is captcha-gated and unreachable, but looks for an address in public search results rather than by crawling the creator's website. Neither approach guarantees a hit, and this Actor claims no coverage rate.

Does YouTube Shorts Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names across runs, no HTML and no selectors. Pass the rows directly to an LLM, index them into a vector store, or feed them to an agent tool. Because every row carries all 47 keys with the same types, no shape-handling is needed.

What happens when YouTube changes its layout or anti-bot system?

The Actor does not parse rendered page HTML for Short content — it reads YouTube's own internal JSON endpoints and extracts the client version it needs live from the page it is about to call, so a visual redesign does not affect it directly. What can change is the shape of those JSON payloads, which the extraction handles with layered fallbacks: view counts, like counts, subscriber counts and comment counts are each tried against several different payload structures before giving up and returning null. The Actor is maintained, and the output field names and types stay stable regardless.

Can I use YouTube Shorts Scraper without managing proxies or browser infrastructure?

Yes. No browser is launched at any point — the Actor makes plain HTTP requests. YouTube traffic goes out directly unless you switch proxyConfiguration.useApifyProxy on, in which case one Apify Proxy URL is used for the run. The Google side is handled for you regardless: the email lookup always builds its own GOOGLE_SERP proxy configuration, with nothing for you to set up separately.

Which YouTube Shorts fields work best for AI training data and RAG indexing?

For RAG, text and title carry the most information per record — the description and title as plain text — with hashtags supplying creator-applied topic tags as ready-made metadata filters and channelId as a partition key. channelDescription adds useful creator context when you want the agent to reason about who published something. For training data and feature extraction, the most structurally consistent fields are viewCount, likes, commentsCount, numberOfSubscribers, channelTotalViews, duration and date — all typed primitives, with date already normalized to UTC ISO-8601 so a cross-channel time series needs no timezone handling. Keep the personal-data obligations in the legal section in mind before pushing channelEmail or creator identity into a training set or a shared vector store.

🔗 Related scrapers

Scraper Name	What it extracts
YouTube Video Details Scraper	Long-form video metadata and transcripts
YouTube Search Scraper	Videos, channels and playlists from a search query
YouTube Channel Finder	Channel discovery by keyword or URL
YouTube Community Posts Scraper	Channel community posts, polls and engagement
TikTok Video Scraper (Creator Profile & Contact)	TikTok videos with the creator's profile and contact attached
Instagram Reel Creator Insights Scraper	Reels with creator-level performance context
Pinterest Comment Scraper With Commenter Profile Enrichment	Pin comments with the commenter's public profile attached

💬 Your feedback

Found a bug, or a channel whose Shorts come back short of what the tab shows? Open an issue on the Actor's Issues tab. Reports that include the exact input JSON — the handle or keyword and your maxResults and publishedAfter values — are the fastest to reproduce and fix.