# Reddit Subreddit Posts Scrapers (`scrapers-hub/reddit-subreddit-posts-scrapers`) Actor

Reddit Subreddit Posts Scrapers exports posts and full comment trees across many subreddits at once, including body text, score, depth, parent ID and author metadata. 📊 Ideal for large-scale discourse and sentiment datasets.

- **URL**: https://apify.com/scrapers-hub/reddit-subreddit-posts-scrapers.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Subreddit Scraper – Posts, Comments & Engagement Data Extraction

The Reddit Subreddit Scraper pulls posts and comments from any subreddit into a structured dataset, complete with scores, upvote ratios, author metadata, flair, awards and timestamps. Point it at a single community or a list of hundreds, choose a sort order and a time window, and it returns the raw Reddit post objects — every field the platform exposes on a listing — ready for analysis.

Built for social listening, market research, sentiment analysis and content teams, this Reddit scraper handles the whole spectrum from a quick look at r/AskReddit to a bulk crawl driven by an uploaded CSV of communities. It supports all five Reddit feed orders — hot, new, top, rising and controversial — with a time filter for the ranked feeds, and it can optionally fetch the top comments beneath every post so you get the conversation, not just the headline.

***

### 📊 What Data Can You Extract with This Reddit Scraper?

Each post record mirrors Reddit's own listing object, so the field set is broad. It organises into seven practical groups.

| Category | Fields | What it tells you |
|---|---|---|
| 🆔 Post identity | `id`, `name`, `title`, `permalink`, `url`, `domain`, `subreddit`, `subreddit_id`, `subreddit_name_prefixed` | The post's identifiers, its headline, where it lives and what it links to |
| 📈 Engagement | `score`, `ups`, `downs`, `upvote_ratio`, `num_comments`, `num_crossposts`, `view_count`, `likes` | The full vote and discussion picture, including the ratio that reveals contested posts |
| 👤 Author | `author`, `author_fullname`, `author_premium`, `author_flair_text`, `author_flair_type`, `author_patreon_flair`, `author_is_blocked`, `is_submitter` | Who posted, their flair, and their account status within the community |
| 📝 Content | `selftext`, `selftext_html`, `body`, `thumbnail`, `media`, `media_embed`, `secure_media`, `is_video`, `is_self`, `is_original_content`, `media_only` | The text of the post or comment plus any attached media |
| 🏷️ Flair & classification | `link_flair_text`, `link_flair_richtext`, `link_flair_type`, `link_flair_background_color`, `link_flair_text_color`, `category`, `content_categories`, `discussion_type` | How the community categorises the post — often the fastest way to segment a subreddit |
| 🛡️ Moderation state | `stickied`, `pinned`, `locked`, `archived`, `over_18`, `spoiler`, `quarantine`, `hidden`, `removed_by_category`, `removal_reason`, `mod_reason_title`, `distinguished`, `contest_mode`, `is_robot_indexable` | Whether a post is promoted, restricted, removed or otherwise special |
| 🏅 Awards & timing | `all_awardings`, `total_awards_received`, `gilded`, `gildings`, `awarders`, `top_awarded_type`, `created`, `created_utc`, `edited` | Award activity and precise creation and edit timestamps |

The single most underrated field is `upvote_ratio`. Score alone conflates popularity with consensus — a post at +500 with a 0.55 ratio is a community argument, while +500 at 0.97 is settled agreement. For anyone doing sentiment or reputation work on Reddit data, that distinction changes the conclusion.

***

### 🌟 Key Features of the Reddit Subreddit Scraper

