# Reddit Community Scraper V2 (`myagizm/reddit-community-scraper-v2`) Actor

Reddit Community Scraper V2 — cached data source (results may lag up to ~1.5h). Structured JSON, no login, no API key. For real-time data use the V1 actor.

- **URL**: https://apify.com/myagizm/reddit-community-scraper-v2.md
- **Developed by:** [MYM](https://apify.com/myagizm) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Reddit Community Scraper V2 — Scrape Reddit Communities in Bulk (No API Key, No Login)

<p align="center">
<strong>Scrape Reddit communities at scale</strong> — turn any list of subreddit names into clean, structured JSON packed with posts, scores, flairs, authors, comment counts, timestamps, and community context — in minutes, with <strong>no API key, no login, and no cookies or account required</strong>. Export scraped data to JSON, CSV, Excel, or XML, schedule runs via API, and integrate with your tools and AI workflows.
</p>

<p align="center">
<strong>Built for AI agents:</strong> plug this actor into <strong>Claude</strong>, <strong>ChatGPT / Codex</strong>, and <strong>Cursor</strong> via the <a href="https://apify.com/apify/actors-mcp-server">Apify MCP server</a> so your assistant can scrape Reddit community data on demand.
</p>

<p align="center">
<a href="https://apify.com/myagizm/reddit-community-scraper-v2"><img src="https://img.shields.io/badge/▶%20Try%20Now-Reddit%20Community%20Scraper%20V2-45C33E?style=for-the-badge" alt="Try Now"></a>
<a href="https://apify.com/myagizm/reddit-community-scraper-v2/input-schema"><img src="https://img.shields.io/badge/⚙%20Input%20Schema-View-2B6CB0?style=for-the-badge" alt="Input Schema"></a>
<a href="https://apify.com/myagizm/reddit-community-scraper-v2/api"><img src="https://img.shields.io/badge/⟨⟩%20API%20Docs-Read-6B46C1?style=for-the-badge" alt="API Docs"></a>
</p>

<p align="center">
<a href="#what-can-reddit-community-scraper-v2-do">What it does</a> •
<a href="#use-with-ai-agents-mcp">AI Agents (MCP)</a> •
<a href="#how-to-scrape-reddit-communities">How to scrape</a> •
<a href="#what-data-can-i-scrape-from-reddit-communities">Output data</a> •
<a href="#limits">Limits</a> •
<a href="#output-example">Output example</a> •
<a href="#how-much-does-it-cost-to-scrape-reddit-communities">Pricing</a> •
<a href="#integrations">Integrations</a> •
<a href="#faq">FAQ</a> •
<a href="#want-other-reddit-data">Other Reddit actors</a>
</p>

---

### What can Reddit Community Scraper V2 do? {#what-can-reddit-community-scraper-v2-do}

**Reddit Community Scraper V2** lets you **scrape Reddit communities in bulk** — feed it a list of subreddit names and it returns each community's content as clean, structured JSON. Paste names like `technology`, `science`, or `AskReddit` (the `r/` prefix is optional) and it collects the posts flowing through each community — titles, scores, flairs, authors, comment counts, timestamps, outbound links, and more — ready for analysis, dashboards, or AI pipelines.

It is purpose-built to **scrape Reddit communities at scale**: give it dozens of subreddits at once and it works through them for you. There is **no API key to obtain, no login, no cookies or account required, and no rate-limit juggling** — the actor handles all of that internally and hands you a tidy dataset. This lets you **go beyond the limitations of the official Reddit API**, with **no limitations on requests or number of calls**, and collects only **publicly available data**.

This is the **V2** edition, tuned for stability and throughput. It reads from a fast, high-capacity data layer, so results can lag up to roughly 1.5 hours behind live Reddit. If you need up-to-the-second freshness, pair it with the real-time **[Reddit Scraper V2](https://apify.com/myagizm/reddit-scraper-v2)**.

> **Get your first results free in under 2 minutes** — paste a couple of subreddit names, press **Start**, and watch structured Reddit community data land in your dataset.

#### ✅ Scrape Reddit communities with no API key, no login, no setup

Skip Reddit's developer portal, OAuth apps, and rate-limit paperwork entirely. Paste subreddit names, press **Start**, and get structured results. The actor manages access, retries, and pacing for you — **no cookies or account required**.

#### 🗂️ Scrape many Reddit communities at once

Pass one subreddit or a hundred in a single run. The actor iterates through your list and returns a unified dataset, so you can compare communities side by side without stitching separate exports together. **Scrape Reddit communities at scale** with no per-call limits.

#### 💬 Rich per-post fields from every Reddit community

Every item includes the essentials you actually use: `title`, `score`, `upvoteRatio`, `numComments`, `author`, `flair`, `domain`, `outboundUrl`, `createdUtc`, and NSFW / spoiler / stickied flags — no scraping HTML yourself.

#### 📊 Analysis-ready structured JSON

Output is flat, predictable JSON with consistent field names and ISO-8601 timestamps (plus epoch seconds). Drop it straight into pandas, a data warehouse, a spreadsheet, or a BI tool with zero cleanup. **Export to JSON, CSV, Excel, or XML.**

#### 🔄 Reliable retries & polite pacing

Configurable retry attempts and a request delay keep runs stable and respectful. Transient hiccups are retried automatically so your dataset comes back complete.

#### ⚡ Fast, fresh data with hands-off runs

Fast response times deliver data in seconds. A single run lasts at most ~10 minutes and needs zero babysitting. Schedule it, trigger it from code, or call it from an AI agent — the results land in your dataset either way.

---

### Use with AI agents — Claude, ChatGPT & Cursor (MCP) {#use-with-ai-agents-mcp}

Reddit Community Scraper V2 works as a **tool for AI agents** through the [Apify MCP server](https://apify.com/apify/actors-mcp-server). Once connected, your assistant can call this actor autonomously — "scrape the latest posts from r/technology and r/science and summarize the themes" — and get back structured data it can reason over.

- **Claude** (Desktop, Code, or the API) — add the Apify MCP server and let Claude invoke the actor directly.
- **ChatGPT / Codex** — expose the actor as a callable tool in your agent stack.
- **Cursor** — pull Reddit community data into your coding workflow without leaving the editor.

Because results are clean JSON, they flow naturally into downstream automation platforms and MCP connectors: **Make, Zapier, n8n, Slack, Airbyte, Gumloop, CrewAI, IFTTT, Lindy, GitHub, Google Sheets, and Google Drive**. Chain the scraper into a workflow that posts trending threads to Slack, appends rows to a sheet, or files research into Notion — all without writing glue code.

---

### How to scrape Reddit communities {#how-to-scrape-reddit-communities}

You can scrape Reddit communities in six quick steps:

1. Open **[Reddit Community Scraper V2](https://apify.com/myagizm/reddit-community-scraper-v2)** on Apify.
2. In **Subreddits** (`communities`), add the community names you want, one per line — e.g. `technology`, `science`, `AskReddit`. The `r/` prefix is optional.
3. (Optional) Set **Max communities** (`maxItems`) to cap how many communities a single run processes.
4. (Optional) Tune **Max request retries** (`maxRetries`) and **Delay between requests** (`requestDelayMs`) under *Advanced*.
5. Click **Start**.
6. When the run finishes, open the **Dataset** tab and export to **JSON, CSV, Excel, or XML** — or fetch results via the API.

No credentials, no proxy configuration, no browser extensions — the actor handles everything for you.

---

### What data can I scrape from Reddit communities? {#what-data-can-i-scrape-from-reddit-communities}

Each dataset item represents one post collected from a community. Typical fields returned when you scrape Reddit communities:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique post identifier (e.g. `t3_1v0xg9z`). |
| `type` | string | Item type — `post`. |
| `title` | string | Post title. |
| `url` | string | Permalink to the post on Reddit. |
| `subreddit` | string | Community the post belongs to. |
| `author` | string | Username of the poster. |
| `score` | integer | Net upvotes at scrape time. |
| `upvoteRatio` | number | Fraction of votes that are upvotes (0–1). |
| `numComments` | integer | Number of comments on the post. |
| `flair` | string | Post flair / category label. |
| `domain` | string | Source domain for link posts. |
| `outboundUrl` | string | External link the post points to (if any). |
| `isSelf` | boolean | `true` for text (self) posts. |
| `selftext` | string | Body text for self posts. |
| `nsfw` | boolean | Whether the post is marked NSFW. |
| `spoiler` | boolean | Whether the post is flagged as a spoiler. |
| `stickied` | boolean | Whether the post is pinned in the community. |
| `archived` | boolean | Whether the post is archived. |
| `edited` | boolean | Whether the post was edited. |
| `gilded` | integer | Number of awards received. |
| `thumbnail` | string | Thumbnail image URL. |
| `createdUtc` | string | Post creation time (ISO-8601). |
| `createdUtcEpoch` | integer | Post creation time (Unix epoch seconds). |
| `scrapedAt` | string | When the item was collected (ISO-8601). |

> Field availability depends on the post. Link posts populate `domain` / `outboundUrl`; self posts populate `selftext`.

---

### Why scrape Reddit communities? Use cases

- **Trend & topic monitoring** — track what's rising across the communities in your niche.
- **Market & product research** — see what users discuss, praise, or complain about in relevant subreddits.
- **Content & social media ideas** — mine high-scoring titles and flairs for inspiration.
- **Brand & reputation tracking** — collect posts mentioning your product across multiple communities.
- **Academic & social research** — build datasets of community discourse at scale.
- **Lead generation & audience discovery** — find active authors and hot threads in target communities.
- **AI/RAG ingestion** — feed clean Reddit data into LLM pipelines, embeddings, and agents.
- **Competitor analysis & competition monitoring** — compare engagement across competing subreddits.

---

### Input examples — how to scrape Reddit communities

Below are ready-to-paste input examples using the **real** field names from the actor's input schema.

#### Scrape a few Reddit communities

```json
{
  "communities": ["technology", "science"]
}
````

#### Scrape many Reddit communities with a cap

```json
{
  "communities": [
    "technology",
    "science",
    "programming",
    "gadgets",
    "futurology"
  ],
  "maxItems": 25
}
```

#### Include NSFW / niche communities (r/ prefix optional)

```json
{
  "communities": ["r/AskReddit", "r/worldnews", "r/todayilearned"]
}
```

#### Tune reliability and pacing (Advanced)

```json
{
  "communities": ["technology", "science"],
  "maxItems": 50,
  "maxRetries": 5,
  "requestDelayMs": 500,
  "debug": false
}
```

#### Full input reference

| Field | Key | Type | Default | Notes |
|-------|-----|------|---------|-------|
| Subreddits | `communities` | array of strings | `["technology","science"]` | Community names to collect. `r/` prefix optional. |
| Max communities | `maxItems` | integer | `50` | 1–100. Caps communities processed per run. |
| Max request retries | `maxRetries` | integer | `3` | 0–6. Retry attempts per failed request. |
| Delay between requests (ms) | `requestDelayMs` | integer | `300` | 0–10000. Politeness delay between requests. |
| Debug logging | `debug` | boolean | `false` | Emit verbose logs for troubleshooting. |

***

### Limiting results when you scrape Reddit communities {#limits}

Use **`maxItems`** to control run size:

```json
{
  "communities": ["technology", "science", "programming"],
  "maxItems": 10
}
```

- `maxItems` accepts **1–100** and defaults to **50**.
- A single run lasts at most **~10 minutes**, and only one long-running job runs at a time.
- Keeping `maxItems` tight makes runs faster and cheaper — raise it when you need broader coverage.

***

### Output example {#output-example}

A single dataset item looks like this (real sample, trimmed):

```json
{
  "id": "t3_1v0xg9z",
  "url": "https://www.reddit.com/r/technology/comments/1v0xg9z/recent_patches_for_windows_11_could_have_been/",
  "nsfw": false,
  "type": "post",
  "flair": "Software",
  "score": 1,
  "title": "Recent patches for Windows 11 could have been created by Microsoft's new Mythos rival",
  "author": "kazu_qt",
  "domain": "neowin.net",
  "edited": false,
  "gilded": 0,
  "isSelf": false,
  "spoiler": false,
  "archived": false,
  "selftext": "",
  "stickied": false,
  "scrapedAt": "2026-07-19T18:12:06.652Z",
  "subreddit": "technology",
  "thumbnail": "https://external-preview.redd.it/msF-tG65CkyaHlMuDJNHs1xFJoZ_5mOYmfypnQy87b8.jpeg?width=140&height=78&auto=webp&s=5f98a6967ad1cfe919fd36d9985c66fbbc5c5287",
  "createdUtc": "2026-07-19T18:02:15.000Z",
  "sourceType": "reddit",
  "numComments": 0,
  "outboundUrl": "https://www.neowin.net/news/recent-patches-for-windows-11-could-have-been-created-by-microsofts-new-mythos-rival/",
  "upvoteRatio": 1,
  "createdUtcEpoch": 1784484135
}
```

***

### How much does it cost to scrape Reddit communities? {#how-much-does-it-cost-to-scrape-reddit-communities}

This actor uses a simple **pay-per-result** model — you pay for the data you actually collect, with no monthly minimums and no separate proxy or subscription fees. Because runs are efficient and capped at ~10 minutes, costs stay predictable, and keeping `maxItems` reasonable keeps each run lean.

New Apify accounts include free monthly platform credits, so you can **get your first results free in under 2 minutes** and trial the scraper at no cost. See the live pricing on the **[actor page](https://apify.com/myagizm/reddit-community-scraper-v2)**.

***

### Integrate with n8n, Zapier, and Make {#integrations}

Reddit Community Scraper V2 exposes a standard Apify API, so you can trigger it from any HTTP-capable tool — **n8n**, **Zapier**, **Make**, or your own backend — and integrate Reddit community data with other apps and AI workflows. The actor path is `myagizm~reddit-community-scraper-v2`.

#### Run synchronously and get results (short runs)

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~reddit-community-scraper-v2/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "communities": ["technology", "science"],
    "maxItems": 25
  }'
```

#### Start an async run

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~reddit-community-scraper-v2/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "communities": ["technology", "science"],
    "maxItems": 50
  }'
```

#### Fetch dataset items from a finished run

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&format=json"
```

You can also add the actor to a **schedule** in the Apify Console to run it hourly, daily, or on any cron you like — and route the output into Google Sheets, Airtable, Notion, or Slack via the connectors above, plus **webhooks** for event-driven pipelines.

***

### Support {#support}

Questions, feature requests, or a field you'd like added? Open an **Issue** on the actor's [Issues tab](https://apify.com/myagizm/reddit-community-scraper-v2/issues) in the Apify Console. Bug reports that include your input configuration get resolved fastest.

***

### FAQ — scraping Reddit communities {#faq}

#### Do I need a Reddit API key or account to scrape Reddit communities?

No. There is no API key, no login, and no OAuth setup — no cookies or account required. Enter subreddit names and run.

#### What exactly does this actor return?

Posts collected from the communities you list — titles, scores, upvote ratios, comment counts, authors, flairs, domains, outbound links, timestamps, and NSFW / spoiler / stickied flags.

#### Is it legal to scrape Reddit communities?

The actor collects only **publicly available data**. As with any scraping, you are responsible for how you use the data — respect Reddit's terms, applicable laws, and privacy rules such as **GDPR**, and avoid collecting personal data you don't have a lawful basis to process.

#### Can I use Reddit Community Scraper V2 with the Apify API?

Yes. Trigger runs and fetch datasets programmatically via the standard Apify API using the actor path `myagizm~reddit-community-scraper-v2`. See the snippets above.

#### Can I get Reddit community data through an MCP server?

Yes. Connect it through the [Apify MCP server](https://apify.com/apify/actors-mcp-server) so **Claude**, **ChatGPT / Codex**, and **Cursor** can call it as a tool.

#### Do I need proxies to scrape Reddit communities?

No. The actor handles access, pacing, and retries internally — nothing to set up.

#### Can I integrate Reddit community data with other apps?

Yes — route output into **Make, Zapier, n8n, Slack, Google Sheets, Google Drive, Airtable, Notion**, and more, or via webhooks and the API.

#### Can I export the data to CSV, Excel, or JSON?

Yes. Every dataset can be exported to **JSON, CSV, Excel, or XML** (plus RSS or via the API) from the Dataset tab.

#### Can I scrape multiple Reddit communities at once?

Yes. Scrape up to **100** communities per run via `maxItems` (default 50). Split very large lists across multiple runs or schedule them — there are no limitations on the number of calls.

#### Can I schedule the scraper?

Yes. Use the Apify **Schedules** feature to run the actor on any cron interval and push results to your tools automatically.

#### Can I scrape data from private communities?

No. The actor collects only public content. Private or quarantined communities that require a logged-in member are out of scope.

#### How fresh is the data?

This V2 actor reads from a high-capacity cached layer, so results may lag up to roughly **1.5 hours** behind live Reddit. For real-time data, use **[Reddit Scraper V2](https://apify.com/myagizm/reddit-scraper-v2)**.

#### Why did a community return fewer items than expected?

Small, quiet, or brand-new communities simply have less content, and the cached source may not reflect the very latest posts. Try again later or use the real-time actor.

#### What's the difference between V1 and V2?

V2 is tuned for stability and throughput and uses a cached source (slight lag). V1 targets real-time freshness. Choose based on whether latency or freshness matters more for your use case.

#### Does the r/ prefix matter?

No. `technology` and `r/technology` are treated the same.

#### Can I get NSFW communities?

Yes — NSFW posts are returned and flagged with the `nsfw` field so you can filter them downstream.

#### What if a request fails?

The actor retries automatically up to `maxRetries` times (default 3, max 6), so transient failures rarely affect your final dataset.

***

### Want other Reddit data? {#want-other-reddit-data}

Scraping Reddit communities is just the start. Explore the rest of the **Reddit V2** family by **myagizm** to scrape every corner of Reddit:

- **[Reddit Scraper V2](https://apify.com/myagizm/reddit-scraper-v2)** — real-time, all-in-one Reddit scraper for posts, comments, and subreddits.
- **[Reddit Subreddit Scraper V2](https://apify.com/myagizm/reddit-subreddit-scraper-v2)** — deep post extraction from individual subreddits.
- **[Reddit Comment Scraper V2](https://apify.com/myagizm/reddit-comment-scraper-v2)** — pull full comment threads from any post.
- **[Reddit Search Scraper V2](https://apify.com/myagizm/reddit-search-scraper-v2)** — scrape Reddit search results by keyword.
- **[Reddit Profile Scraper V2](https://apify.com/myagizm/reddit-profile-scraper-v2)** — collect a user's posts and activity.

***

### Related searches {#related-searches}

reddit community scraper · subreddit subscriber count · compare subreddit size · subreddit metadata api · reddit community directory · find biggest subreddits · subreddit nsfw check · reddit community research · subreddit stats export

***

### Disclaimer

This is an independent tool and is not affiliated with, endorsed by, or sponsored by Reddit. All product names, logos, and brands are property of their respective owners. This actor collects only publicly available data and is intended for lawful use in accordance with Reddit's terms and applicable regulations, including data-protection laws such as GDPR.

***

### Resources {#resources}

- **[Apify API documentation](https://docs.apify.com/api/v2)** — run actors and fetch datasets programmatically.
- **[Apify MCP server](https://apify.com/apify/actors-mcp-server)** — connect this actor to Claude, ChatGPT, and Cursor.
- **[Dataset export docs](https://docs.apify.com/platform/storage/dataset)** — export to JSON, CSV, Excel, and more.
- **[Apify Schedules](https://docs.apify.com/platform/schedules)** — automate recurring runs.
- **[Actor page](https://apify.com/myagizm/reddit-community-scraper-v2)** — input schema, pricing, and live runs.

***

## 中文说明 —— Reddit 社区信息抓取工具（V2）

> **V2 = 托管交付线。** 本 Actor 为 V2：运行在托管基础设施上，交付更稳定、字段更全。若只需要最低价的尽力而为版本，同一功能的 **V1** 版本也在 [商店主页](https://apify.com/myagizm)。

**免登录抓取 Reddit 公开数据** —— 抓取子版块的元数据：订阅人数、简介、图标、是否成人内容。不需要 Reddit API Key、不需要 OAuth 应用、不需要登录或 Cookie。结果可导出为 JSON、CSV、Excel、XML，也可通过 Apify API 定时运行并接入 n8n、Zapier、Make 等工具。

> **两分钟内免费拿到第一批数据** —— 填入内容、点击 Start 即可。无需配置，试用不需要信用卡。

### 能做什么

- 🏘️ **抓取子版块元数据**：名称、订阅人数、公开简介、图标、NSFW 标记。
- 📊 **对比多个社区规模**，一次运行多个版块。
- 🔍 **投放前先做社区体检**：规模、定位、内容分级。
- 📏 **`maxItems`** 控制数量。

### 谁在用

- 📣 **社区营销** —— 发帖前先确认版块规模与调性。
- 📊 **市场研究** —— 量化某个垂直领域的社区总量。
- 🧑‍💻 **数据团队** —— 建立社区目录用于后续抓取编排。
- 🛡️ **合规团队** —— 提前识别 NSFW 版块。

### 可以抓取哪些数据

| 字段 | 类型 | 说明 |
|------|------|------|
| `id` | string | 记录 ID（帖子如 `t3_...`，评论如 `t1_...`） |
| `type` | string | 记录类型（`post` / `comment` / `user` / `community`） |
| `title` | string | 帖子标题 |
| `url` | string | 永久链接 |
| `subreddit` | string | 所属子版块 |
| `author` | string | 作者用户名 |
| `score` | integer | 抓取时的净赞数 |
| `upvoteRatio` | number | 赞同比例（0–1） |
| `numComments` | integer | 评论数 |
| `flair` | string | 帖子 flair 标签 |
| `domain` | string | 来源域名（如 `self.AskReddit`、`i.redd.it`） |
| `outboundUrl` | string | 帖子指向的链接（外链帖为外部地址，自帖为永久链接） |
| `isSelf` | boolean | 是否为纯文本自帖 |
| `selftext` | string | 帖子正文（开启 *Include post text* 时返回） |
| `nsfw` | boolean | 是否标记为成人内容 |
| `spoiler` | boolean | 是否标记为剧透 |
| `stickied` | boolean | 是否在版块内置顶 |
| `archived` | boolean | 是否已归档 |
| `edited` | boolean | 是否被编辑过 |
| `gilded` | integer | 是否获得奖励 |
| `thumbnail` | string | 缩略图地址 |
| `createdUtc` | string | 创建时间（ISO 8601，UTC） |
| `createdUtcEpoch` | integer | 创建时间（Unix 时间戳） |
| `scrapedAt` | string | 该行的抓取时间（ISO 8601） |

> 字段取决于该条目公开了什么；不存在的值返回 `null`，数据结构保持稳定。

### 输入示例

```json
{
  "communities": ["technology", "science"]
}
```

### 输出示例

```json
{
  "id": "t3_1v0xg9z",
  "url": "https://www.reddit.com/r/technology/comments/1v0xg9z/recent_patches_for_windows_11_could_have_been/",
  "nsfw": false,
  "type": "post",
  "flair": "Software",
  "score": 1,
  "title": "Recent patches for Windows 11 could have been created by Microsoft's new Mythos rival",
  "author": "kazu_qt",
  "domain": "neowin.net",
  "edited": false,
  "gilded": 0,
  "isSelf": false,
  "spoiler": false,
  "archived": false,
  "selftext": "",
  "stickied": false,
  "scrapedAt": "2026-07-19T18:12:06.652Z",
  "subreddit": "technology",
  "thumbnail": "https://external-preview.redd.it/msF-tG65CkyaHlMuDJNHs1xFJoZ_5mOYmfypnQy87b8.jpeg?width=140&height=78&auto=webp&s=5f98a6967ad1cfe919fd36d9985c66fbbc5c5287",
  "createdUtc": "2026-07-19T18:02:15.000Z",
  "sourceType": "reddit",
  "numComments": 0,
  "outboundUrl": "https://www.neowin.net/news/recent-patches-for-windows-11-could-have-been-created-by-microsofts-new-mythos-rival/",
  "upvoteRatio": 1,
  "createdUtcEpoch": 1784484135
}
```

### 价格

采用**按结果计费**：只为真正拿到的数据付费，不按运行时间收费。

- 💸 成本 = 结果数量 × 单价，预算可提前算清。
- 📉 Apify 的 Bronze / Silver / Gold / Platinum / Diamond 套餐享阶梯折扣。
- 🆓 新账号自带每月免费额度，第一次运行不花钱。
- 🚫 无代理附加费、无单次请求费、无最低消费。

实时价格见 [Apify 商店页面](https://apify.com/myagizm/reddit-community-scraper-v2)。

### 使用建议

- 📊 **按 `subscribers` 排序**即可找到细分领域最大的社区。
- 🔞 用 `over18` 提前过滤掉不适合品牌的版块。
- 🗂️ 把社区列表作为其他 Reddit actor 的输入清单。
- ⏰ 定期快照即可跟踪社区增长。

### 其他 Reddit 数据

- 🤖 **[Reddit 综合抓取](https://apify.com/myagizm/reddit-scraper-v2)** —— 子版块 / 用户 / 社区 / 搜索四合一。
- 🔎 **[Reddit 搜索抓取](https://apify.com/myagizm/reddit-search-scraper-v2)** —— 全站或指定版块关键词搜索。
- 🏘️ **[子版块抓取](https://apify.com/myagizm/reddit-subreddit-scraper-v2)** —— 按版块抓帖子。
- 💬 **[评论抓取](https://apify.com/myagizm/reddit-comment-scraper-v2)** —— 可控深度的评论采集。
- 📇 **[社区信息抓取](https://apify.com/myagizm/reddit-community-scraper-v2)** —— 版块规模与简介。
- 👤 **[用户资料抓取](https://apify.com/myagizm/reddit-profile-scraper-v2)** —— karma、账号年龄、徽章。

其他平台同样采用免登录、按结果计费的方式：**[Instagram](https://apify.com/myagizm/instagram-profile-scraper-v2)** ·
**[TikTok](https://apify.com/myagizm/tiktok-profile-scraper-v2)** · **[X（推特）](https://apify.com/myagizm/x-tweets-scraper)** ·
**[LinkedIn](https://apify.com/myagizm/linkedin-profile-scraper)** · **[YouTube](https://apify.com/myagizm/youtube-channel-scraper)** ·
**[Google 地图](https://apify.com/myagizm/google-maps-scraper)**。完整工具家族见 **[myagizm 商店主页](https://apify.com/myagizm)**。

### 配合 AI 智能体使用（MCP）

本 Actor 已接入 **Apify MCP 服务器**，Claude、ChatGPT、Cursor 等助手可以把它当作工具直接调用，用自然语言提问即可拿到结构化结果，无需写胶水代码。

### 集成与 API

支持 **Make、Zapier、n8n、Slack、Airbyte、Gumloop、CrewAI、IFTTT、Lindy、GitHub、Google Sheets、Google Drive**，以及 Webhook、定时任务与 MCP 服务器。

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~reddit-community-scraper-v2/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "communities": ["technology", "science"]
}'
```

把 `format` 改成 `json`、`csv`、`xlsx` 或 `xml` 即可导出不同格式。

### 常见问题

**需要 Reddit API Key 或登录吗？**
不需要。没有 API Key、没有 OAuth 应用、不登录、不用 Cookie。

**抓取 Reddit 合法吗？**
只采集公开可见的数据，即任何未登录访客都能看到的内容。不登录、不访问私密版块或私信。合规责任由使用者承担：如涉及个人数据请遵守 GDPR / CCPA 与平台条款。

**能抓私密版块或已删除内容吗？**
不能，会被跳过并记录在运行日志中。

**需要配置代理吗？**
不需要，已内置托管。

**支持导出 CSV / Excel / JSON 吗？**
支持 JSON、CSV、Excel、XML。

**可以通过 Apify API 调用吗？**
可以，见上方示例。

**支持 AI 智能体（MCP）吗？**
支持，Claude、ChatGPT、Cursor 均可当作工具调用。

**可以定时运行吗？**
可以，支持 Apify Schedules、API 与 Webhook；按 `id` 去重即可实现增量采集。

**V1 和 V2 有什么区别？**
V1 轻量自包含、价格最低、尽力而为；V2 运行在托管基础设施上，交付更稳定、字段更全。两者输入基本一致，可以先用 V1 广筛、再用 V2 精查。

**数据有多新？**
不缓存，每次运行都读取当前公开页面。

### 免责声明

本工具为独立第三方工具，与 Reddit, Inc. 无任何隶属、认可或赞助关系，所有商标归各自所有者。

本 Actor 只采集**公开可见**的数据，不登录、不绕过访问控制、不获取私密内容。数据使用的合规责任由使用者承担。

### 相关搜索

reddit 社区信息抓取 · 子版块订阅数 · reddit 版块规模对比 · reddit 社区目录 · reddit 版块元数据 · 免登录抓取 reddit 社区

# Actor input Schema

## `communities` (type: `array`):

Subreddit names to fetch content and metadata for (subscribers, description, creation date, NSFW). The r/ prefix is optional. For example: \["technology", "science", "r/AskReddit"].

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

Maximum number of communities to fetch in one run. A run lasts at most ~10 minutes. For example: 25 to cap a large list.

## `maxRetries` (type: `integer`):

Retry attempts per failed request. For example: 5 for flakier networks, 0 to disable retries.

## `requestDelayMs` (type: `integer`):

Politeness delay between requests, in milliseconds. For example: 500 for a gentler pace, 0 for fastest throughput.

## `debug` (type: `boolean`):

Emit verbose logs to help troubleshoot a run. For example: true when a community returns fewer items than expected.

## Actor input object example

```json
{
  "communities": [
    "AskReddit",
    "worldnews"
  ],
  "maxItems": 50,
  "maxRetries": 3,
  "requestDelayMs": 300,
  "debug": false
}
```

# Actor output Schema

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

All scraped items as structured JSON.

# 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 = {
    "communities": [
        "technology",
        "science"
    ],
    "maxItems": 50,
    "maxRetries": 3,
    "requestDelayMs": 300,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("myagizm/reddit-community-scraper-v2").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 = {
    "communities": [
        "technology",
        "science",
    ],
    "maxItems": 50,
    "maxRetries": 3,
    "requestDelayMs": 300,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("myagizm/reddit-community-scraper-v2").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 '{
  "communities": [
    "technology",
    "science"
  ],
  "maxItems": 50,
  "maxRetries": 3,
  "requestDelayMs": 300,
  "debug": false
}' |
apify call myagizm/reddit-community-scraper-v2 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Community Scraper V2",
        "description": "Reddit Community Scraper V2 — cached data source (results may lag up to ~1.5h). Structured JSON, no login, no API key. For real-time data use the V1 actor.",
        "version": "0.1",
        "x-build-id": "d5se2hir4QbxwFljf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/myagizm~reddit-community-scraper-v2/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-myagizm-reddit-community-scraper-v2",
                "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/myagizm~reddit-community-scraper-v2/runs": {
            "post": {
                "operationId": "runs-sync-myagizm-reddit-community-scraper-v2",
                "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/myagizm~reddit-community-scraper-v2/run-sync": {
            "post": {
                "operationId": "run-sync-myagizm-reddit-community-scraper-v2",
                "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",
                "properties": {
                    "communities": {
                        "title": "🎯 Subreddits",
                        "type": "array",
                        "description": "Subreddit names to fetch content and metadata for (subscribers, description, creation date, NSFW). The r/ prefix is optional. For example: [\"technology\", \"science\", \"r/AskReddit\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "💯 Max communities",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of communities to fetch in one run. A run lasts at most ~10 minutes. For example: 25 to cap a large list.",
                        "default": 50
                    },
                    "maxRetries": {
                        "title": "🔁 Max request retries",
                        "minimum": 0,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Retry attempts per failed request. For example: 5 for flakier networks, 0 to disable retries.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "⏱️ Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Politeness delay between requests, in milliseconds. For example: 500 for a gentler pace, 0 for fastest throughput.",
                        "default": 300
                    },
                    "debug": {
                        "title": "🐞 Debug logging",
                        "type": "boolean",
                        "description": "Emit verbose logs to help troubleshoot a run. For example: true when a community returns fewer items than expected.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
