YouTube Community Posts & Comments Scraper

YouTube Community Posts Scraper — Extract Posts, Comments & Polls

Scrape every public post on a YouTube channel's Community (Posts) tab — text updates, polls, images, and video shares — then optionally pull the comments on each post and detect the language of every post and comment. The scraper returns typed, normalized JSON: no HTML, no DOM selectors, no ytInitialData blobs to parse yourself. Point it at one or more channel URLs and it pages the whole feed for you, links every comment to its parent post, and hands back a dataset you can filter, join, or feed straight into an LLM pipeline. After reading this page you'll know exactly which fields ship on a post row versus a comment row, how billing works when comments are enabled, and where the scraper's real limits sit.

What is the YouTube Community Posts & Comments Scraper?

It's an Apify Actor that reads the Community/Posts tab of any public YouTube channel and returns every post as a structured JSON row — then, if you turn it on, walks the comment thread under each post and returns those as linked child rows. No YouTube account, no Google Cloud project, and no API key are required to run it; it reads the same public HTML and internal InnerTube endpoints your browser uses when you visit a channel's Posts tab while logged out. It is a child-entity variant of a base community-post extractor: every base post field is preserved, and comment fetching plus offline language detection are layered on top.

• Scrape community posts — text updates, polls, image posts, and shared-video posts
• Scrape comments on any post, sorted newest-first or top-first
• Detect the language of post and comment text (ISO 639-1 code)
• Query multiple channels in a single run, each with its own post/comment pagination
• Export straight to JSON, CSV, Excel, or XML from the Apify dataset — no parsing step

⚙️ How the scraper reads the Community tab

The engine is hybrid: it first fetches https://www.youtube.com/<handle>/posts as plain HTML and extracts the ytInitialData JSON blob YouTube embeds in the page — the same payload the browser uses to render the first screen of posts. From there it reads ytcfg for the page's INNERTUBE_API_KEY and INNERTUBE_CONTEXT, and switches to YouTube's internal InnerTube youtubei/v1/browse endpoint to walk continuation tokens for every post past the first batch, until maxPosts is reached or the feed runs out. Comments work the same way one level down: fetching https://www.youtube.com/post/<postId> seeds a comment continuation token, which is then walked through the same browse endpoint, optionally switching to the "Newest first" or "Top" sort token if sortCommentsBy asks for the non-default order.

Every request — the initial HTML fetch and every browse call — goes through curl_cffi with Chrome 131 TLS impersonation rather than a stock HTTP client, so the TLS fingerprint matches a real Chrome browser rather than a typical Python requests session. A response missing ytInitialData is treated as a soft-block signal (a data-less shell page) and triggers a retry with exponential backoff (starting at a short delay and doubling on each attempt) before the Actor escalates to the next proxy tier. This combination — HTML bootstrap, InnerTube continuation, browser TLS impersonation, and a soft-block guard — is what lets the Actor page through large post and comment feeds without a headless browser.

Resolving channelId reliably is harder than it looks, because YouTube renders channel pages with several different header layouts depending on the channel. The Actor tries, in order: the canonical channelMetadataRenderer.externalId field, then the legacy c4TabbedHeaderRenderer.channelId, then the newer pageHeaderViewModel.channelId, then the urlCanonical field inside microformatDataRenderer, and finally a scan of the playlist sidebar's browse endpoint for anything starting with UC. If every one of those is absent, channelId on the resulting rows falls back to whatever the post's own authorEndpoint.browseId reports, and only comes back empty if none of these six sources resolve.

📊 What data does the scraper collect?

The Actor returns two structurally different row types from the same run — community posts and their comments — plus the poll/image/video attachment data embedded in each post. That's the breadth this scraper covers in one pass:

Data Type	Key Fields	JSON Field Names
Community posts (text, poll, image, video-share)	author, post text, published time, like count, comment count, attachment type	author, text, publishedTime, likeCount, commentCount, attachmentType
Poll posts	poll question, answer choices	text, pollChoices
Image & video-share posts	image URLs, shared-video thumbnail	images, videoThumbnail
Comments (child rows)	commenter handle, comment text, like count, reply count, creator-heart flag	author, text, likeCount, replyCount, isHearted
Language tags (optional, on posts and comments)	ISO 639-1 language code	detectedLanguage