| Feature | Description |
|---|---|
| 📚 Bulk subreddit input | Scrape one community via `subreddit`, many via the `subreddits` array, or hundreds by uploading a .txt/.csv through `subredditsFile` |
| 🧾 Flexible file parsing | TXT files take one subreddit per line; CSV files auto-detect a `subreddit` column, so exports from other tools work as-is |
| 🔀 All five feed orders | `sort` covers hot, new, top, rising and controversial, matching every ranking Reddit itself offers |
| 🕰️ Time-windowed ranking | `timeFilter` narrows top and controversial feeds to the last hour, day, week, month, year or all time |
| 💬 Optional comment fetching | `includeComments` adds the top comments beneath each post, returned as their own records with a `_post_id` linking them back |
| 🎚️ Comment depth control | `maxCommentsPerPost` caps comment volume per post, using a single fast request for up to 500 and two for 501–1000 |
| 🧮 Volume control | `maxPostsPerSubreddit` limits how many posts each community contributes, with Reddit's own ceiling of roughly 1,000 per feed |
| 📦 Complete raw objects | Posts arrive with Reddit's full field set rather than a trimmed subset, so nothing is lost before you decide what matters |
| 🛡️ Automatic proxy rotation | Requests are routed through rotating proxies automatically, with no proxy configuration required from you |

***

### 🚀 Why Choose This Reddit Scraper?

**No API credentials, no OAuth app.** Reddit's official API requires registering an application, managing tokens and living inside a rate-limit budget. This Reddit scraper reads public listings directly, so you go from a subreddit name to a dataset without any developer onboarding.

**Bulk input that matches how research actually works.** Most social listening projects begin with a list of communities in a spreadsheet, not one name. Between the `subreddits` array and `subredditsFile` upload, you can hand the scraper a CSV of several hundred subreddits and let it work through them.

**Posts and comments in one run.** Turning on `includeComments` returns comment records alongside posts, each carrying `_post_id`, `parent_id` and `depth`. That means you can reconstruct entire threads and analyse replies in context rather than as detached snippets.

**The complete Reddit object, not a summary.** Fields like `upvote_ratio`, `link_flair_text`, `total_awards_received`, `removed_by_category` and `is_original_content` all survive into the dataset. Analyses that would be impossible with a five-field export — flair-based segmentation, moderation studies, award economics — are straightforward here.

***

### 📥 Input

```json
{
  "subreddit": "AskReddit",
  "maxPostsPerSubreddit": 100,
  "subreddits": ["dataisbeautiful", "webdev"],
  "sort": "hot",
  "timeFilter": "all",
  "includeComments": false,
  "maxCommentsPerPost": 1000
}
```

#### 🔧 Reddit Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `subreddit` | string | No | — | A single subreddit name or URL. |
| `maxPostsPerSubreddit` | integer | No | `100` | Maximum number of posts to scrape per subreddit (Reddit limits to ~1,000). |
| `subreddits` | array | No | `[]` | Add multiple subreddit names or URLs. Use 'Bulk edit' to paste a list, or upload a .txt/.csv file. Any format accepted. |
| `subredditsFile` | string | No | — | Upload a .txt or .csv file, or paste a URL. TXT: one subreddit per line. CSV: auto-detects 'subreddit' column. |
| `sort` | string | No | `hot` | How to sort posts in the feed. One of `hot`, `new`, `top`, `rising`, `controversial`. |
| `timeFilter` | string | No | `all` | Time range for 'top' and 'controversial' sort orders. Ignored for other sorts. One of `hour`, `day`, `week`, `month`, `year`, `all`. |
| `includeComments` | boolean | No | `false` | Fetch top comments for each post. Charged at $0.001 per comment. |
| `maxCommentsPerPost` | integer | No | `1000` | Maximum comments to fetch per post when comments are enabled. Uses a single fast request for up to 500, two requests for 501-1000. |

#### 💡 Input Examples

**Top posts of the week from one community**

```json
{
  "subreddit": "dataisbeautiful",
  "sort": "top",
  "timeFilter": "week",
  "maxPostsPerSubreddit": 200
}
```

**Multi-subreddit monitoring of new posts**

```json
{
  "subreddits": ["webdev", "javascript", "reactjs", "node"],
  "sort": "new",
  "maxPostsPerSubreddit": 50
}
```

**Posts with their comment threads**

```json
{
  "subreddit": "AskReddit",
  "sort": "hot",
  "maxPostsPerSubreddit": 25,
  "includeComments": true,
  "maxCommentsPerPost": 300
}
```

***

### 📤 Output

