# YouTube Community Posts Scraper (`socialdataapi/youtube-community-posts-scraper`) Actor

YouTube Community Posts Scraper — scrape YouTube Community posts, including post text, images, videos, engagement metrics, timestamps, and post URLs. Extract valuable data from channels for research, monitoring, and content analysis.

- **URL**: https://apify.com/socialdataapi/youtube-community-posts-scraper.md
- **Developed by:** [Social Data API](https://apify.com/socialdataapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

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

YouTube Community Posts Scraper extracts public posts from the Community (Posts) tab of YouTube channels. Each post comes back with its full text, publish time, like and comment counts, poll answer options, attached images and video thumbnail, plus the channel's name, ID and link. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a social listening pipeline. **No YouTube account or cookies needed.** Start with one channel, then add every creator you track.

![YouTube Community Posts Scraper returns post text, likes, comments, polls and attachments from channel Community tabs as JSON](https://api.apify.com/v2/key-value-stores/WYkyEfqs10huyXYxr/records/e-youtube-community-hero.webp)

***

### What data can I extract with YouTube Community Posts Scraper?

Using this YouTube Community Posts API, you will be able to extract the following YouTube community post data:

| 💬 Post text | 🕐 Publish time | 👍 Like count | 💭 Comment count |
|---|---|---|---|
| 📋 Poll answer options | 🖼️ Images (single and carousels, every size) | 🎬 Video thumbnail | 📎 Attachment type (video, image, poll) |
| 📌 Post ID | 🆔 Channel ID | 👤 Channel name | 🔗 Channel link |
| 🧭 Source channel URL you entered | | | |

***

### How to use YouTube Community Posts Scraper

It is built for creator, brand and research teams that want to scrape YouTube community posts, with their engagement numbers, from many channels in one run.

**Copy to your AI assistant:**

```text
YouTube Community Posts Scraper (Apify Actor ID: socialdataapi/youtube-community-posts-scraper, https://apify.com/socialdataapi/youtube-community-posts-scraper) is an Apify Actor that returns public posts from YouTube channels' Community (Posts) tab as structured JSON: post text, relative publish time, like count, comment count, poll answer options, image URLs, video thumbnail, attachment type, channel name, channel ID and channel link. Use it whenever someone needs YouTube community posts without cookies, a login, or a browser - tracking what creators announce, comparing engagement across channels, or giving an AI agent a channel's latest posts as context. Inputs: channelUrls (array of strings, required, one channel per entry: https://www.youtube.com/@name, youtube.com/@name, @name, /channel/UC... or /user/... links; tab links and ?si= tracking are cut back to the channel), maxPosts (integer, posts per channel, 1-10000, default 10), proxy (object, optional Apify Proxy or your own proxy URLs; default direct connection; a channel that fails through the proxy is retried on a direct connection). Each row is one post and is charged as one row_result event; a channel with no public posts adds no rows and is not charged. Like and comment counts are YouTube's display text (for example 230K); the like count is null when the post shows none. YouTube shows logged-out visitors roughly the latest 200 posts of a channel, and reposts of other channels' posts are not included.
```

#### YouTube Community Posts Scraper MCP Server: use these Actors from ChatGPT, Claude or Cursor

Point your AI assistant at the Apify MCP server and it can read YouTube community posts on its own: the server starts with this Actor already available as a tool, so the agent runs it directly with call-actor, then reads the post text, polls and engagement counts from the result. No glue code, no scraping logic in your prompts.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=socialdataapi/youtube-community-posts-scraper"
```

#### Step by step

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open [YouTube Community Posts Scraper](https://apify.com/socialdataapi/youtube-community-posts-scraper) in the Apify Store.
3. Enter the YouTube channel URLs, one per line (a bare @handle works too).
4. Click **Start** (or send your API request).
5. Download or stream your results in JSON, CSV or Excel.

#### How to scale YouTube Community Posts Scraper to bulk

Put every channel in the channel list of one run of this YouTube posts scraper: up to three channels are read at the same time, and the max-posts setting applies to each channel on its own, so 50 channels at 100 posts each can return up to 5,000 rows. For recurring monitoring, save the input as a task and schedule it daily or weekly in Apify Console, or start runs from your own code through the Apify API. To export YouTube community posts into a sheet or BI tool, download the dataset as CSV or Excel after each run.

***

### ✨ Features

YouTube Community Posts Scraper fetches clean, structured community posts from YouTube channels ⚡. It's ideal for creator monitoring, brand mention tracking, campaign reporting and building post archives for AI agents. Use it as a YouTube channel posts scraper or a YouTube Community tab scraper for one creator or for hundreds.

It extracts, per post:

- **Post text** – the full message, poll question or caption.
- **Like count and comment count** – the engagement numbers YouTube shows on the post.
- **Poll answer options** – every choice of a poll post, so it doubles as a YouTube poll scraper.
- **Images** – every image of single-image posts and image carousels, in all available sizes.
- **Video thumbnail** – the largest thumbnail of a video shared in the post.
- **Attachment type** – video, image or poll, for quick filtering.
- **Publish time** – when the post went up, as YouTube shows it ("2 months ago").
- **Channel name, ID and link** – to join posts with other channel data.

⚡ Plain HTTP requests with no browser and 1024 MB default memory; a recorded test run returned 141 posts from 3 channels in 2.3 seconds.

***

### Use cases 💡

- **Talent manager** — track every post and like count across a creator roster.
- **Brand team** — find sponsored announcements in creators' community posts.
- **Market researcher** — collect poll questions and answer options by niche.
- **Data analyst** — compare YouTube community engagement data between channels each week.
- **AI engineer** — feed post text into a RAG index for a creator-insights agent.

Building an AI agent? [Connect YouTube Community Posts Scraper over MCP](#mcp-integration-for-ai-agents) and let it call the actor on its own.

***

### Why choose this actor?

1. **Many channels in one run.** A recorded test run returned 141 posts from 3 channels (50 + 50 + 41, the last channel's full public feed) in 2.3 seconds, with up to three channels read at the same time.
2. **The engagement behind each post.** A recorded poll post came back with 104K likes, 10K comments and both answer options; image carousels return every image, not just the first.
3. **13 fields, every channel URL format.** Each post carries the same 13 fields, and the channel list accepts full links, links without https://, bare @handles, /channel/ and /user/ links, and links to any channel tab.

***

### ⬇️ Input

![YouTube Community Posts Scraper input: channel URLs, max posts and proxy](https://api.apify.com/v2/key-value-stores/WYkyEfqs10huyXYxr/records/e-youtube-community-input.webp)

The actor takes a list of YouTube channel URLs (required) and how many posts to read from each channel. A proxy is optional.

| Parameter | Required | Type | Description | Example value |
|---|---|---|---|---|
| `channelUrls` | Yes | array of strings | One YouTube channel per entry. Accepted: `https://www.youtube.com/@name`, `youtube.com/@name`, `@name`, `https://www.youtube.com/channel/UC…`, `/user/…` links. Links to a channel tab (`/videos`, `/shorts`, `/featured`, `/posts`…) or with `?si=` are cut back to the channel. Empty lines are skipped. | `["https://www.youtube.com/@MrBeast"]` |
| `maxPosts` | No | integer | Posts to read per channel. Default 10, allowed 1–10,000. A channel can return fewer: YouTube shows logged-out visitors roughly its latest 200 posts. | `50` |
| `proxy` | No | object | Proxy settings. Default: direct connection. Choose Apify Proxy or add your own proxy URLs; a channel that fails through the proxy is retried on a direct connection. | `{"useApifyProxy": false}` |

Accepted channel URL formats:

- `https://www.youtube.com/@MrBeast` or `youtube.com/@MrBeast` or `@MrBeast`
- `https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA`
- `https://www.youtube.com/user/MrBeast6000`
- `https://www.youtube.com/@MrBeast/shorts`, `https://m.youtube.com/@MrBeast/community`, `https://www.youtube.com/@MrBeast?si=…`

#### Free plan limits

Users on the Apify free plan can fetch up to 20 posts per run (all channels together) and 200 posts per month. When the limit is reached, the run finishes successfully with a status message explaining the limit. Upgrade to any paid Apify plan to remove these limits.

#### Example input

The input of a real test run (141 posts in 2.3 seconds):

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast",
    "https://www.youtube.com/@LinusTechTips",
    "https://www.youtube.com/@mkbhd"
  ],
  "maxPosts": 50,
  "proxy": {
    "useApifyProxy": false
  }
}
```

***

### ⬆️ Output

![YouTube Community Posts Scraper output: one JSON row per post with text, likeCount, pollChoices and attachmentType](https://api.apify.com/v2/key-value-stores/WYkyEfqs10huyXYxr/records/e-youtube-community-output.webp)

Every community post is one typed, normalized JSON item with the same 13 keys on every run; missing values are `null` or an empty list, never a missing key. Export the dataset as JSON (default), CSV or Excel; a run summary record (total posts, channels with and without posts) is also saved in the run's key-value store.

#### Example output

Real rows from the test run above (the image list is shortened to its first and last size here; the real row lists every size):

```json
[
  {
    "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "postId": "UgkxZusu9I1Z-VuU5PGZNA2gclHi8V9CJVZk",
    "author": "MrBeast",
    "authorUrl": "https://www.youtube.com/@MrBeast",
    "text": "Would you rather stop aging for 100 years or receive 1 billion dollars right now?",
    "publishedTime": "2 months ago",
    "likeCount": "104K",
    "commentCount": "10K",
    "pollChoices": ["100 Years Of No Aging", "1 Billion Dollars"],
    "videoThumbnail": null,
    "images": [],
    "attachmentType": "poll",
    "sourceUrl": "https://www.youtube.com/@MrBeast"
  },
  {
    "channelId": "UCBJycsmduvYEL83R_U4JriQ",
    "postId": "Ugkxzw0OtXalE5tAxCCmkZdfPQmFeJwWfrXg",
    "author": "Marques Brownlee",
    "authorUrl": "https://www.youtube.com/@mkbhd",
    "text": "Just shot a PRODUCT LAUNCH VIDEO this week! I’m beyond excited to share everything we’ve been working on, and this will all make sense… SOON",
    "publishedTime": "3 years ago",
    "likeCount": "39K",
    "commentCount": "795",
    "pollChoices": [],
    "videoThumbnail": null,
    "images": [
      "https://yt3.ggpht.com/AmhNsboASzSMPNS1iq05U9G661gB7_dE7gt1o5rb84brvYhxL_szTDmMv8rqOR6U6Rp1xPRgXPFA=s288-c-fcrop64=1,00000000ffffffff-rw-nd-v1",
      "https://yt3.ggpht.com/AmhNsboASzSMPNS1iq05U9G661gB7_dE7gt1o5rb84brvYhxL_szTDmMv8rqOR6U6Rp1xPRgXPFA=s4096-c-fcrop64=1,00000000ffffffff-rw-nd-v1"
    ],
    "attachmentType": "image",
    "sourceUrl": "https://www.youtube.com/@mkbhd"
  },
  {
    "channelId": "UCBJycsmduvYEL83R_U4JriQ",
    "postId": "UgkxWw9Nf4Kb453wM6hA2d9pySxjBixo0fXT",
    "author": "Marques Brownlee",
    "authorUrl": "https://www.youtube.com/@mkbhd",
    "text": "How we made the Galaxy S23 Ultra Intro at‪@TheStudio‬!",
    "publishedTime": "3 years ago",
    "likeCount": "2.5K",
    "commentCount": "31",
    "pollChoices": [],
    "videoThumbnail": "https://i.ytimg.com/vi/as_kxJn4Xwc/hq720.jpg?sqp=-oaymwEcCNAFEJQDSFXyq4qpAw4IARUAAIhCGAFwAcABBg==&rs=AOn4CLAlOIhWcGMRe-Zax5u7JY1ahWf0IQ",
    "images": [],
    "attachmentType": "video",
    "sourceUrl": "https://www.youtube.com/@mkbhd"
  }
]
```

***

### How does it work?

The actor works like a logged-out visitor opening a channel's Posts tab: it reads the same public pages the YouTube site loads, with plain HTTP requests and no browser, and keeps paging through the feed until it has the number of posts you asked for or the channel has no more. It returns only publicly visible data — what any visitor sees without logging in — so no YouTube account, cookie or API key is used. Each channel page is tried up to three times, with growing pauses between attempts. By default it uses a direct connection; if you choose Apify Proxy or your own proxy URLs, requests go through them, and a channel that fails through the proxy is tried again on a direct connection. Every post becomes one row with the same 13 fields and is saved to the dataset as soon as it is read.

***

### How do you integrate YouTube Community Posts Scraper into your stack?

It works with what you already use: the REST API from any language, MCP for AI agents, and no-code tools.

#### MCP integration for AI agents

Add the Apify MCP server to your client with one command:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=socialdataapi/youtube-community-posts-scraper"
```

