Youtube Community Posts Scraper

YouTube Community Posts Scraper — Text, Polls, Likes and Images

YouTube Community Posts Scraper extracts the Community tab of any public YouTube channel as structured JSON: post text, poll answer options, like and comment counts, attached image and video-thumbnail URLs, publish time, and the channel identity behind each post. Paste channel URLs, set how many posts you want per channel, and rows stream into the dataset live as each post is parsed — no login, no HTML parsing, no selectors.

⚠️ Two things worth knowing before your first run. Poll answer options are returned in pollChoices, but poll vote totals and per-option percentages are not — the Actor reads the choice text only. And maxPosts is a limit per channel, not per run.

What is YouTube Community Posts Scraper?

YouTube Community Posts Scraper is an Apify Actor that loads a channel's /posts page, reads YouTube's own ytInitialData payload out of the HTML, and then pages through YouTube's internal youtubei/v1/browse continuation feed until it reaches your post limit. Every community post comes back as one flat row with the same 13 keys.

No YouTube account, Google login, cookie or API key is used anywhere in the run. Everything returned is what a signed-out visitor sees on the Community tab.

It is built for creator-management and talent teams tracking roster engagement, brand and social-listening researchers reading what creators actually say to their audience, and developers and AI engineers piping post text into dashboards, RAG indexes or agent tools.

What YouTube community post data is publicly available to scrape?

YouTube renders a channel's Community tab to logged-out visitors in full: post text, relative publish time, like and comment counts, poll questions and their answer options, attached images and shared-video thumbnails are all present before any sign-in. What sits behind a gate is membership-restricted content and anything that requires you to interact with the post yourself.

Data Category	Publicly Available	Requires sign-in or paid channel membership
Post text and captions	✅ Public	—
Relative publish time ("2 weeks ago")	✅ Public	—
Like count and comment count as display strings	✅ Public	—
Poll question and answer options	✅ Public	—
Attached images and shared-video thumbnails	✅ Public	—
Channel display name, channel ID and channel URL	✅ Public	—
Per-option poll percentages	❌ — YouTube reveals them only after you cast a vote	Signed-in account
Members-only community posts	❌	Paid channel membership on that channel
Who liked a post, and voter identities on a poll	❌ — never rendered to anyone	Not available at all

YouTube Community Posts Scraper only returns publicly visible data — what any signed-out visitor sees on the Community tab. Nothing behind a login wall, and nothing behind a channel membership.

Two things YouTube does show publicly that this Actor deliberately does not collect: the total vote count printed under a poll, and the comment text under a post. It returns the poll's answer options and the comment count only.

What data can I extract with YouTube Community Posts Scraper?

Every community post is one dataset row carrying four groups of data: what the post says, who published it and when, how the audience engaged with it, and what media or poll is attached.

Field Name	Description
channelId	The channel's UC… ID, resolved once per channel from YouTube's own page metadata. Falls back to the post author's browse ID when the channel-level lookup finds nothing
postId	YouTube's Ugkx… community post identifier. Stable — use it as your dedupe and join key
author	The channel's display name as printed on the post, e.g. MrBeast
authorUrl	YouTube's canonical base path for the channel, e.g. /@MrBeast — a path, not an absolute URL. Prefix it with https://www.youtube.com to open it
text	Full post body, with YouTube's text runs joined into one string. "" on posts that carry only an image or a poll with no caption
publishedTime	YouTube's relative publish label, e.g. 2 weeks ago — a string, not a date. See the note below
likeCount	Like count as YouTube's display string, e.g. "12K". null when YouTube prints 0 or no count at all
commentCount	Comment count as YouTube's display string, e.g. "1.4K". null when the reply button is absent — for example when comments are turned off
pollChoices	Array of the poll's answer option texts, in the order YouTube lists them. [] on every non-poll post. Vote totals and percentages are not included
videoThumbnail	Highest-resolution thumbnail URL when the post shares a video. null otherwise
images	Array of URLs for an attached image — see the note below, this is one image at several resolutions, not a carousel. [] when the post has no single-image attachment
attachmentType	"video", "image", "poll", or null for a text-only post. Use it to segment rows by post type
sourceUrl	The channel URL exactly as you supplied it in channelUrls, so every row traces back to your input