```json
{
  "approved_at_utc": null,
  "subreddit": "AskReddit",
  "selftext": "",
  "author_fullname": "t2_sz6c2b129",
  "location_lat": null,
  "saved": false,
  "mod_reason_title": null,
  "gilded": 0,
  "clicked": false,
  "title": "If it weren't for modern medicine, how would you have died?",
  "link_flair_richtext": [],
  "subreddit_name_prefixed": "r/AskReddit",
  "hidden": false,
  "pwls": 6,
  "link_flair_css_class": null,
  "downs": 0,
  "top_awarded_type": null,
  "hide_score": false,
  "name": "t3_1vkycb2",
  "quarantine": false,
  "link_flair_text_color": "dark",
  "upvote_ratio": 1
}
```

#### 🧾 Reddit Post Output Fields

| Field | Type | Description |
|---|---|---|
| `id` | string | null | Unique identifier of the item. |
| `name` | string | null | Name of the item (Reddit fullname, e.g. `t3_…`). |
| `title` | string | null | Title of the item. |
| `author` | string | null | Author of the item. |
| `author_fullname` | string | null | Name of the author fullname. |
| `subreddit` | string | null | Subreddit the item belongs to. |
| `subreddit_id` | string | null | Identifier of the subreddit. |
| `subreddit_name_prefixed` | string | null | Subreddit name prefixed of the item. |
| `subreddit_subscribers` | integer | null | Subreddit subscribers of the item. |
| `subreddit_type` | string | null | Subreddit type of the item. |
| `selftext` | string | null | Text of the selftext. |
| `selftext_html` | string | null | Selftext HTML of the item. |
| `score` | integer | null | Score assigned to the item. |
| `ups` | integer | null | Number of upvotes. |
| `downs` | integer | null | Number of downvotes. |
| `upvote_ratio` | integer | null | Upvote ratio of the item. |
| `num_comments` | integer | null | Num comments of the item. |
| `num_crossposts` | integer | null | Num crossposts of the item. |
| `view_count` | integer | null | Number of views. |
| `permalink` | string | null | Permanent link to the item. |
| `url` | string | null | Canonical URL of the scraped item. |
| `domain` | string | null | Domain name of the item. |
| `thumbnail` | string | null | Thumbnail image URL. |
| `media`, `media_embed`, `secure_media`, `secure_media_embed` | object | null | Media attached to or embedded in the post. |
| `is_video`, `is_self`, `is_original_content`, `media_only`, `is_reddit_media_domain`, `is_meta` | boolean | null | Content type flags. |
| `link_flair_text`, `link_flair_richtext`, `link_flair_type`, `link_flair_css_class`, `link_flair_background_color`, `link_flair_text_color` | mixed | Post flair and its styling. |
| `author_flair_text`, `author_flair_richtext`, `author_flair_type`, `author_flair_css_class`, `author_flair_background_color`, `author_flair_text_color`, `author_flair_template_id` | mixed | Author flair and its styling. |
| `author_premium`, `author_patreon_flair`, `author_is_blocked`, `is_submitter` | boolean | null | Author account attributes. |
| `all_awardings`, `awarders`, `gildings`, `gilded`, `total_awards_received`, `top_awarded_type` | mixed | Award activity on the post. |
| `stickied`, `pinned`, `locked`, `archived`, `hidden`, `saved`, `clicked`, `visited`, `spoiler`, `over_18`, `quarantine`, `contest_mode`, `hide_score`, `send_replies`, `no_follow`, `is_crosspostable`, `can_gild`, `can_mod_post`, `allow_live_comments`, `is_robot_indexable`, `is_created_from_ads_ui` | boolean | null | State and permission flags. |
| `removed_by`, `removed_by_category`, `removal_reason`, `banned_by`, `banned_at_utc`, `approved_by`, `approved_at_utc`, `mod_note`, `mod_reason_by`, `mod_reason_title`, `mod_reports`, `user_reports`, `num_reports`, `report_reasons`, `distinguished` | mixed | Moderation and reporting state. |
| `category`, `content_categories`, `discussion_type`, `suggested_sort`, `treatment_tags`, `pwls`, `wls` | mixed | Classification and ranking metadata. |
| `location_name`, `location_lat`, `location_long` | mixed | Location metadata, where Reddit supplies it. |
| `created`, `created_utc`, `edited` | mixed | Creation and edit timestamps. |
| `websocket_url`, `likes` | mixed | Live-update endpoint and viewer vote state. |