Need more YouTube data?

If you need video-level rather than Community-tab data, API Empire publishes other YouTube Actors worth pairing with this one: a keyword-rank search scraper, a playlist scraper, a Shorts scraper that surfaces sponsor segments and sentiment/topic breakdowns, a video-details scraper for chapters and replay-heatmap peaks, and an influencer-tier finder for channel scoring. Run this Actor for the Community feed and one of those for the channel's actual video catalogue.

How does it differ from the official YouTube Data API?

The YouTube Data API v3 has no resource for Community-tab posts at all. Its current reference (developers.google.com/youtube/v3/docs, checked 2026-07-25) lists Activities, Captions, Channels, ChannelSections, Comments, CommentThreads, PlaylistItems, Playlists, Search, Subscriptions, Videos, and a handful of others — there is no communityPosts or posts resource anywhere in it. commentThreads.list, the closest thing to a comments endpoint, is documented to cover comments on a video or a channel, not on a community post.

Feature	YouTube Data API v3	This Scraper
Community-post access	Not available — no documented resource covers the Posts/Community tab	Reads any public Community/Posts tab directly
Comments on a community post	Not available — commentThreads only covers video/channel comments	Fetches comments per post, linked via parentId
Setup	Requires a Google Cloud project, an API key, and OAuth for write operations (per the API's getting-started guide)	No API key, no Google account — run it directly on Apify
Default rate budget	10,000 units/day combined quota for most endpoints, 100 calls/day for search.list (per the API's getting-started guide, checked 2026-07-25)	No per-day unit quota built into the Actor itself; throughput depends on your Apify plan and proxy setup
Poll / image / video-share attachment data	Not exposed for community posts	Returned per post via pollChoices, images, videoThumbnail, attachmentType
Output shape	Per-resource JSON, varies by endpoint	One normalized row shape per post, one per comment, across every channel in the run

Use the official API when you're building inside Google's own quota system and only need video, channel, or playlist data it actually exposes. Use this scraper when you need the Community tab specifically — the official API cannot reach it at any quota level.

Why do developers and teams scrape YouTube community posts?

For AI engineers and agent builders

Community posts are unstructured, high-signal creator communication — announcements, polls testing audience sentiment, behind-the-scenes updates — that rarely shows up in a channel's video metadata. Pull text, pollChoices, and detectedLanguage from a channel's recent posts and comments and you have a clean corpus to index into a vector store for a fan-facing Q&A agent, or to feed an agent tool that answers "what has this creator announced recently" without re-scraping HTML on every call.

For marketers and brand teams

Community posts are where creators test messaging before it goes into a video — polls in particular double as informal audience research. Track a shortlist of creator or brand channels, pull pollChoices and comment likeCount/replyCount on each post, and you get a lightweight signal of what resonates with an audience before committing budget to a sponsorship or a co-branded video.

For researchers and analysts

Because the scraper only returns publicly accessible posts and comments, it's suited to studying public discourse patterns — how creators use polls versus text updates, comment sentiment on announcements, or engagement trends across a cohort of channels — without needing platform-side data-sharing agreements. publishedTime, likeCount, and commentCount on posts give you a time-ordered engagement series per channel.

For developers building data products

Because output is one stable JSON shape per post and per comment across every channel you query, it's straightforward to run this Actor on a schedule and layer a dashboard, alerting system, or creator-monitoring product on top — new post detection, comment-volume spikes, or poll-result tracking — without maintaining your own YouTube HTML parser.

How to scrape YouTube community posts (step by step)

1. Open the Actor's page in the Apify Store and click Try for free (or find it in your Apify Console under Actors if you've already added it).
2. Provide the required input: channelUrls — one or more channel URLs (youtube.com/@Handle or youtube.com/channel/UC…), one per line.
3. Set maxPosts for how many posts to pull per channel, and turn on includeComments and/or detectPostLanguage if you want comment threads and language tags.
4. Click Start and watch results land in the dataset in real time as each channel is processed.
5. Download the finished dataset as JSON, CSV, Excel, or XML — or pull it programmatically via the Apify API / apify-client.

What to do when YouTube changes its Community tab structure

The Actor is maintained against YouTube's current markup and InnerTube payload shapes, and the output schema — field names and types — stays stable on your end even when the underlying page structure changes. The code already handles one real structural change: YouTube renamed the "Community" tab to "Posts," and the extractor checks for both tab titles so existing integrations kept working through the rename. No specific turnaround time is promised for future changes.

What changed in YouTube community-post scraping recently?

Two verifiable shifts matter here. First, YouTube renamed the Community tab to "Posts" as part of its Communities rollout (reported in trade coverage around February 2025), which broke any scraper hard-coded to look for a tab literally titled "Community" — this Actor checks both titles. Second, since 2024 YouTube has progressively rolled out BotGuard-issued Proof-of-Origin (PO) token enforcement across InnerTube endpoints, primarily targeting video-playback requests; unauthenticated automated clients that don't attest a token risk 403 responses or IP-level blocks on the endpoints where it's enforced (documented in yt-dlp's PO Token Guide). This Actor's browse/continuation calls for the Community feed and comment threads are not player-format requests, but the direction of travel across InnerTube generally is tighter anti-bot enforcement — which is why this Actor ships TLS impersonation, retries, and a multi-tier proxy fallback rather than a single bare HTTP client. Ongoing maintenance tracks these changes; no numeric SLA is attached to it.

⬇️ Input

The Actor accepts seven parameters, all defined in its input schema. channelUrls is the only required one.

Parameter	Required	Type	Default	Constraints
channelUrls	Yes	array of strings	—	stringList editor. One or more channel URLs, one per line (a comma-separated string is also accepted). Both youtube.com/@Handle and youtube.com/channel/UC… formats work.
maxPosts	No	integer	10	minimum: 1, maximum: 10000. Community posts to collect per channel. Comments, if enabled, are fetched in addition and do not count against this — only parent posts are counted.
includeComments	No	boolean	false	Fetches comments for every scraped post and pushes each as a child row linked via parentId.
maxCommentsPerPost	No	integer	10	minimum: 1, maximum: 200. How many comments to fetch per post when includeComments is on. Applied per post; the post count is unaffected.
sortCommentsBy	No	string (enum)	"mostRecent"	One of "mostRecent" (newest first) or "mostPopular" (top/most-liked first).
detectPostLanguage	No	boolean	false	Runs offline language detection on every post's (and comment's) text and adds detectedLanguage. Empty or emoji-only text yields null.
proxy	No	object	{"useApifyProxy": false, "apifyProxyGroups": []}	proxy editor. Optional — the Actor runs on a direct connection by default. Enable Apify Proxy or set a custom proxy URL for higher volume; see the Input pitfall note below for what happens on a block.

No credential, API key, or login field exists anywhere in this schema — the Actor doesn't need one, and there's nothing here that requires masking as a secret.

How the proxy fallback order actually works: if you supply a customProxyUrl, it's tried first. If useApifyProxy is on with specific apifyProxyGroups selected, those groups are tried next, in the order listed (e.g. DATACENTER before RESIDENTIAL if you list both); if useApifyProxy is on with no group specified, the Actor tries Datacenter then Residential automatically. A direct connection (no proxy at all) is always appended as the final fallback, even if you configured a proxy — so a run never hard-fails purely because every configured proxy tier was rejected, though it may still fail for other reasons (e.g. a channel with no Community tab).

Example JSON input

{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxPosts": 25,
  "includeComments": true,
  "maxCommentsPerPost": 20,
  "sortCommentsBy": "mostPopular",
  "detectPostLanguage": true,
  "proxy": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}

Common pitfall: pasting a URL that includes /community, /about, /videos, or /posts already appended is fine — the Actor strips those suffixes and rebuilds the Posts-tab URL itself — but pasting a video URL or a search-results URL instead of a channel URL will return zero posts, since there's no Community tab to read at that address.

⬆️ Output

Every row lands in the default dataset as flat, typed JSON — no nested HTML, no selectors. Post rows and comment rows are interleaved: each post is immediately followed by its comments (when includeComments is on), and every row carries type and isChild so you can tell them apart programmatically. Post rows and comment rows carry different key sets — a post row never has commentId, authorChannelId, replyCount, or isHearted; a comment row never has authorUrl, commentCount, pollChoices, videoThumbnail, or attachmentType. Filter on type before assuming a field exists.

When includeComments is on, comment rows are additionally mirrored to a per-run dataset named <runId>-comments, so you can pull just the comments for a given run without filtering the combined dataset.

Scraped community post (row shape)

{
  "type": "post",
  "isChild": false,
  "parentId": null,
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "postId": "Ugkx7RvKumu_Ilo0oXu6kwVvtPmQsL5miLae",
  "author": "MrBeast",
  "authorUrl": "/@MrBeast",
  "text": "James Patterson and I wrote a book! Pre-order now…",
  "publishedTime": "3 weeks ago",
  "likeCount": "271K",
  "commentCount": "7K",
  "pollChoices": [],
  "videoThumbnail": null,
  "images": ["https://yt3.ggpht.com/example-image.jpg"],
  "attachmentType": "image",
  "sourceUrl": "https://www.youtube.com/@MrBeast",
  "detectedLanguage": "en"
}

• type (string) — always "post" for a community-post row.
• isChild (boolean) — always false for posts.
• parentId (null) — always null for posts; only comment rows carry a parent.
• channelId (string) — the channel's UC… ID, resolved from the page metadata.
• postId (string) — the unique community-post ID.
• author (string) — the channel's display name.
• authorUrl (string) — canonical channel path of the poster, e.g. /@MrBeast.
• text (string) — the full post text, including a poll's question text.
• publishedTime (string) — YouTube's relative timestamp as rendered, e.g. "3 weeks ago".
• likeCount (string or null) — the like count as YouTube's own abbreviated string (e.g. "271K"), not a parsed integer; null when no likes are shown.
• commentCount (string or null) — the comment count as YouTube's abbreviated string (e.g. "7K"); null when absent.
• pollChoices (array of strings) — poll answer text; [] for non-poll posts.
• videoThumbnail (string or null) — largest available thumbnail URL for a shared video; null when the post has no shared video.
• images (array of strings) — attached image URLs; [] when the post has no images.
• attachmentType (string or null) — one of "video", "image", "poll", or null for a plain text post.
• sourceUrl (string) — the exact channel URL you passed as input for that post.
• detectedLanguage (string or null) — present only when detectPostLanguage is true; the key is omitted entirely otherwise, not set to null.

A poll post looks like this

Poll posts use the same row shape as any other post — only attachmentType, text, and pollChoices change:

{
  "type": "post",
  "isChild": false,
  "parentId": null,
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "postId": "UgkxAbCdEf1234567890ghijk",
  "author": "MrBeast",
  "authorUrl": "/@MrBeast",
  "text": "Which video should I post next?",
  "publishedTime": "5 days ago",
  "likeCount": "48K",
  "commentCount": "2.1K",
  "pollChoices": ["100 Girls vs 100 Guys", "Extreme Hide and Seek", "Squid Game IRL"],
  "videoThumbnail": null,
  "images": [],
  "attachmentType": "poll",
  "sourceUrl": "https://www.youtube.com/@MrBeast"
}

Individual vote percentages per choice are not returned — YouTube only reveals per-choice percentages to a signed-in viewer who has already voted, and this Actor runs without authentication, so only the poll question and its answer options are available.

Scraped comment (row shape, only when includeComments is on)

{
  "type": "comment",
  "isChild": true,
  "parentId": "Ugkx7RvKumu_Ilo0oXu6kwVvtPmQsL5miLae",
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "postId": "Ugkx7RvKumu_Ilo0oXu6kwVvtPmQsL5miLae",
  "commentId": "UgzVEw6TwJFuNHsHOzh4AaABAg",
  "text": "MrBeast making books now? The side quests are getting crazy",
  "author": "@KarionJohnson_3",
  "authorChannelId": "UC5m7OG-AMr2QubKW5V3H5-Q",
  "likeCount": 2000,
  "replyCount": 17,
  "publishedTime": "3 weeks ago",
  "isHearted": true,
  "sourceUrl": "https://www.youtube.com/post/Ugkx7RvKumu_Ilo0oXu6kwVvtPmQsL5miLae",
  "detectedLanguage": "en"
}

• type (string) — always "comment".
• isChild (boolean) — always true.
• parentId (string) — the postId of the post this comment belongs to.
• channelId (string or null) — the channel ID the parent post belongs to.
• postId (string) — same value as parentId, repeated for convenience when you're not joining on parentId.
• commentId (string) — the unique comment ID.
• text (string) — comment text.
• author (string) — the commenter's handle, e.g. "@name".
• authorChannelId (string or null) — the commenter's channel ID, when YouTube exposes it.
• likeCount (integer) — comment like count, parsed to a number — note this differs in type from a post's likeCount, which stays as YouTube's raw abbreviated string.
• replyCount (integer) — number of replies under the comment.
• publishedTime (string) — the comment's relative timestamp.
• isHearted (boolean) — whether the channel owner hearted the comment.
• sourceUrl (string) — the youtube.com/post/<postId> page the comment was read from.
• detectedLanguage (string or null) — present only when detectPostLanguage is true.

How does this scraper compare to other YouTube community post scrapers?

Feature	This Scraper	Generic alternative
Output format	Typed JSON, stable field names, ready for direct ingestion	Often raw HTML or inconsistent field naming that requires post-processing
Comment support	Comments are a first-class linked child entity (parentId, mirrored per-run dataset)	Frequently post-only, or comments bolted on as nested arrays inside the post row
Entity coverage per run	Posts and comments across multiple channels in a single run	Usually single-entity or single-channel per run
Anti-bot handling	Chrome-TLS-impersonated requests, retry/backoff, and an automatic custom → datacenter → residential → direct proxy escalation chain	Varies widely; some tools ship no fallback and fail outright on a block
Schema stability across a platform change	Actor already tolerates the Community → Posts tab rename by checking both titles	Depends entirely on the individual scraper's maintenance cadence

If you're building an AI agent or RAG pipeline, the output-format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature, and every field this scraper returns is already typed and named consistently across post and comment rows.

How many posts and comments can you scrape?

maxPosts is schema-capped at 10,000 per channel per run (default 10) — there's no separate hard ceiling elsewhere in the code, so the practical limit is however many posts YouTube's Community feed actually serves for that channel. Pagination is automatic: the Actor reads the first page from the channel's HTML, then walks YouTube's InnerTube browse continuation endpoint until maxPosts is reached or the feed runs out of tokens. maxCommentsPerPost is capped at 200 (default 10); internally the comment fetch stops after 12 continuation pages per post as a safety bound, reached well before 200 comments on most posts. lurkapi's YouTube Community Posts Scraper README (Apify Store, checked 2026-07-25) states YouTube itself serves "approximately 200 community posts" per channel with "no way to access older posts" — a platform-side ceiling reported by a third party, not measured by this Actor, but a useful expectation-setter if you set maxPosts well above what a channel's feed actually holds.

Both limits apply per channel, not per run: five channelUrls with maxPosts: 100 targets up to 100 posts on each channel independently, not 100 split across all five. Channels process sequentially, and one channel failing doesn't stop the rest.

Integrate the scraper and automate your workflow

This Actor works with any language or tool that can send an HTTP request — it runs on Apify's standard Actor API, so anything that can call apify-client or a REST endpoint can drive it.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

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

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item.get("postId") or item.get("commentId"), item["text"][:60])