Post identity, author and timing fields

postId is the stable key — it is the same Ugkx… string YouTube uses in the permalink, so https://www.youtube.com/post/{postId} reconstructs a link to any row. There is no post-URL field in the output; build it from postId when you need one. channelId, author and authorUrl identify the publisher, and sourceUrl ties the row back to the entry you typed, which is what you group on when a run covers many channels.

publishedTime deserves a plain statement: it is YouTube's relative label as rendered, such as 3 days ago or 1 year ago, not a timestamp. The Actor requests pages with Accept-Language: en-US, so the phrasing comes back in English and is parseable with a simple rule, but if you need an absolute date you must convert it against the run's own date yourself. Rows arrive in the order YouTube serves them, newest first, so relative ordering within a channel is reliable even though the values are approximate.

Engagement, attachment and media fields

likeCount and commentCount are the two engagement figures, and both are strings taken verbatim from YouTube's display text — "12K", "1.4K", "827". They are not parsed to integers, so cast them yourself if you plan to sort or sum. One behaviour to code around: likeCount is null rather than "0" when a post has no likes, because the Actor treats YouTube's 0 as "no count" and writes null. Treat null as zero-or-unknown, not as an error.

attachmentType tells you which media branch fired. On a "poll" post, pollChoices carries the answer options and nothing else — YouTube's poll renderer also prints a total vote figure, and this Actor does not read it, so if aggregated poll results are what you are after, this is not the field that provides them. On a "video" post you get videoThumbnail only: no shared video ID, title or watch URL. On an "image" post, images is the thumbnails array YouTube supplies for that one image at ascending resolutions — the last entry is the largest — rather than a list of distinct images. Multi-image carousel posts use a renderer the Actor does not parse, so they land as attachmentType: null with images: [], with their text intact.

Nothing is ever omitted from a row. All 13 keys are written on every post, using null for missing scalars and [] for missing arrays, so row["field"] is always safe and your table columns stay stable across runs.

🤖 Add-on: Need additional YouTube data?

Community posts are only one surface of a channel. YouTube Video Details Scraper goes deep on any single video, including transcripts, when a community post points at an upload. YouTube Search Scraper finds videos, channels and playlists by keyword when you do not yet know which channels to watch, and YouTube Channel Finder resolves channels from names and handles into the URLs this Actor takes as input. For a channel's actual catalogue rather than its posts, YouTube Playlist Scraper returns full playlist contents with per-video stats.

Why not build this yourself?

Start with the reason this Actor exists at all: the official YouTube Data API v3 has no community-posts endpoint. Google's published API reference covers videos, channels, playlists, search, captions and comment threads — community posts are simply not among the resources it exposes. Check Google's current YouTube Data API v3 reference yourself before assuming otherwise; that absence, not a quota or a pricing difference, is why every tool in this category reads the public page instead. There is no approved API route to this data, so a comparison table between "the official API" and this Actor would have nothing to compare.

That leaves scraping the Community tab, and the honest version of that job is more work than it first looks. The post feed is not in the HTML you get back — it lives inside a ytInitialData JavaScript blob you have to extract and parse, and only the first batch of posts is in it. Everything after that comes from YouTube's internal youtubei/v1/browse endpoint, which needs an INNERTUBE_API_KEY and a full INNERTUBE_CONTEXT object lifted from a separate ytcfg.set(...) call in the same page, plus a continuation token that YouTube nests in one of four different places depending on which renderer variant it served you. This Actor handles all four.

Then the shapes multiply. A post can arrive as backstagePostThreadRenderer or as a bare backstagePostRenderer; its attachment can be a pollRenderer, a videoRenderer or a backstageImageRenderer; the comment count hides in a reply button that is sometimes simpleText and sometimes a runs array you have to scan for digits. Every one of those is a branch someone has to maintain, and YouTube changes them without notice. Add proxy handling, retries with backoff, and the plumbing to stream rows into a dataset as they parse, and the build is not an afternoon. Running this Actor is a paste-and-start.

