YouTube Community Posts Scraper: Polls, Choices & Vote Counts

YouTube Community Posts Scraper — Poll Choices & Vote Percentages

Extract YouTube community posts from any channel's Community tab and mine every poll on it: the question, each answer choice, the per-choice vote percentage where YouTube exposes it, and the total vote count as both raw text and a parsed integer. Every row is structured JSON — ready to load into a spreadsheet, pass to an LLM as grounding context, or feed a monitoring pipeline that tracks audience sentiment over time. Point it at one channel or a hundred, filter down to poll-only posts with a minimum choice count or a question keyword, and the actor paginates the feed until it has enough matches or runs out of posts. Run it once for a snapshot, or on a schedule to watch how an audience's answers shift as a poll runs its course.

What is the YouTube Community Posts Scraper?

This actor reads a YouTube channel's public Community/Posts tab and returns one structured row per post, with full poll parsing on any post that carries a poll or quiz attachment: every choice's text, its vote percentage when YouTube reveals one, the total-votes string YouTube displays (e.g. "2.6M votes"), and that same total parsed to an integer for sorting and math. No YouTube account, API key, or login is required — the actor requests the public page the same way a signed-out browser would.

• Scrapes one or many channels per run from a single list of URLs
• Parses every poll into rich pollChoices — { text, percentage } per choice, not a flat string list
• Returns pollTotalVotes as YouTube's display text and pollTotalVotesValue as a parsed integer
• Filters server-side to poll-only posts, a minimum number of choices, or a keyword in the poll question — so you don't pay for or sort through posts you don't need
• Still returns standard post fields (author, text, published time, likes, comments, attached image or video) for non-poll posts when you turn poll-only filtering off
• Fetches through a Chrome-TLS-impersonated HTTP client with a soft-block guard and proxy escalation, instead of a full headless browser
• Resolves the channel's canonical channelId (UC...) for you even when you only supply a @handle URL, so downstream joins against other YouTube datasets don't need a separate lookup step

What is the difference between a community poll and a community quiz on YouTube?

Both are answer-choice posts on a channel's Community tab, but YouTube renders them with two different internal components: a poll (pollRenderer) simply asks a question and shows vote-share once you've voted, while a quiz (quizRenderer) marks one choice as correct and can show whether your pick was right. The distinction matters to a viewer, but it doesn't change what you get from this actor — both attachment types are parsed through the same choice-extraction logic, so quiz posts come back with the same pollChoices (choice text plus vote percentage where available), pollTotalVotes, and pollTotalVotesValue fields as ordinary polls, and both are labeled attachmentType: "poll" in the output. If you're searching for a "YouTube community quiz scraper" specifically, this actor already covers that case — there's no separate quiz mode to enable, and pollsOnly keeps both poll and quiz posts when turned on.

📊 What data can you get with the YouTube Community Posts Scraper?

The actor returns one row per community post, and the fields that are populated depend on the post's attachment type. Every field below is a real key written by the actor's row-builder — none are simplified or renamed from the source.

Result Type	Extracted Fields	Primary Use Case
Poll / quiz post	pollChoices (array of {text, percentage}), pollTotalVotes, pollTotalVotesValue, attachmentType: "poll", plus channelId, postId, author, authorUrl, text, publishedTime, likeCount, commentCount, sourceUrl	Audience-preference tracking, sponsorship due diligence, poll-trend monitoring
Shared-video post	videoThumbnail (best-resolution URL), attachmentType: "video", plus the shared post fields above	Tracking which videos a creator promotes through the Community tab
Image / carousel post	images (array of URLs, one per image, best resolution), attachmentType: "image", plus the shared post fields above	Tracking merch drops, announcements, and visual content posted outside the video feed

Poll choices with per-choice vote percentages

This is the field competing YouTube community-post scrapers don't expose in this shape. Where most tools return pollChoices as a flat array of choice strings, this actor returns each choice as an object carrying both the choice text and its vote-share percentage:

"pollChoices": [
  { "text": "Team Cake", "percentage": "62%" },
  { "text": "Team Pie", "percentage": "38%" }
]