Works in Python, Node.js, Go, Ruby, and cURL — same Actor ID, same input shape, same JSON rows back.

Automation platforms (n8n, Make, LangChain)

n8n — Apify's official n8n node can run any Actor on your account, including this one: configure it with your Apify API token and this Actor's ID, set the JSON input, and wire the output dataset into downstream nodes without writing a scraper yourself. Make (Integromat) — the Apify app module works the same way: pick "Run an Actor," select this Actor, map channelUrls and the other input fields to upstream data, and consume the dataset items in the next module. LangChain — since output is already typed JSON per post/comment, you can load a finished dataset straight into a Document loader or a custom tool without an HTML-parsing step in between; the agent gets clean text, author, and engagement fields instead of raw markup.

Is it legal to scrape YouTube community posts and comments?

Scraping publicly accessible YouTube content is generally permissible; this Actor only returns posts and comments that are visible on a channel's public Community/Posts tab without logging in — it cannot and does not access private, members-only, or age-gated content. Comment rows do include personal identifiers — a commenter's public handle (author) and, when exposed, their channel ID (authorChannelId) — so if you store or process this data at scale, GDPR (for EU/UK data subjects) and CCPA (for California residents) considerations apply to how you retain and use that information, separate from whether the scrape itself is permitted. YouTube's own Terms of Service govern automated access to the platform. Consult legal counsel for commercial use cases involving bulk collection of personal data such as commenter identities.