How to use YouTube Community Posts Scraper

YouTube Community Posts Scraper runs on Apify. Start it from the Apify Console, or call it through the Apify API with your Apify token — there is no separate signup and no API key of its own.

1. Open YouTube Community Posts Scraper on Apify and click Try for free
2. Add your targets to Channel URLs (channelUrls) — this is the only required input. One channel URL per line
3. Set Max posts per channel (maxPosts) — the default 10 is a quick smoke test; raise it to pull more history
4. Optionally open Proxy settings (proxy) and pick an Apify proxy group or paste a custom proxy URL. The default is a direct connection with no proxy
5. Click Start, then export the dataset as JSON, CSV, Excel or XML

Channels are processed sequentially, one after another, and each post is pushed to the dataset the moment it is parsed — you can start reading rows before the run finishes. A running tally of posts scraped, successful channels and failed channels is written to the run's key-value store under the SUMMARY key while the run is in progress.

How to scale to bulk community post extraction

channelUrls is a list, so one run covers as many channels as you need — paste ten, or a hundred, and they all run in the same job. A single comma-separated string is also accepted and split on commas, which means a value carried in from a spreadsheet cell or another Actor usually works unchanged.

maxPosts applies per channel, not as a run total: twenty channels at maxPosts: 200 is a ceiling of 4,000 rows, not 200. A channel that fails or has no posts contributes nothing and the run simply moves to the next one. For recurring monitoring, put the same input on an Apify schedule and attach a webhook so each finished dataset lands in your own store.

What can you do with YouTube community post data?

• 📊 A creator-management analyst tracking a talent roster runs every managed channel in one job and ranks likeCount against commentCount per postId, finding which creators drive more engagement through posts than through uploads.
• 🗳️ A brand researcher vetting a sponsorship filters rows to attachmentType == "poll" and reads pollChoices alongside text, seeing exactly which questions a creator puts to their audience before signing anything.
• 🕐 A content strategist planning a posting cadence groups publishedTime buckets against likeCount across a competitor set to work out how often those channels post and which cadence their audience actually rewards.
• 🖼️ A social-listening engineer watching for product mentions indexes text per postId with sourceUrl as the channel key, and alerts on new rows whose text matches a brand watchlist.
• 🤖 An AI engineer building a creator-intelligence agent embeds text with author, publishedTime and attachmentType as metadata, so the agent can answer "what has this creator told their community about the new launch, and how did engagement compare to their usual posts" against live public data rather than a stale export.

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 Community Posts Scraper handle rate limits and blocking?

The Actor does not drive a browser and does not solve CAPTCHAs. It fetches pages over plain HTTP with a fixed desktop Chrome user-agent and an Accept-Language: en-US,en header, then parses YouTube's embedded JSON. Its defences are retries, backoff and an egress fallback chain.

Retries and backoff. The initial channel-page fetch gets up to 3 attempts by default, with a 15-second request timeout and a 2-second delay after a failure that doubles on each subsequent retry. All three of those figures are configurable — see the undeclared parameters noted in the Input section.

Egress fallback. The Actor builds an ordered list of connection configurations and walks it until one works: your custom proxy URL first if you supplied a valid one, then each Apify proxy group you selected in the order you listed them, and finally a direct connection with no proxy. If one configuration fails, the whole channel is retried on the next one. With no proxy configured, the run is a direct connection throughout.

What happens on failure. Continuation requests — the ones that fetch posts beyond the first batch — are not retried: a network error there ends pagination for that channel and keeps the posts already collected. If every configuration fails for a channel, that channel contributes zero rows, the failure is logged, and the run continues to the next channel. No partial, placeholder or error row is ever written, and since charging is per saved post row, a channel that returns nothing costs nothing.

⬇️ Input

Three parameters, one of them required. channelUrls is the only thing you have to supply — start a run without it and the Actor logs No channel URLs provided and exits immediately with an empty dataset rather than failing loudly, so check the log if a run finishes instantly.