One real limitation worth stating up front: YouTube always shows the total vote count on a poll, but it only reveals the per-choice percentage breakdown to viewers who have already voted on that specific poll. Because the actor reads the page logged out and without voting, percentage is frequently null even though text is always present and pollTotalVotes / pollTotalVotesValue are populated whenever the poll itself is present. Treat choice text and total votes as the reliable signals, and percentage as best-effort — it fills in whenever YouTube's response happens to include it.

Without this actor, getting from a rendered Community-tab poll to a usable record means viewing the page source, locating the poll inside the ytInitialData blob, and hand-walking the pollRenderer.choices array to pull each choice's text and percentage, then repeating that for every post on every channel you care about. The actor collapses that into one output row per poll: text holds the question, pollChoices holds the parsed choice list, and pollTotalVotes / pollTotalVotesValue hold the total — all populated the moment the row lands in the dataset, with no manual JSON-walking required on your end.

Image and video attachment posts

Posts that aren't polls still parse cleanly when pollsOnly is turned off. A shared-video post returns the video's highest-resolution videoThumbnail URL; an image or multi-image carousel post returns a flat images array with one URL per image, already resolved to the largest thumbnail size YouTube serves — no nested renderer objects to unwrap yourself.

Why not build this yourself?

YouTube's official Data API v3 has no resource for community posts, and none for polls — its documented resource types cover channels, videos, playlists, comments, captions, and a handful of others, but nothing under the Community tab. That means any community-post or poll extraction has to go through the page YouTube renders for browsers, not a documented endpoint.

Building and maintaining that path yourself means: reverse-engineering and re-parsing ytInitialData and the ytcfg InnerTube context every time YouTube changes its page structure, implementing continuation-token pagination against the internal youtubei/v1/browse endpoint, matching a TLS/JA3 fingerprint that doesn't trip YouTube's bot detection, detecting and recovering from soft blocks (a data-less shell or a consent wall in place of real data), and maintaining a proxy escalation chain for when an IP gets rate-limited. This actor implements all of that — Chrome TLS impersonation, a soft-block detector, exponential-backoff retries, and a proxy fallback chain from a custom proxy through Apify Datacenter and Residential groups down to a direct connection — so a poll question and its vote counts are one run away instead of a maintenance project.

The pagination logic also has to know when to stop. A naive implementation that keeps requesting continuation pages until a strict poll filter is satisfied can loop indefinitely against a channel that rarely posts polls at all. This actor caps continuation pagination at 60 pages per channel internally, so a run always terminates in bounded time even when pollsOnly, minPollChoices, and pollKeywordFilter are all set tightly against a channel with few qualifying posts — you get whatever matches were found within that ceiling rather than a run that hangs.

How to scrape YouTube community posts and polls

1. Open the actor on its Apify Store page and click Run, or start it from the API/CLI with your Apify token.
2. Enter one or more channel URLs in channelUrls — either youtube.com/@Handle or youtube.com/channel/UC... format, one per line or comma-separated.
3. Set maxPosts for how many matching rows to collect per channel, and configure the 🗳️ Poll Filters (pollsOnly, minPollChoices, pollKeywordFilter) to narrow the output to the polls you actually want.
4. Start the run.
5. Download results as JSON or CSV from the run's dataset, or stream them via the Apify API as they're written.

{
  "channelUrls": ["https://www.youtube.com/@MrBeast"],
  "maxPosts": 25,
  "pollsOnly": true,
  "minPollChoices": 2,
  "pollKeywordFilter": ""
}

Scraping multiple channels in one job

channelUrls accepts an array (or a comma-separated string, which the actor splits automatically), so a single run can walk any number of channels — each one processed in sequence, with its own proxy fallback attempts and its own maxPosts ceiling applied per channel, not across the whole run. Add channels to the list rather than starting separate runs when you want one dataset covering all of them. Results write to the shared run dataset as each channel finishes, so a large channel list doesn't leave you waiting for the whole run to end before you can start reading rows — the log line "Output is saved to the run dataset in real time as posts are scraped" confirms this at the start of every run.

⬇️ Input

All input is set through the actor's input schema on Apify — no separate config file. channelUrls is the only required field; everything else has a default.