❓ Frequently asked questions

Does the scraper work without a YouTube account?

Yes. There's no login field, API key, or OAuth step anywhere in the input schema — the Actor reads the same public HTML and InnerTube endpoints a logged-out browser sees on a channel's Posts tab.

How often is the scraped data updated?

Every run performs a live fetch against YouTube at the time you start it — there's no caching layer in the Actor, so the data reflects whatever posts, comments, and counts YouTube is serving at that moment, not a stored snapshot from a previous run.

What happens if a channel has no Community/Posts tab, or its posts aren't public?

You get zero rows for that channel, and the run log records a warning that no posts were found and to check the URL and that community posts are public — no charge is incurred for a channel that returns no posts, since billing is tied to each post row actually pushed.

What happens when comments are disabled on a specific post?

That post row is still returned in full; the Actor simply logs that no comment continuation token was found for that post (YouTube's own signal that comments may be off) and returns zero comment rows for it, without failing the rest of the run.

Can I scrape private or members-only community posts?

No. Only content visible on the public Posts tab without signing in is returned. Members-only posts and posts on channels with the Community tab disabled are not accessible to this Actor, the same way they aren't visible to a logged-out browser.

What does it cost to run, and is there a free trial?

The Actor runs on Apify's pay-per-event pricing, charging for each community post row it successfully returns; comment rows fetched via includeComments are pushed at no additional charge. Check the Actor's Pricing tab on the Apify Store for current rates — Apify's own account terms determine any trial credit, not this Actor's configuration.

Does it work for AI agent workflows and LLM pipelines?

Yes. Every response is typed, normalized JSON with stable field names — no HTML and no parsing step before you pass it into an LLM context window, a vector store, or an agent tool call. It's callable as a standard HTTP endpoint via apify-client from any agent framework.

How does it handle YouTube's anti-bot defenses, and do I need to manage proxies myself?

Requests go through curl_cffi with Chrome TLS impersonation rather than a plain HTTP client, with retry and exponential backoff on failure, plus a soft-block guard that detects a data-less response (missing ytInitialData) and escalates rather than returning empty data silently. You don't have to manage proxies — the Actor runs on a direct connection by default and only escalates through your configured proxy tiers (custom → Apify Datacenter → Apify Residential → direct) if a request is blocked.

How does it compare to other YouTube community post scrapers?

Scrapestorm's YouTube Community Posts Extractor (Apify Store listing, checked 2026-07-25) returns posts only, on a flat monthly subscription, with no comment-fetching or language-detection feature documented. lurkapi's YouTube Community Posts Scraper (same, checked 2026-07-25) offers comments, image download, and language detection as separately priced paid add-ons on top of a base per-post charge. This Actor returns posts and comments from the same run, with language detection as a plain input toggle rather than a metered add-on, and interleaves comment rows with their parent post automatically.

What happens when YouTube changes its structure or blocks the scraper?

The Actor is maintained, and the output schema — field names and types — doesn't change on your end even when YouTube's page markup does. It's already proven that in practice: when YouTube renamed the Community tab to "Posts," the extraction logic was updated to check both titles rather than breaking silently. No specific turnaround time is promised for future changes.

Can I filter posts by type (poll, image, video, text-only) before they're scraped?

No — there's no postType filter parameter in the input schema. Every post the channel's Community feed serves within your maxPosts limit is returned, regardless of type; use attachmentType client-side after the run to split posts into "poll", "image", "video", or plain text (null). If your workflow only cares about one post type, filter the dataset on attachmentType rather than trying to restrict it at scrape time.

💬 Your feedback

Found a bug, or a field that doesn't match what YouTube is actually showing? We want to know. Reach out through the Actor's page on the Apify Store or open an issue via Apify's support channel — reports like this go straight into what gets fixed next.