Parameter	Required	Type	Description	Example Value
channelUrls	Yes	array	YouTube channel URLs, one per line. Handle URLs (youtube.com/@Name), /channel/UC… URLs, and /c/ or /user/ vanity URLs all work. A single comma-separated string is also accepted and split on commas.	["https://www.youtube.com/@MrBeast", "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA"]
maxPosts	No	integer	Maximum community posts to collect per channel, not per run. Minimum 1, maximum 10000. Default 10.	200
proxy	No	object	Proxy settings. Empty means a direct connection with no proxy. A customProxyUrl is tried first, then each selected Apify group, then a direct connection.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

⚠️ Two notes where the schema and the code do not line up.

The "automatic residential fallback" is conditional, not automatic. The Actor's own description says it switches to Apify RESIDENTIAL if the selected proxy is blocked. What the code does is build a fallback list from what you selected — custom URL, then your chosen Apify groups in your order — and end that list with a direct, unproxied connection. Residential is only in the chain if you put RESIDENTIAL in apifyProxyGroups yourself. Separately, when an Apify group is selected the Actor points at proxy.apify.com with no proxy username or password attached, so Apify Proxy credentials are never sent; if those requests are rejected, the chain falls through to the next entry and ultimately to the direct connection.

Include the scheme in your URLs. The schema's description shows youtube.com/@ChannelName, but the Actor passes your string to an HTTP client that requires a scheme. Paste the full https://www.youtube.com/@ChannelName form. A schemeless entry, or a bare handle like @MrBeast, is treated as a network failure, burns the retry budget and yields zero rows for that channel. Whatever you paste, the Actor strips a trailing slash, removes any /about, /videos, /posts or /community suffix, and appends /posts — so all four URL styles converge on the same Community tab request.

Three parameters exist in the code but are not in the schema. They are read from the run input if you send them through the API or the JSON input editor, and clamped as shown. They are undocumented on the input form and unsupported — treat them as diagnostics, not features.

Undeclared key	Type	Default	Clamped to	Effect
requestTimeout	integer	15	1–300	Per-request timeout in seconds
maxRetries	integer	3	1–10	Attempts for the initial channel-page fetch
retryDelay	integer	2	0–60	Seconds before the first retry; doubles on each subsequent one

Two more honest notes. maxPosts is clamped to 1–10000 in code, matching the schema exactly — a value outside the range is pulled to the nearest bound rather than rejected, and a non-numeric value silently becomes the default 10. And there is no deduplication anywhere: list the same channel twice and you get its posts twice. Dedupe on postId downstream if your input list might contain duplicates.

Example input

{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast",
    "https://www.youtube.com/@LofiGirl",
    "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ"
  ],
  "maxPosts": 200,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

⬆️ Output

Every community post is one dataset row with the same 13 keys in the same order, run after run. Nothing is conditionally omitted — missing scalars come back as null and missing arrays as [], so no presence checks are needed. Rows are pushed live as each post is parsed, so the dataset fills while the run is still going. Export as JSON, CSV, Excel or XML, or read the dataset through the Apify API.

One display note: the dataset's default table view shows 11 of the 13 columns. authorUrl and videoThumbnail are written to every row but hidden from that view — switch the view to all fields, or export the dataset, to see them.

Every row in the dataset is a community post. The Actor writes no error rows, no status rows, no diagnostic rows and no summary rows, so there is no marker field to filter on and nothing to exclude. Run-level counters live outside the dataset, in the key-value store under SUMMARY (total_posts, successful_channels, failed_channels, last_processed_url, timestamp). Because one row_result event is charged per saved post row, a channel that returns nothing costs nothing.

Example output

A poll post — note that pollChoices carries the options only, with no vote figures:

{
  "channelId": "UCSJ4gkVC6NrvII8umztf0Ow",
  "postId": "UgkxzXI5yqUI81XAwGFCCpcmqyk8Tmya93v4",
  "author": "Lofi Girl",
  "authorUrl": "/@LofiGirl",
  "text": "Which mood should the next 24/7 stream go for?",
  "publishedTime": "6 days ago",
  "likeCount": "18K",
  "commentCount": "1.2K",
  "pollChoices": [
    "Rainy jazz",
    "Late-night synthwave",
    "Morning acoustic"
  ],
  "videoThumbnail": null,
  "images": [],
  "attachmentType": "poll",
  "sourceUrl": "https://www.youtube.com/@LofiGirl"
}