Parameter	Required	Type	Description	Example Value
channelUrls	Yes	array of strings	One or more YouTube channel URLs. Both youtube.com/@Handle and youtube.com/channel/UC... formats work. One per line, or comma-separated. Every channel's community/posts tab is scanned for polls.	["https://www.youtube.com/@MrBeast"]
maxPosts	No	integer (min 1, max 10000, default 10)	How many community posts to scan per channel before stopping. This counts matched output rows; the actor keeps paginating to reach this many polls when Poll Filters are strict. Start with 10 for a quick test.	25
pollsOnly	No	boolean (default true)	When on, only poll (and quiz) posts are returned — text, image and video posts are skipped. Turn off to keep every post type while still parsing polls where present.	true
minPollChoices	No	integer (min 2, max 10, default 2)	Drop polls that have fewer than this many answer choices. Set to 4 to skip simple yes/no or A/B binary polls and keep only multi-option polls.	2
pollKeywordFilter	No	string	Optional. Keep only polls whose question/caption text contains this word or phrase (case-insensitive). Leave empty to keep all polls.	"merch"
proxy	No	object (Apify proxy configuration)	Optional. Runs without a proxy by default. Enable Apify Proxy or a custom URL for higher volume; if a proxy is blocked the actor escalates to Apify RESIDENTIAL and retries on a fresh IP.	{ "useApifyProxy": false, "apifyProxyGroups": [] }

None of these fields hold credentials or API keys — the proxy field is Apify's standard proxy-configuration widget, not a secret value, so nothing here needs to be masked.

Common pitfall: maxPosts is titled "Posts to scan per channel," but its own description clarifies it actually caps matched output rows, not raw posts inspected. With pollsOnly on and a strict minPollChoices or pollKeywordFilter, the actor may scan far more posts than maxPosts to find that many qualifying polls — and it stops after 60 continuation pages per channel regardless, so a channel with very few matching polls in its recent history may return fewer rows than maxPosts even though the run completed normally.

Second pitfall: pollKeywordFilter only matches against the post's text field — the poll question or caption — not against individual choice text. A filter of "merch" keeps a poll whose question mentions merch even if none of the answer choices do, and it won't match a poll whose question is generic but whose choices happen to contain the word. If you need to filter on choice wording specifically, apply that filter to pollChoices[].text downstream after the run.

Example JSON input

{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast",
    "https://www.youtube.com/@LofiGirl"
  ],
  "maxPosts": 50,
  "pollsOnly": true,
  "minPollChoices": 2,
  "pollKeywordFilter": ""
}

⬆️ Output

Every matched post is written to the run's default dataset as a typed JSON row, in the same shape on every run. Export it as JSON, CSV, or the other formats Apify's dataset view offers, or read it live through the Apify API or apify-client. Unlike many scrapers, the default dataset view here isn't a trimmed-down subset — it shows all 15 fields the actor writes to every row.

Field	Type	Description
channelId	string	Channel ID (UC...), resolved from the channel page even when you passed a @handle URL.
postId	string	Unique ID of the community post.
author	string	Channel display name.
authorUrl	string	Canonical channel URL of the post's author.
text	string	Post body text — the poll question for poll posts, the caption for others.
publishedTime	string	Relative published time as YouTube displays it (e.g. "3 days ago").
likeCount	string | null	Abbreviated like/vote count as YouTube displays it (e.g. "12K"); null when YouTube doesn't expose one for this post.
commentCount	string | null	Abbreviated comment count as YouTube displays it; null when absent.
pollChoices	array of objects	[{ "text": "...", "percentage": "..." | null }, ...] for poll/quiz posts; empty array [] for every other post type.
pollTotalVotes	string | null	Total votes as YouTube's display text (e.g. "2.6M votes"); null when the post isn't a poll or YouTube doesn't expose a total.
pollTotalVotesValue	integer | null	pollTotalVotes parsed to an integer (e.g. 2600000); null under the same conditions as pollTotalVotes.
videoThumbnail	string | null	Best-resolution thumbnail URL for a shared-video post; null for every other type.
images	array of strings	One best-resolution URL per image for image/carousel posts; empty array [] otherwise.
attachmentType	string | null	"poll", "video", or "image" depending on what's attached; null for plain text posts.
sourceUrl	string	The exact channel URL you passed in channelUrls that produced this row.

Every row that reaches the dataset has already passed your Poll Filters and is charged under the row_result event — the actor doesn't push separate uncharged error or accounting rows, so what you see in the dataset is exactly what you're billed for.