#### 🧾 Reddit Comment Output Fields

When `includeComments` is enabled, comment records are pushed alongside posts. They carry their own shape:

| Field | Type | Description |
|---|---|---|
| `_type` | string | null | Type of the item — distinguishes comments from posts. |
| `_post_id` | string | null | Identifier of the post the comment belongs to. |
| `_subreddit` | string | null | Subreddit the item belongs to. |
| `_status` | string | null | Status of the item. |
| `body` | string | null | Body text of the item. |
| `author` | string | null | Author of the item. |
| `authorId` | string | null | Identifier of the author. |
| `authorAccountType` | string | null | Author account type of the item. |
| `authorIsCakeDay` | boolean | null | Whether author is cake day. |
| `authorIcon`, `authorFlair` | mixed | Author avatar and flair. |
| `score` | integer | null | Score assigned to the item. |
| `depth` | integer | null | Depth of the item within the thread. |
| `parent_id` / `parentId` | string | null | Identifier of the parent comment or post. |
| `childCount` | integer | null | Number of child comments. |
| `createdAt`, `editedAt`, `created_utc` | mixed | Comment timestamps. |
| `isStickied`, `isLocked`, `isScoreHidden`, `isDeleted`, `isArchived`, `isRemoved`, `isInitiallyCollapsed`, `isCommercialCommunication` | boolean | null | Comment state flags. |
| `distinguishedAs`, `removedByCategory` | mixed | Moderation markers. |
| `languageCode`, `contentTypeHint` | string | null | Detected language and content type hint. |

***

### 💻 How to Use the Reddit Subreddit Scraper (Step by Step)

#### Step 1: Choose how to supply your subreddits

There are three routes into the scraper and they can be combined. Use `subreddit` for a single community — a bare name like `AskReddit` or a full URL both work. Use the `subreddits` array when you have a handful, pasting them through the Bulk edit view. For anything larger, `subredditsFile` accepts an uploaded .txt or .csv, or a URL pointing at one; TXT files take one community per line and CSV files auto-detect a `subreddit` column, so exports from other research tools usually need no reformatting at all.

#### Step 2: Pick a sort order that matches your question

`sort` fundamentally changes what you get back. Use `new` for monitoring — it gives you a chronological stream and is the right choice for brand mentions or issue tracking. Use `top` for research into what a community values most. `hot` is Reddit's blended relevance ranking and gives a good sense of current attention. `rising` surfaces posts gaining traction quickly, which is what you want for trend spotting. `controversial` finds the posts where voting is genuinely split.

#### Step 3: Set the time window

`timeFilter` applies only to `top` and `controversial`, and it is ignored for the other sorts. The default of `all` gives you the highest-scoring posts in a subreddit's entire history — excellent for understanding a community's canon, but useless for tracking current sentiment. For anything time-sensitive, set `week` or `month`. Combining `top` with `day` is a reliable pattern for daily digest workflows.

#### Step 4: Control post volume

`maxPostsPerSubreddit` defaults to 100 and caps how much each community contributes. Reddit itself limits a single feed to roughly 1,000 posts, so that is the practical ceiling regardless of what you request. When crawling many subreddits, a lower per-subreddit cap gives you broader coverage for the same total volume — usually more useful than exhausting one community.

#### Step 5: Decide whether you need comments

Leave `includeComments` off when you only need post-level metrics; it keeps runs fast and datasets small. Turn it on when the analysis depends on what people actually said — sentiment work, question mining, support-issue discovery. `maxCommentsPerPost` then controls depth. The description notes that up to 500 comments uses a single fast request while 501–1000 uses two, so 500 is a natural efficiency boundary if you are tuning for speed.

#### Step 6: Run and inspect a sample

Start the actor and open the Dataset tab as results arrive. Check a few rows for the fields your analysis depends on: is `selftext` populated, or is the subreddit mostly link posts? Is `link_flair_text` in use, which would give you free segmentation? Is `upvote_ratio` varying meaningfully? A quick look at 25 rows tells you whether the run configuration is right before you scale up.