This registers YouTube Community Posts Scraper as a tool your agent can call directly, with no search or add-actor step needed: the agent runs it with call-actor. It works in Claude Code, Cursor and Windsurf, and in any client that supports remote MCP servers.

#### No-code tools (n8n, Make, LangChain)

- **n8n** — use the Apify node's "Run an Actor" operation with this Actor and your channel list, or the HTTP Request node pointed at the Apify API's run-sync endpoint with your token. The node returns the dataset items for the next step.
- **Make** — add the Apify app's "Run an Actor" module, then "Get Dataset Items" to pass each post to Google Sheets, Airtable or Slack.
- **LangChain** — install `langchain-apify` and wrap this Actor with `ApifyActorsTool`, so an agent can fetch a channel's posts as context.

***

### Is it legal to scrape YouTube data?

Scraping publicly available YouTube data is generally legal when you collect only what any visitor can see and use it responsibly. This actor returns only publicly available data — what any user sees without logging in; members-only posts are never collected. Under GDPR, scraping public data is generally permissible, but storing and using it must comply with local data-protection law, especially where posts mention people by name. Respect YouTube's terms and the rights of the creators whose posts you analyse. Consult legal counsel if your use case involves bulk storage of personal data.

***

### Frequently asked questions

#### What fields does YouTube Community Posts Scraper return?