The actor also follows a "null over faked zero" rule for every count field it parses: pollTotalVotesValue, likeCount, and commentCount come back as null when YouTube doesn't expose a value for that post, rather than being coerced to 0. That distinction matters if you're aggregating vote counts — a null means "not available," while a 0 would wrongly imply a poll that genuinely received zero votes.

Dataset view in the Apify Console

The default table view in the Console labels these same 15 fields for readability rather than renaming them: channelId shows as "🆔 Channel ID", postId as "📌 Post ID", text as "💬 Post / Poll Question", attachmentType as "📎 Type", pollChoices as "🗳️ Poll Choices (text + %)", pollTotalVotes as "🗳️ Total Votes", pollTotalVotesValue as "🔢 Total Votes (int)", videoThumbnail as "🖼️ Video Thumbnail" (rendered as a clickable link), and images as "🖼️ Images". The underlying JSON keys — the ones you'll use in code or when exporting — are the field names in the table above, not these display labels.

Scraped results

[
  {
    "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "postId": "UgkxAbCdEf12345",
    "author": "MrBeast",
    "authorUrl": "/@MrBeast",
    "text": "Would you rather have 1,000,000 subscribers or $1,000,000?",
    "publishedTime": "1 year ago",
    "likeCount": null,
    "commentCount": "50K",
    "pollChoices": [
      { "text": "1,000,000 Subscribers", "percentage": null },
      { "text": "$1,000,000", "percentage": null }
    ],
    "pollTotalVotes": "2.6M votes",
    "pollTotalVotesValue": 2600000,
    "videoThumbnail": null,
    "images": [],
    "attachmentType": "poll",
    "sourceUrl": "https://www.youtube.com/@MrBeast"
  },
  {
    "channelId": "UCSJ4gkVC6NrvII8umztf0Ow",
    "postId": "UgkxzXI5yqUI81XAwGFCCpc",
    "author": "Lofi Girl",
    "authorUrl": "/@LofiGirl",
    "text": "Current study status?",
    "publishedTime": "6 days ago",
    "likeCount": "1.6K",
    "commentCount": "424",
    "pollChoices": [
      { "text": "High School", "percentage": "22%" },
      { "text": "University / College", "percentage": "51%" },
      { "text": "Already Graduated", "percentage": "27%" }
    ],
    "pollTotalVotes": "42K votes",
    "pollTotalVotesValue": 42000,
    "videoThumbnail": null,
    "images": [],
    "attachmentType": "poll",
    "sourceUrl": "https://www.youtube.com/@LofiGirl"
  },
  {
    "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "postId": "UgkxQrStUv67890",
    "author": "MrBeast",
    "authorUrl": "/@MrBeast",
    "text": "New video is up!",
    "publishedTime": "2 days ago",
    "likeCount": "88K",
    "commentCount": "3.2K",
    "pollChoices": [],
    "pollTotalVotes": null,
    "pollTotalVotesValue": null,
    "videoThumbnail": "https://i.ytimg.com/vi/exampleId/maxresdefault.jpg",
    "images": [],
    "attachmentType": "video",
    "sourceUrl": "https://www.youtube.com/@MrBeast"
  }
]

How can I use the data extracted with the YouTube Community Posts Scraper?

The output is a flat, typed JSON row per post, so it drops straight into a spreadsheet, a BI tool, or a script without any reshaping. Because pollTotalVotesValue is already an integer and pollChoices is already structured, you can sort, filter, and aggregate on poll results immediately rather than parsing display strings like "2.6M votes" yourself.

• 📊 Creator-partnership and sponsorship teams — pull a creator's poll history before a deal, and use pollChoices plus pollTotalVotesValue to gauge real audience-preference signals instead of relying on subscriber counts alone.
• 🤖 AI engineers and LLM developers — feed text (the poll question) and pollChoices as grounding context so an agent can answer questions about a creator's audience or summarize recent community activity from live data instead of a stale training cut.
• 📈 Market and trend researchers — run the same channel list on a schedule and diff pollChoices[].percentage and pollTotalVotesValue between runs to see how opinion shifts while a poll is live.
• 🎬 Content and social teams — compare attachmentType distribution and commentCount across a competitor set to see which post types and questions drive the most engagement.
• 🔬 Academic and social researchers — collect poll choices and vote counts across a set of channels as a structured dataset for studying audience-engagement or parasocial-interaction patterns, without hand-transcribing results from screenshots.