An image post from the same run — images holds one image at ascending resolutions, largest last:

{
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "postId": "UgkxX6gkDxQ0KRucvyG7NLui0LhjHp0CLlfZ",
  "author": "MrBeast",
  "authorUrl": "/@MrBeast",
  "text": "Behind the scenes on the biggest build we have ever attempted",
  "publishedTime": "2 weeks ago",
  "likeCount": "412K",
  "commentCount": "9.7K",
  "pollChoices": [],
  "videoThumbnail": null,
  "images": [
    "https://yt3.ggpht.com/Kx9dQm2Ff0S9pQ8m0h0jZ0lW=s288-nd-v1",
    "https://yt3.ggpht.com/Kx9dQm2Ff0S9pQ8m0h0jZ0lW=s640-nd-v1",
    "https://yt3.ggpht.com/Kx9dQm2Ff0S9pQ8m0h0jZ0lW=s1280-nd-v1"
  ],
  "attachmentType": "image",
  "sourceUrl": "https://www.youtube.com/@MrBeast"
}

A text-only post, showing the null shape when a post has no attachment and no like count is printed:

{
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "postId": "UgkxoALLVbJBCAlPjcXE3bcrv8PCAuBYQbc9",
  "author": "Marques Brownlee",
  "authorUrl": "/@mkbhd",
  "text": "New review drops Thursday. Short one this time, you will see why.",
  "publishedTime": "4 hours ago",
  "likeCount": null,
  "commentCount": "83",
  "pollChoices": [],
  "videoThumbnail": null,
  "images": [],
  "attachmentType": null,
  "sourceUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ"
}

How does it work?

YouTube builds the Community tab from a JSON payload embedded in the page, and that is what this Actor reads. For each channel URL you supply, it normalises the URL to the channel's /posts page and fetches it once over HTTP with a desktop browser user-agent — through your proxy if you configured one, otherwise directly. From that single response it extracts three things: the ytInitialData blob holding the first batch of posts, the channel's canonical UC… ID, and the INNERTUBE_API_KEY and INNERTUBE_CONTEXT values YouTube's own front end uses to ask for more.

It then calls YouTube's youtubei/v1/browse endpoint directly, following continuation tokens page after page until your maxPosts ceiling is reached, YouTube stops returning a token, or a batch comes back empty. Each post is parsed out of its renderer and pushed to the dataset immediately, which is why rows appear while the run is still going.

Because the Actor reads YouTube's structured data rather than rendered markup, a visual redesign generally does not affect it, and your field names stay put. Only publicly visible posts are collected — no account, cookie or session is used anywhere in the run, so members-only posts are never reachable.

Integrations

YouTube Community Posts Scraper is an Apify Actor, so it works with anything that can call the Apify API or consume an Apify dataset.