#### Step 7: Separate posts from comments and export

If comments are enabled, split the dataset on `_type` before analysis — posts and comments have different shapes and should live in different tables. Join comments back to posts on `_post_id`, and use `parent_id` with `depth` to rebuild reply trees. Export as CSV, JSON or XLSX, or schedule the run and pipe finished datasets into your warehouse via webhook.

***

### 🔌 API Access & Integrations

Run the Reddit scraper and get dataset items back in the same request:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~reddit-subreddit-posts-scrapers/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "subreddit": "AskReddit",
    "sort": "top",
    "timeFilter": "week",
    "maxPostsPerSubreddit": 50
  }'
```

The same run in Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/reddit-subreddit-posts-scrapers").call(run_input={
    "subreddits": ["webdev", "javascript", "reactjs"],
    "sort": "new",
    "maxPostsPerSubreddit": 100,
    "includeComments": True,
    "maxCommentsPerPost": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("_type"):
        print("comment:", item["author"], item["score"])
    else:
        print("post:", item["title"], item["score"], item["upvote_ratio"])
```

Finished datasets connect to Zapier, Make, Google Sheets and Slack, and Apify webhooks can notify your own service the moment a Reddit scraping run completes.

***

### 💡 Best Use Cases for Reddit Data

#### 🗣️ Brand and product social listening

Monitor the subreddits where your category is discussed using `sort` set to `new`, then search `title` and `selftext` for your brand and competitor names. `score`, `num_comments` and `upvote_ratio` tell you whether a mention is a passing remark or a thread the community rallied around, which is what determines whether it needs a response.

#### 📉 Sentiment and opinion analysis

Enable comments and run sentiment models over the `body` field, weighting each comment by `score` so that community-endorsed opinions count more than lone replies. `depth` lets you distinguish top-level reactions from deep argument threads, which usually carry very different tone.

#### 🔥 Trend detection and content ideation

`rising` combined with a short `timeFilter` surfaces posts accelerating right now. Tracking which `link_flair_text` categories dominate rising posts over time is a reliable early signal of shifting community interest, and `num_crossposts` shows which ideas are spreading beyond their home subreddit.

#### 🧪 Academic and market research

The raw Reddit object supports serious quantitative work: `created_utc` for time series, `upvote_ratio` for consensus measurement, `total_awards_received` and `gilded` for studying award economics, and `removed_by_category` plus `distinguished` for moderation research. Bulk subreddit input via `subredditsFile` makes large comparative studies practical.

#### 🎯 Audience and community intelligence

`subreddit_subscribers`, `author_flair_text` and `author_premium` describe who a community is made of. Comparing posting patterns across dozens of subreddits, pulled in one run from a CSV, quickly shows where your target audience is genuinely active rather than merely present.

#### 🛠️ Customer support and pain-point mining

Software and hardware subreddits are full of unfiltered problem reports. Filter posts where `num_comments` is high relative to `score` — a signal of unresolved discussion — then read the comment `body` text to extract recurring complaints, feature requests and workarounds your own support tickets never surface.

#### 📰 Newsroom and editorial monitoring

Journalists use `top` with `timeFilter` set to `day` across a watchlist of subreddits to see what a community is talking about right now. `permalink` and `url` give citable links, `author` provides an attribution starting point, and `over_18`, `spoiler` and `quarantine` flag content that needs editorial care.

***

### ⚙️ Tips for Better Reddit Scraping Results

- **Remember the ~1,000 post ceiling.** Reddit caps how deep a single feed goes, so requesting more from one subreddit will not help. Use several sort orders or time windows to reach different slices of the same community instead.
- **Set `timeFilter` deliberately.** It is silently ignored for `hot`, `new` and `rising`, which surprises people who set it and see no change. It only bites on `top` and `controversial`.
- **Use flair as a free classifier.** In well-moderated subreddits `link_flair_text` is a hand-curated category label. Grouping by it is faster and often more accurate than running your own topic model.
- **Cap comments before scaling up.** Comment volume grows much faster than post volume. Test with `maxCommentsPerPost` at 100 to gauge dataset size before committing to a large multi-subreddit run.
- **Deduplicate on `id`, not `title`.** Crossposts and recurring weekly threads share titles across communities; the post `id` is the only reliable unique key.
- **Schedule `new` runs for monitoring.** A frequent run against the `new` feed catches posts before they are deleted or removed, which a weekly `top` run would miss entirely.