How do you monitor community-poll results over time?

Tracking a poll while it's live is a repeated-query problem: a poll's pollTotalVotesValue climbs and its pollChoices[].percentage values shift as more of a channel's audience votes, and the interesting signal is the delta between runs, not any single snapshot. Run the same channelUrls list on a recurring schedule with pollsOnly on and a pollKeywordFilter matching the poll you're watching (or minPollChoices set to isolate it if the wording varies), then diff the new pollTotalVotesValue and each choice's percentage against the previous run's values for the same postId.

A simple loop looks like: scheduled run across your channel list → keep the dataset keyed by postId → on the next run, join incoming rows to the same postId → alert when pollTotalVotesValue crosses a threshold or a choice's percentage moves past whatever margin you care about. Because percentage is only populated when YouTube's response happens to include it, base alerting on pollTotalVotesValue first and treat percentage deltas as a secondary signal.

Trigger the repeated runs with an Apify Schedule on the actor, and pull each run's dataset via the Apify API or apify-client once it finishes — there is no built-in webhook or delta-diffing feature in the actor itself, so the comparison logic runs in whatever you're using to consume the dataset.

Integrate the YouTube Community Posts Scraper and automate your workflow

This actor works with any language or tool that can call the Apify API — there's no separate signup flow or credential system beyond your Apify account token. Start a run with channelUrls and your Poll Filters, wait for it to finish, then read the dataset — the same three-step pattern works whether you're calling from a Python script, a Node service, or a low-code automation tool that can make an HTTP request.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

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

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("attachmentType") == "poll":
        print(row["text"], row["pollChoices"], row["pollTotalVotesValue"])

Scheduled monitoring and delivery

Set up an Apify Schedule on the actor to trigger runs on a cron interval, then read each run's dataset through the Apify API, apify-client, or the Console once it finishes. The actor doesn't push a webhook payload itself, but Apify's platform-level run webhooks can notify an external system when a scheduled run completes, so you can trigger your own fetch-and-diff step from there.

Running from the Apify Console without writing code

If you don't need a scripted integration, the actor is fully usable from the Apify Console alone: fill in channelUrls and your Poll Filters in the input form, click Start, and watch rows land in the dataset tab in real time as the run progresses. From there you can export the results directly as JSON or CSV, or open the API tab on the run to copy a ready-made request for whichever language you end up automating with later — the Console and the programmatic paths use the same underlying run, so there's nothing to reconcile between a manual test and a scripted call.

Is it legal to scrape YouTube community posts and polls?

Yes — this actor only extracts what any signed-out visitor to a channel's public Community tab can already see; it does not access private posts, does not log in, and does not bypass any access control. Courts have recognized that scraping publicly accessible web data does not violate the U.S. Computer Fraud and Abuse Act (hiQ Labs, Inc. v. LinkedIn Corp., 9th Cir., 2022).

The data returned here is content a channel owner chose to publish publicly — poll questions, choices, and vote counts — rather than private personal data, so YouTube's Terms of Service, not GDPR or CCPA, is the primary framework to consider. Author names and handles are the channel's own public identity, not private user data, but you should still review YouTube's Terms of Service before storing or republishing scraped content at scale, and note that scraping for internal monitoring carries a different risk profile than scraping to build a dataset for AI training. Consult your legal team for commercial use cases involving bulk data storage.

❓ Frequently asked questions

Does channelUrls accept both handle and channel-ID URL formats?

Yes. Both youtube.com/@Handle and youtube.com/channel/UC... URLs work, and you can mix formats within the same channelUrls list. The actor resolves the numeric channelId from the page itself, so you don't need to look it up beforehand.

How do I keep only polls with more than two choices?

Set minPollChoices above 2 — for example 4 to drop simple yes/no or A/B polls and keep only multi-option ones. It only applies to posts that are already polls; non-poll posts are unaffected by this filter (and are excluded anyway if pollsOnly is on).

How does the scraper handle YouTube's anti-bot measures?

Every request goes through a curl_cffi session impersonating Chrome's TLS/JA3 fingerprint rather than a generic HTTP client. A soft-block detector checks each response for a missing ytInitialData payload, a too-short page, or a consent//sorry/ wall, and treats any of those as a failed fetch; failed fetches retry with exponential backoff, and if a configured proxy keeps failing, the actor escalates through the proxy fallback chain (custom proxy → Apify Datacenter → Apify Residential → direct connection) on a fresh IP before giving up on that channel.