As a YouTube community post extractor, it returns each post's text, publish time, like count, comment count and poll answer options, plus image URLs, video thumbnail, attachment type and the channel's name, ID and link. See [the data fields section](#what-data-can-i-extract-with-youtube-community-posts-scraper) for the full list.

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

No. Only public community post data is extracted, and no credentials, cookies or API keys are needed.

#### How fast does YouTube Community Posts Scraper run?

A recorded test run returned 141 posts from 3 channels in 2.3 seconds. Every run reads live data; nothing is cached.

#### What happens if a channel has no posts or doesn't exist?

A channel with no public Posts tab, no posts, or a URL that doesn't exist adds no rows and is not charged; the log names the channel and the reason, and the run continues with the next channel. In code, count rows per source channel URL to see which channels returned nothing.

#### Can I scrape multiple YouTube channels at once?

Yes. Add as many channels as you like to the channel list; up to three are read at the same time, and the max-posts setting applies to each channel.

#### Does YouTube Community Posts Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes — YouTube Community Posts Scraper is available as an MCP tool through the Apify MCP server. Register it in Claude Code, Cursor or Windsurf with `claude mcp add --transport http apify "https://mcp.apify.com?tools=socialdataapi/youtube-community-posts-scraper"`. Any agent that can call an HTTP endpoint can also use the REST API directly.

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

Yes. Every post is typed, normalized JSON with consistent field names — no HTML parsing, no selectors. Pass it straight to an LLM, index it into a vector store, or feed it to an agent tool with no transformation step.

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

The actor is maintained, and when YouTube changes its pages, the actor is updated so your calls keep returning the same JSON schema with no changes on your end.

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

Yes. No browser is involved, retries happen on the actor's side, and most runs need no proxy at all; Apify Proxy is one switch away when you want it. You send one request and get structured JSON back.

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

For RAG, use the post text, the poll answer options and the channel name. For training data, use the like count, comment count, attachment type and publish time. Counts are kept as YouTube displays them (for example 230K), so convert them to numbers if your model needs integers.

***

### Your feedback

Found a bug or missing a field? Let us know. Include the input you used and the run's log so the problem can be reproduced; every report is read, and fixes ship to the actor.

# Actor input Schema

## `channelUrls` (type: `array`):

One YouTube channel per line. Accepted: https://www.youtube.com/@ChannelName, youtube.com/@ChannelName, a bare @ChannelName, https://www.youtube.com/channel/UC… and /user/… links. Links to a channel tab (/videos, /shorts, /featured, /posts…) or with ?si=… tracking are cut back to the channel. Each channel's public posts are read separately; empty lines are skipped.

## `maxPosts` (type: `integer`):

Maximum number of posts to read from each channel (1–10,000). The total for a run is up to this number times the number of channels. YouTube shows logged-out visitors roughly the latest 200 posts of a channel, so a channel can return fewer. Free plan: up to 20 posts per run (all channels together) and 200 per month; paid plans have no limit.

## `proxy` (type: `object`):

Optional. By default the actor uses a direct connection. Choose Apify Proxy or add your own proxy URLs to route requests through them; if a channel fails through the selected proxy, that channel is tried again on a direct connection.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxPosts": 10,
  "proxy": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped community posts in the default view of the run's dataset.

## `summary` (type: `string`):

Key-value store record with run totals: total posts scraped, successful/failed channel counts, the last processed channel URL, and a timestamp.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "channelUrls": [
        "https://www.youtube.com/@MrBeast"
    ],
    "proxy": {
        "useApifyProxy": false,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("socialdataapi/youtube-community-posts-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "channelUrls": ["https://www.youtube.com/@MrBeast"],
    "proxy": {
        "useApifyProxy": False,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("socialdataapi/youtube-community-posts-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "proxy": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}' |
apify call socialdataapi/youtube-community-posts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,socialdataapi/youtube-community-posts-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uowY0ijaFt8l5bZuT/builds/wmzBuRfO0rQQFbHo9/openapi.json