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

Scrape public YouTube Community posts, polls, images, videos, and engagement from channel Posts tabs. Export clean creator updates.

- **URL**: https://apify.com/automation-lab/youtube-community-posts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.12 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## YouTube Community Posts Scraper

Scrape public YouTube Posts / Community tab updates from creator channels.

Use this actor to collect channel announcements, launch posts, polls, image posts, video shares, and engagement signals that do not appear in normal video or comment exports.

### What does YouTube Community Posts Scraper do?

YouTube Community Posts Scraper extracts public posts from a channel's Posts or Community tab.

It saves each post as a structured dataset row.

The actor works with public channel pages and does not require your YouTube login.

It is designed for monitoring creator updates at scale.

### Who is it for?

- 📣 Social media teams tracking creator announcements
- 🎬 YouTube agencies monitoring client channels
- 🧠 Competitive intelligence teams watching launch posts
- 🗳️ Research teams collecting poll options and audience prompts
- 📰 Journalists following creator/community updates
- 🛍️ E-commerce teams watching influencer promotions

### Why use this actor?

Community posts are often where creators announce launches, polls, giveaways, collaborations, delays, and audience requests.

Those updates can be missed if you only scrape videos, Shorts, comments, or transcripts.

This actor focuses on the channel Posts surface.

### What data can you extract?

| Field | Description |
| --- | --- |
| `channelName` | YouTube channel name |
| `channelHandle` | Channel handle when available |
| `channelId` | Channel browse ID |
| `channelUrl` | Canonical channel URL |
| `postId` | YouTube post ID |
| `postUrl` | Direct post URL |
| `text` | Post text |
| `publishedTime` | Relative publish time shown by YouTube |
| `voteCount` | Like/vote count when exposed |
| `commentCount` | Comment count when exposed |
| `attachmentType` | none, image, video, poll, quiz, multi_image, or unknown |
| `imageUrls` | Image URLs found in the post |
| `videoUrl` | Linked YouTube video URL when present |
| `pollOptions` | Poll/quiz options when present |
| `scrapedAt` | ISO scrape timestamp |

### How much does it cost to scrape YouTube community posts?

The actor uses pay-per-event pricing.

A small start event is charged once per run.

A post event is charged for each saved community post.

Formula-derived pricing from cloud validation starts at about $0.03 per 1,000 saved posts on the Starter/BRONZE tier before higher-tier discounts.

Actual cost depends on the number of posts saved and the Apify plan tier used for the run.

### Input

Provide one or more public YouTube channel URLs.

Examples:

```json
{
  "startUrls": [
    { "url": "https://www.youtube.com/@MrBeast" },
    { "url": "https://www.youtube.com/@Google" }
  ],
  "maxItems": 20,
  "languageCode": "en",
  "countryCode": "US"
}
````

### Input fields

#### `startUrls`

Channel URLs to scrape.

You can use handle URLs, `/channel/...` URLs, `/posts` URLs, or legacy `/community` URLs.

#### `maxItems`

Maximum posts to save across all channels.

Use a low number for the first run.

#### `languageCode`

YouTube web language context.

Default: `en`.

#### `countryCode`

YouTube web country context.

Default: `US`.

### Output example

```json
{
  "channelName": "MrBeast",
  "channelHandle": null,
  "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
  "postId": "Ugkx...",
  "postUrl": "https://www.youtube.com/post/Ugkx...",
  "text": "WE HIT HALF A BILLION SUBSCRIBERS ❤️",
  "publishedTime": "1 day ago",
  "voteCount": 904000,
  "commentCount": 39000,
  "attachmentType": "image",
  "imageUrls": ["https://yt3.ggpht.com/..."] ,
  "videoUrl": null,
  "pollOptions": [],
  "scrapedAt": "2026-06-14T08:22:12.533Z"
}
```

### How to run

1. Open the actor on Apify.
2. Add one or more YouTube channel URLs.
3. Keep `maxItems` small for a test run.
4. Start the actor.
5. Export results as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

- Use channel home URLs such as `https://www.youtube.com/@MrBeast`.
- Use `/channel/UC...` URLs when you already have channel IDs.
- Increase `maxItems` only after a small test run succeeds.
- Some channels may not have public posts.
- Very old posts may require additional pagination time.

### Integrations

You can connect the dataset to:

- Google Sheets for social monitoring
- Slack or Discord alerts for new creator announcements
- BI dashboards for campaign tracking
- CRM enrichment workflows for influencer teams
- LLM pipelines for announcement classification

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/youtube-community-posts-scraper').call({
  startUrls: [{ url: 'https://www.youtube.com/@MrBeast' }],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/youtube-community-posts-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.youtube.com/@MrBeast'}],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~youtube-community-posts-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.youtube.com/@MrBeast"}],"maxItems":20}'