***

### 🛠️ Troubleshooting

**Why did my Reddit scraper run return no posts?**
Check the subreddit name first — private, banned and quarantined communities return nothing publicly. Also confirm the combination of `sort` and `timeFilter` actually has results; `top` with `timeFilter` set to `hour` in a quiet subreddit can legitimately be empty.

**I set `timeFilter` but the results did not change.**
`timeFilter` applies only to `top` and `controversial`. With `hot`, `new` or `rising` it is ignored by design, because those feeds are not ranked over a time window.

**Why do I get fewer posts than `maxPostsPerSubreddit`?**
Reddit limits a feed to roughly 1,000 posts and many subreddits simply do not have that many in the selected window. Smaller or newer communities will return everything they have and stop.

**Comments are missing even though `includeComments` is on.**
Posts with no replies produce no comment records, and locked, archived or heavily moderated threads may expose very few. Check `num_comments` on the parent post: if it is zero, there is nothing to fetch.

**Some fields are null on every row.**
Reddit populates its listing object inconsistently. Fields such as `view_count`, `likes`, `banned_by` and `approved_by` are typically null for anonymous public reads, since they only carry values in an authenticated moderator context. Build your pipeline to tolerate nulls throughout.

***

### ❓ Frequently Asked Questions About Reddit Scraping

**Is scraping Reddit legal?**
This Reddit scraper reads only publicly visible subreddit listings — no login, no private communities, no direct messages. Collecting public data is broadly permissible in many jurisdictions, but you remain responsible for complying with Reddit's Terms of Service, the User Agreement and any laws that apply to your use of the data.

**Do I need Reddit API credentials?**
No. The actor works from public Reddit endpoints, so there is no OAuth application to register, no client secret to manage and no developer rate-limit quota tied to your account.

**How many posts can I scrape from a subreddit?**
Up to roughly 1,000 per feed, which is Reddit's own ceiling. `maxPostsPerSubreddit` defaults to 100 and lets you request less. To get more from a single community, run several jobs with different `sort` and `timeFilter` combinations.

**Can I scrape multiple subreddits at once?**
Yes. Use the `subreddits` array for a handful, or upload a .txt or .csv through `subredditsFile` for large lists. CSV files auto-detect a `subreddit` column, and TXT files take one name per line.

**Does the Reddit scraper collect comments?**
Yes, when `includeComments` is enabled. Comments come back as separate records identified by `_type`, linked to their post via `_post_id`, with `parent_id` and `depth` available for rebuilding the thread structure.

**How many comments does it fetch per post?**
Up to `maxCommentsPerPost`, which defaults to 1000. The description notes that up to 500 comments is handled by a single fast request and 501–1000 uses two requests.

**What is the difference between `score` and `ups`?**
`score` is the net figure Reddit displays. `ups` and `downs` are the underlying vote components, though Reddit fuzzes these publicly. For measuring agreement rather than raw popularity, `upvote_ratio` is the more informative field.

**Can I scrape a subreddit by URL instead of by name?**
Yes. Both `subreddit` and the entries in `subreddits` accept a name or a full URL, and the actor normalises either form.

**Which sort order should I use for monitoring?**
`new`. It returns posts chronologically, so a scheduled run captures everything published since the last one. `hot` and `top` re-rank continuously and will show you the same high performers repeatedly.

**How do I get posts from the last week only?**
Set `sort` to `top` or `controversial` and `timeFilter` to `week`. For chronological coverage of the same period, use `sort` set to `new` and filter on `created_utc` after the run.

**Can I scrape NSFW or private subreddits?**
NSFW posts are returned and flagged via `over_18`, so you can filter them in or out. Private and banned subreddits are not publicly accessible and cannot be scraped.