Does the scraper extract per-choice poll vote percentages?

Yes — they arrive in pollChoices[].percentage alongside each choice's text, and the total is separately available in pollTotalVotes (text) and pollTotalVotesValue (integer). percentage is null when YouTube's response doesn't include a per-choice split for that viewer session, which happens most often since the actor reads polls logged out; text and the total-vote fields are populated whenever the poll itself is present.

How many results does the scraper return per query?

Up to maxPosts matching rows per channel (1–10,000, default 10). To reach that count when filters are strict, the actor keeps paginating the channel's Community tab, but it stops after 60 continuation pages per channel regardless of whether maxPosts was reached — a channel with very few matching polls in its recent post history may return fewer rows than requested even on a fully successful run.

What happens if a channel has no community posts, or none match my filters?

The run completes normally with zero rows for that channel and a log line noting whether any posts were scanned at all. If posts were scanned but none passed your Poll Filters, loosen pollsOnly, minPollChoices, or pollKeywordFilter and re-run; if zero posts were found, verify the channel actually has a public Community tab — some channels don't post there at all. When every channel in a run returns zero matching rows, the log also suggests setting pollsOnly to false as the first thing to try, since that's the filter most likely to be excluding everything.

Are likeCount and commentCount exact numbers?

No — they're returned as the abbreviated display strings YouTube itself shows (e.g. "12K", "3.2M"), not pre-parsed integers, unlike pollTotalVotesValue. If you need them as numbers, parse the same K/M/B suffix pattern the actor already applies to pollTotalVotes internally. Both fields are null, not 0, whenever YouTube doesn't display a count for that post.

How do I monitor a specific poll's results over time?

Schedule the actor to run on the same channelUrls and pollKeywordFilter at an interval, key incoming rows by postId, and compare pollTotalVotesValue and pollChoices[].percentage against the previous run's values for that same post. See "How do you monitor community-poll results over time?" above for the full pattern.

Does the scraper work with Claude, ChatGPT, and AI agent frameworks?

Yes, as an HTTP endpoint callable through the Apify API or apify-client from any agent framework — start a run, wait for it to finish, and read the dataset. That lets an agent retrieve live poll results and post text before answering a question, rather than relying on stale training data about a channel.

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

As observed on the Apify Store on 2026-07-26, sian.agency's YouTube Community Posts & Polls Scraper bundles a channel-feed listing operation with separate post-detail and post-comments operations in one actor, and returns pollChoices as a flat array of choice strings with a separately parsed pollTotalVotes integer — its listing doesn't document a per-choice vote-percentage field. This actor is narrower in scope — it doesn't fetch individual comment threads — but returns pollChoices as {text, percentage} objects and gives you three server-side poll filters (pollsOnly, minPollChoices, pollKeywordFilter) to narrow the feed to the polls you want before you ever look at the data.

Can I use this without managing proxies or YouTube credentials?

Yes. No YouTube login or API key is required — the actor requests the public Community tab directly. By default it runs with a direct connection and no proxy at all; you only need to configure proxy if you're running high volume and want Apify Proxy or a custom proxy URL in the mix, and the actor manages the fallback and escalation between proxy tiers itself.

Does the scraper pick up quiz posts, not just polls?

Yes — YouTube quiz posts are parsed through the same choice-extraction path as polls and come back with the same pollChoices, pollTotalVotes, and pollTotalVotesValue fields, labeled attachmentType: "poll". See "What is the difference between a community poll and a community quiz on YouTube?" above.

Which proxy groups does the actor support?

proxy.apifyProxyGroups accepts Apify Proxy group names; the actor always appends DATACENTER and RESIDENTIAL to whatever you list if they aren't already there, and tries them in that order after any custom proxy you've set, before finally falling back to a direct connection with no proxy. You don't need to manually configure the escalation order — it's fixed in the actor.

💬 Your feedback

Found a bug, or a poll field that isn't parsing the way you expect? Let us know through the Issues tab on this actor's Apify Console page so we can take a look. Feedback like this is what keeps the poll-parsing logic accurate as YouTube changes its Community tab.