```

### MCP usage

Use this actor through Apify MCP when working in Claude Code or Claude Desktop.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/youtube-community-posts-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/youtube-community-posts-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-youtube-community-posts": {
      "url": "https://mcp.apify.com/?tools=automation-lab/youtube-community-posts-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the latest YouTube posts for these creator channels."
- "Find community posts that mention launches or giveaways."
- "Monitor these channels and summarize new poll questions."

### Data quality notes

YouTube exposes some values as relative text.

For example, `publishedTime` may be `1 day ago`.

Engagement counts may be compacted on YouTube and normalized to numbers when possible.

### Limitations

The actor only extracts public posts.

It does not access private members-only posts.

It does not log in as a YouTube user.

It does not scrape post comments; use a dedicated YouTube comments scraper for that workflow.

### Legality

This actor extracts publicly visible web data.

You should use the data responsibly, respect applicable laws, and follow YouTube's terms and your own compliance requirements.

Do not scrape private, personal, or access-restricted content.

### FAQ

#### Is it legal to scrape YouTube community posts?

The actor is intended for public channel posts only. Review your use case, jurisdiction, and compliance obligations before collecting or storing data.

#### Does it scrape members-only posts?

No. The actor does not log in and does not access members-only, private, or age-gated content.

### Troubleshooting

#### The actor returned no posts

The channel may not have public Posts/Community tab content, or the URL may not be a channel URL.

Try the channel home URL and a small `maxItems` value.

#### A field is null

YouTube does not expose every field for every post.

Text-only posts have no images.

Image posts may not link a video.

Poll options only appear for poll or quiz posts.

### Related scrapers

- https://apify.com/automation-lab/youtube-scraper
- https://apify.com/automation-lab/youtube-comments-scraper
- https://apify.com/automation-lab/youtube-channel-scraper
- https://apify.com/automation-lab/youtube-transcript-scraper
- https://apify.com/automation-lab/youtube-shorts-scraper

### Changelog

#### 0.1

Initial build.

HTTP-first extraction from public YouTube channel Posts tabs.

### Support

If a run fails, include the run ID and the input you used when asking for help.

Small reproducible inputs are the fastest to debug.

### Privacy

The actor does not ask for your YouTube credentials.

It does not store browser cookies from your account.

It only requests public channel pages.

### Performance

The actor is HTTP-first and uses low memory by default.

Pagination continues until `maxItems` is reached or YouTube has no more continuation pages.

### Recommended first run

Use one channel and `maxItems: 10`.

Review the dataset.

Then increase volume for production monitoring.

### Production workflow

Run the actor on a schedule.

Compare new `postId` values against your previous dataset.

Send alerts when post text matches campaign, product, launch, giveaway, or competitor keywords.

# Actor input Schema

## `startUrls` (type: `array`):

Add YouTube channel, handle, /posts, or /community URLs. Examples: https://www.youtube.com/@MrBeast or https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA

## `maxItems` (type: `integer`):

Maximum number of community posts to save across all channels.

## `languageCode` (type: `string`):

YouTube web client language code used for request headers and InnerTube context.

## `countryCode` (type: `string`):

YouTube web client country code used for request headers and InnerTube context.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@MrBeast"
    }
  ],
  "maxItems": 10,
  "languageCode": "en",
  "countryCode": "US"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.youtube.com/@MrBeast"
        }
    ],
    "maxItems": 10,
    "languageCode": "en",
    "countryCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [{ "url": "https://www.youtube.com/@MrBeast" }],
    "maxItems": 10,
    "languageCode": "en",
    "countryCode": "US",
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@MrBeast"
    }
  ],
  "maxItems": 10,
  "languageCode": "en",
  "countryCode": "US"
}' |
apify call automation-lab/youtube-community-posts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/youtube-community-posts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Community Posts Scraper",
        "description": "Scrape public YouTube Community posts, polls, images, videos, and engagement from channel Posts tabs. Export clean creator updates.",
        "version": "0.1",
        "x-build-id": "GOGvaXhVkQVaTCjnx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~youtube-community-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-youtube-community-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~youtube-community-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-youtube-community-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~youtube-community-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-youtube-community-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "YouTube channel URLs",
                        "type": "array",
                        "description": "Add YouTube channel, handle, /posts, or /community URLs. Examples: https://www.youtube.com/@MrBeast or https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum posts",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of community posts to save across all channels.",
                        "default": 20
                    },
                    "languageCode": {
                        "title": "Language code",
                        "type": "string",
                        "description": "YouTube web client language code used for request headers and InnerTube context.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "YouTube web client country code used for request headers and InnerTube context.",
                        "default": "US"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```