**Why is `view_count` null?**
Reddit only exposes view counts to moderators of the community in question. For anonymous public reads it is null, along with several other moderator-only fields.

**Can I export Reddit data to Excel or Google Sheets?**
Yes. Apify datasets export to CSV, XLSX, JSON and XML from the Console, and the dataset API can be read straight into Google Sheets or any BI tool that consumes CSV or JSON over HTTP.

**How do I rebuild a comment thread from the dataset?**
Filter to comment records, group by `_post_id`, then link each comment to its parent using `parent_id`. `depth` gives you the nesting level directly, and `childCount` tells you how many replies a comment received.

**How often should I run the Reddit scraper?**
For active monitoring of fast-moving subreddits, hourly or a few times a day against the `new` feed. For trend research and reporting, a daily `top` run with `timeFilter` set to `day` is usually the right cadence.

***

### 🆘 Support & Feedback

If the Reddit scraper misbehaves — a field stops populating, a subreddit fails to resolve, a file upload is not parsed as expected — report it on the actor's **Issues** tab so it can be reproduced and fixed.

Need a custom build? Different output shaping, user-profile crawling, search-based collection, or a schema tailored to your analytics stack — email **scraperhubapi@gmail.com** and describe what you are trying to achieve.

If this Reddit scraper is useful in your research or monitoring work, a rating and a short review on the actor page helps other teams discover it and guides which improvements get built next.

***

### ⚖️ Disclaimer

This Reddit scraper collects only publicly available content from public subreddit listings. It does not log into accounts, access private communities, read direct messages or bypass any authentication.

You are responsible for how the collected data is used, including compliance with Reddit's User Agreement and Terms of Service, applicable copyright in user-generated content, and any research-ethics requirements that apply to your institution or organisation.

Reddit posts and comments are written by identifiable individuals and pseudonymous usernames can constitute personal data. If you process fields such as `author`, `author_fullname`, `body` or `selftext`, you act as a data controller under the GDPR, the UK GDPR, the CCPA or the equivalent regime where you operate. That means establishing a lawful basis, minimising what you retain, aggregating or pseudonymising wherever the analysis allows, and honouring deletion requests. Content removed by a user or a moderator after collection should be removed from your own copies too.

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Reddit, Inc. To request removal of data collected through this actor, contact **scraperhubapi@gmail.com** with the relevant details and the request will be actioned promptly.

# Actor input Schema

## `subreddit` (type: `string`):

A single subreddit name or URL.

## `maxPostsPerSubreddit` (type: `integer`):

Maximum number of posts to scrape per subreddit (Reddit limits to ~1,000).

## `subreddits` (type: `array`):

Add multiple subreddit names or URLs. Use 'Bulk edit' to paste a list, or upload a .txt/.csv file. Any format accepted.

## `subredditsFile` (type: `string`):

Upload a .txt or .csv file, or paste a URL. TXT: one subreddit per line. CSV: auto-detects 'subreddit' column.

## `sort` (type: `string`):

How to sort posts in the feed.

## `timeFilter` (type: `string`):

Time range for 'top' and 'controversial' sort orders. Ignored for other sorts.

## `includeComments` (type: `boolean`):

Fetch top comments for each post. Charged at $0.001 per comment.

## `maxCommentsPerPost` (type: `integer`):

Maximum comments to fetch per post when comments are enabled. Uses a single fast request for up to 500, two requests for 501-1000.

## Actor input object example

```json
{
  "maxPostsPerSubreddit": 100,
  "subreddits": [],
  "sort": "hot",
  "timeFilter": "all",
  "includeComments": false,
  "maxCommentsPerPost": 1000
}
```

# Actor output Schema

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

Records scraped by Reddit Subreddit Posts Scrapers, stored in the run's default dataset.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/reddit-subreddit-posts-scrapers").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/reddit-subreddit-posts-scrapers").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 '{}' |
apify call scrapers-hub/reddit-subreddit-posts-scrapers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/reddit-subreddit-posts-scrapers"
        }
    }
}

```

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/34Na1oDltQ7jqP0T5/builds/aGXnODCd5bBC9datT/openapi.json