Calling YouTube Community Posts Scraper from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/youtube-community-posts-scraper").call(run_input={
    "channelUrls": [
        "https://www.youtube.com/@MrBeast",
        "https://www.youtube.com/@LofiGirl",
    ],
    "maxPosts": 200,
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["publishedTime"], post["likeCount"], post["text"][:80])
    if post["attachmentType"] == "poll":
        print("  poll options:", post["pollChoices"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request. Every key is always present, so post["field"] is safe without a guard.

Scheduling and webhooks

Put the same input on an Apify schedule for recurring monitoring — a daily sweep of a creator roster is one cron entry. Attach an Apify webhook on run success so each finished dataset is posted to your own endpoint, and diff on postId to detect new posts without polling.

No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node — or an HTTP Request node pointed at the Apify run endpoint with your token — and pass the same JSON input shown above; an Item Lists node then splits posts into individual items for downstream steps. In Make, the Apify module supports run-and-wait, so a daily creator monitor can feed a Google Sheets, Airtable or Slack step directly. In LangChain, wrap the run call as a tool and hand the returned rows straight to an agent — the JSON needs no transformation before it goes into a prompt or a vector store.

Is it legal to scrape YouTube community posts?

Scraping publicly visible community posts is broadly treated as permissible where no authentication is bypassed, and YouTube Community Posts Scraper returns only public posts — what any signed-out visitor sees on the Community tab. Nothing members-only, nothing behind a login. But this output contains personal data whenever the channel belongs to an individual, and that changes your obligations rather than the Actor's.

Be clear about which case you are in. A brand, label or media company's channel is a business identity, and rows from it are ordinary business content. An individual creator's channel is a person — their name, their channel, and their own written words. Specifically, author, authorUrl and channelId identify that individual; text is content they authored; images and videoThumbnail may contain their likeness; and postId combined with channelId are persistent identifiers that link back to them. Under GDPR, UK GDPR and the CCPA, storing or processing those fields needs a lawful basis of your own — legitimate interest, consent, or another ground you can document — and public availability is not a lawful basis by itself.

Practise data minimisation: keep only what your use case needs. If you are measuring engagement patterns, publishedTime, likeCount, commentCount and attachmentType carry no personal data — drop author, authorUrl and text from what you retain. Set a retention limit rather than keeping rows indefinitely, and honour access and deletion requests against whatever you do store. Note that no commenter identities are returned at all — this Actor collects comment counts, never commenter names or comment text — so that category of personal data never enters your dataset.

Consult legal counsel if your use case involves bulk storage of personal data, profiling individual creators, or re-publishing post text and author identities.

❓ Frequently asked questions

What YouTube community post fields does YouTube Community Posts Scraper return?

The five most used are text, likeCount, commentCount, pollChoices and publishedTime. Thirteen keys are returned on every row — post identity, author identity, engagement counts, poll options, media URLs and attachment type. See the data fields table above for all of them.

Does YouTube Community Posts Scraper return poll results?

No — it returns poll options, not poll results. pollChoices is an array of the answer option texts in YouTube's order, and attachmentType is "poll" so you can filter for them. Total vote counts and per-option percentages are not read from YouTube's poll renderer and are not written to any field. If your analysis depends on how a poll was actually voted, this Actor gives you the questions and the options, not the outcome.

Does it return likes and comment counts, or only post text?

Both counts are returned, as YouTube's display strings rather than integers: likeCount reads "12K" and commentCount reads "1.4K". Two behaviours to code around — likeCount comes back null rather than "0" when YouTube prints no likes, and commentCount is null when the reply button is absent, which happens when comments are turned off. Comment text and commenter identities are not returned at all.

Can it scrape members-only community posts?

No, and not by configuration either. Members-only posts require a paid channel membership and a signed-in session, and this Actor sends no cookies, no session and no credentials of any kind — it makes anonymous requests exactly as a logged-out visitor would. YouTube does not render membership-gated posts to anonymous visitors, so those posts are not present in the data the Actor reads. There is no input that changes this.

Does YouTube Community Posts Scraper require a YouTube account or login?

No. No Google account, no cookie, no session, no YouTube Data API key. The Actor sends signed-out requests and reads only what a public Community tab serves an anonymous visitor. The one credential you need is your Apify token.

How many posts can I extract in one run?

maxPosts sets the ceiling per channel — minimum 1, maximum 10,000 — so a run's total is roughly maxPosts × the number of entries in channelUrls. Pagination is genuinely paginated, not one page: the Actor follows YouTube's continuation tokens through the internal browse endpoint until it hits your ceiling, YouTube stops issuing tokens, or a batch returns empty. The real limit is usually how many posts the channel has ever published — older community posts roll out of YouTube's feed over time, so a channel with a shallow history stops well before a high maxPosts value.

What happens if a channel has no Community tab, no posts, or a members-only tab?

The channel contributes zero rows and the run continues to the next one. All three cases look the same to the Actor: the Community tab section is missing or parses to no posts, a warning naming the channel URL is logged, and the run moves on. Nothing partial or fabricated is written — the dataset contains only real posts, so an empty channel reduces your row count rather than corrupting it. Since charging is per saved post row, that channel costs you nothing. If a channel you expect to work returns nothing, open youtube.com/@Handle/posts in a browser: if the tab is empty or absent there, the result is correct.

Can I scrape multiple YouTube channels at once?

Yes. channelUrls is a list — add as many channels as you like, and mix handle URLs, /channel/UC… URLs and /c/ vanity URLs freely. A single comma-separated string works too. Channels are processed sequentially, and maxPosts applies to each one independently. There is no deduplication between entries, so listing the same channel twice produces its posts twice.

Does YouTube Community Posts 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 hand-written tool definition can invoke it and receive typed JSON with no parsing step.

How does YouTube Community Posts Scraper compare to other YouTube community post scrapers?

Checked on the Apify Store on 25 July 2026, this is a thin category. sian.agency/youtube-community-posts-scraper is the most developed listing: it documents three operations in one Actor — channel feed, post detail, and post comments — 44 typed output fields, geo and lang parameters, maxPages capped at 25, an HTML run report in the key-value store, and error rows that are saved to the dataset but not charged. Notably, its listing documents pollTotalVotes as a parsed integer alongside pollChoices — poll vote totals are something it returns and this Actor does not, and that is the honest headline difference between them. Two further listings, scrapemesh/youtube-community-posts-scraper and scrapebase/youtube-community-posts-scraper, could not be checked: their README pages returned HTTP 404 on the date checked, so their fields and behaviour are not documented here.

Where this Actor is the clearer choice: a three-parameter input with nothing to configure, a per-channel ceiling of up to 10,000 posts rather than a page cap, one flat 13-key row shape with no conditional keys and no error rows to filter out, and documentation that states exactly which fields come back null, which come back as display strings rather than integers, and which YouTube renderers are not parsed.

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

Yes. Every row is typed, normalized JSON with the same 13 field names on every run. No HTML parsing, no selectors, no conditional keys. Pass a row straight into an LLM context window, index it into a vector store, or hand it to an agent tool — no transformation step required.

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

The scraper is maintained, and because it reads YouTube's structured ytInitialData and internal browse payloads rather than rendered HTML, a visual redesign generally does not affect it. The parts exposed to change are the renderer shapes inside that payload — the Actor already handles both post renderer variants, four different continuation token locations and two comment-count text shapes, which is exactly the kind of variation YouTube introduces. When extraction does fail, it says so in the run log rather than writing empty rows. Your field names and types do not change on your end.

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

Yes. There is no browser to run — the Actor talks to YouTube over plain HTTP and parses the embedded JSON, so there is no Chromium to provision. Proxying is optional: the default is a direct connection, and if you want an Apify proxy group or a custom proxy URL you select it in the input rather than creating any proxy account of your own. Note that it does not solve CAPTCHAs; its defences are retries with doubling backoff and the connection fallback chain described above.

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

For RAG indexing: text is the primary document body and the only long-form field, with pollChoices adding short structured text on poll posts and postId giving you a citation link via https://www.youtube.com/post/{postId}. Attach author, publishedTime and attachmentType as metadata for filtering. For training data: attachmentType, pollChoices and sourceUrl are the most structurally consistent values across records, since they are always present with a fixed set of shapes. Be aware that likeCount, commentCount and publishedTime are display strings — "12K", "2 weeks ago" — so they need a parsing pass before they are useful as numeric features. All values come back as typed primitives or plain arrays, so no normalization is needed before indexing.

🔗 Related scrapers

Scraper Name	What it extracts
YouTube Video Details Scraper	Full video metadata and transcripts for a single video
YouTube Search Scraper	Videos, channels and playlists returned for a keyword search
YouTube Channel Finder	Resolves channels from names and handles into channel URLs
YouTube Playlist Scraper	Every video in a playlist with publish dates and full video stats
YouTube Shorts Scraper	Shorts with creator lead enrichment
Facebook Posts Scraper	Public Page and profile posts with reactions and media, for cross-platform monitoring

💬 Your feedback

Found a bug, or need a field YouTube renders on the Community tab but the output does not carry — poll vote totals, multi-image carousels, shared-video IDs? Open an issue on the Actor's Issues tab. Reports that include the exact input JSON and the channel URL you ran are the fastest to reproduce and fix.