# Reddit Scraper: Posts, Comments, Users, Search & Explore (`nextgensda/reddit-scraper`) Actor

Scrape Reddit posts, full comment threads, users, communities and comment search by keyword, plus the Explore tab's recommended communities. API-grade JSON with no login or browser, unaffected by Reddit's 2026 .json shutdown. Monitor brands and keywords with only-new runs.

- **URL**: https://apify.com/nextgensda/reddit-scraper.md
- **Developed by:** [Tauqeer Abbas](https://apify.com/nextgensda) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Reddit Scraper: Posts, Comments, Users, Search & Explore

![Reddit Scraper: posts, full comment threads, users and communities, comment search and Explore, with pay-per-event pricing shown as a receipt](https://api.apify.com/v2/key-value-stores/ZDBeMq7mdHf129rBl/records/banner-2026-10-20.png?signature=OCaFjIFUFn93Yk8yz7qX)

Scrape [Reddit](https://www.reddit.com/) posts, full comment threads, user
profiles and histories, communities and their rules, and **search comments
by keyword**, plus the communities Reddit's **Explore** tab recommends.
Clean JSON straight from Reddit's API, with no login, no API key and no
browser.

**Still works after Reddit's 2026 shutdown.** In May 2026 Reddit closed
its public `.json` endpoints to anonymous requests (they now answer 403
whatever the IP). This actor doesn't use them: it reads Reddit's
authenticated API the way Reddit's own app does. You get the same
structured data, with exact scores, upvote ratios, flairs, media and
comment trees, and no fragile page parsing.

### What it scrapes

| Source | Rows |
|---|---|
| **Subreddits** (hot, new, top, rising, controversial; any time range), `r/popular`, `r/all`, the front page | posts, optionally with their comments and the subreddit's info and rules |
| **Posts** (any post URL) | the post and its comment thread: text, score, depth and parent of every comment |
| **Users** | profile (karma, account age, verified, moderator), posts and comments |
| **Search** by keyword, site-wide or inside one subreddit | posts, **comments** (full text, with the post and subreddit), communities or users |
| **Explore** | the communities Reddit recommends (popular near you, hidden gems, topic picks) with subscribers and rules |

Paste any Reddit URL (subreddit, post, user, search, `/explore/`) or use
the name and keyword fields. Mix as many sources as you like in one run.

### Why this one

- **Comment search with full text.** Find every comment that mentions your
  brand, product or competitor. Each row has the comment's full text, author,
  score and date, plus the post's title, score and comment count.
- **Deeper comment threads.** Reddit shows logged-out readers 500 comments
  of a thread at a time. Above that, this actor merges several comment
  orders (top, new, controversial, old) and reaches about 3 times more of
  a big thread (1,605 of a 5,050-comment thread instead of 499).
- **Real monitoring.** Turn on *Only new rows* and schedule the run: each run
  delivers only the posts and comments the earlier runs didn't, and you
  never pay twice for the same row. Monitors are remembered for 60 days,
  and you can keep one per brand.
- **No duplicates in a run.** A post found by two searches is delivered and
  charged once.
- **Built for Reddit's rate limit.** Reddit allows each IP 100 requests per
  10 minutes. The actor switches to a fresh IP before that runs out, so it
  doesn't stall or fail on 429 errors.
- **Light and cheap.** Pure HTTP at 256 MB, on datacenter proxies by
  default. If Reddit refuses them, the run moves to residential by itself.
- **Explore**, the recommended communities, which no other Reddit actor
  offers.

### Input examples

**A subreddit's top posts of the week, with comments:**

```json
{
    "startUrls": [{ "url": "https://www.reddit.com/r/technology/top/?t=week" }],
    "includeComments": true,
    "maxCommentsPerPost": 50,
    "maxItemsPerSource": 25
}
```

**Monitor a brand: new comments and posts every day:**

```json
{
    "searches": ["your brand", "yourbrand.com"],
    "searchFor": ["comments", "posts"],
    "searchSort": "new",
    "postedAfter": "1 day",
    "commentedAfter": "1 day",
    "onlyNew": true,
    "monitorName": "your-brand"
}
```

**Every comment of a big thread (up to 2,000):**

```json
{
    "startUrls": [{ "url": "https://www.reddit.com/r/AskReddit/comments/1x7uu01/" }],
    "maxCommentsPerPost": 2000
}
```

**Users' recent comments:**

```json
{
    "users": ["spez", "kn0thing"],
    "userContent": "comments",
    "sort": "new",
    "maxItemsPerSource": 200
}
```

**Communities about a topic, with their rules:**

```json
{
    "searches": ["espresso"],
    "searchFor": ["communities"],
    "includeRules": true
}
```

### Output

One row per post, comment, community or user. The `dataType` field says
which. Every row also carries `source` (what found it), `sourceUrl`,
`created_at` (ISO date) and `scrapedAt`.

**Post** (`dataType: "post"`, 45 fields):

| Field | Example |
|---|---|
| `title`, `selftext` | the post's title and body |
| `subreddit`, `author` | espresso, KiloBrewer |
| `score`, `upvote_ratio`, `num_comments` | 1202, 0.78, 386 |
| `permalink`, `url` | the Reddit link and the linked page / image / video |
| `flair`, `flair_background_color` | "\[SUNDAY ONLY] Self-Promotion", #014980 |
| `post_hint`, `is_video`, `is_gallery`, `media`, `preview`, `gallery` | media details and image URLs |
| `over_18`, `spoiler`, `stickied`, `locked`, `archived`, `edited` | flags |
| `created_utc`, `created_at` | 1792368908, 2026-10-17T22:15:08+00:00 |

**Comment** (`dataType: "comment"`, 34 fields): `body`, `author`, `score`,
`depth`, `parent_id`, `post_id`, `post_title`, `post_permalink`,
`subreddit`, `is_submitter` (the post's author), `controversiality`,
`edited`, `distinguished`, `permalink`, `created_at`. Comment search rows
add `post_score` and `post_num_comments`.

**Community** (`dataType: "community"`): `name`, `title`, `subscribers`,
`public_description`, `description`, `subreddit_type`, `over18`,
`created_utc`, `icon`, `banner`, `url`, and `rules` (name, description,
kind) when *Include community rules* is on.

**User** (`dataType: "user"`): `name`, `link_karma`, `comment_karma`,
`total_karma`, `created_utc`, `verified`, `is_mod`, `is_employee`,
`is_gold`, `is_suspended`, `description`, `icon`, `url`.

### Pricing

Pay per row: platform usage is included, so you never pay Apify compute or
proxy traffic on top.

| Event | Price |
|---|---|
| Run start | $0.001 |
| `post` | $1.00 / 1,000 |
| `comment` | $0.40 / 1,000 |
| `community` | $1.00 / 1,000 |
| `user` | $1.00 / 1,000 |

**Example:** 100 posts with 50 comments each = $0.001 + 100 × $0.001 +
5,000 × $0.0004 = **$2.10** for 5,100 rows.

Duplicates, filtered rows and rows a monitor already delivered are never
charged. Your **spending limit** is always respected: the actor stops
before exceeding it.

### Good to know

- **About 1,000 per listing.** Reddit ends every listing and search at
  roughly 1,000 results. For more, combine sorts (`new`, `top` by time
  range) or keywords.
- **NSFW, private and quarantined communities** aren't readable without a
  Reddit account. They're skipped with a note in the log and aren't charged.
- **Comment search** reads about 10 comments per page, so it's slower per
  row than post search. Use the *New* sort with *Comments after* for
  monitoring: the search stops at the first older comment.
- **Deleted content** shows as `[deleted]` / `[removed]`, as on Reddit.
  `removed_by_category` says who removed a post.
- **Dates:** *Posted after* and the other date filters take a date
  (`2026-10-01`) or a relative time (`7 days`, `24 hours`, `1 month`).

### Use it from your tools

Run it from the Apify API, Make, Zapier, n8n or Google Sheets, or call it
from AI agents through the Apify MCP server. Export to JSON, CSV, Excel or
HTML.

# Actor input Schema

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

Any Reddit URL: a subreddit (with a sort, e.g. <code>/r/espresso/top/?t=week</code>), a post (with its comments), a user (<code>/user/name/</code>, <code>/comments/</code> or <code>/submitted/</code>), a search (<code>/search/?q=…\&type=comments</code>), <code>r/popular</code>, <code>r/all</code>, the front page or <code>/explore/</code>. Share links (<code>/s/…</code>) aren't supported: open them and copy the post URL.

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

Community names (<code>AskReddit</code>, <code>r/espresso</code>). <code>popular</code> and <code>all</code> work too.

## `searches` (type: `array`):

Search Reddit for each keyword. Choose what to search for below.

## `searchFor` (type: `array`):

What each keyword searches: posts, comments (full comment text, with the post and subreddit), communities or users.

## `searchSubreddit` (type: `string`):

Optional: restrict post and comment searches to this community (e.g. <code>espresso</code>).

## `users` (type: `array`):

Usernames (<code>spez</code>, <code>u/spez</code>): profile, posts and/or comments (see below).

## `includeExplore` (type: `boolean`):

The communities Reddit's Explore tab recommends, with subscribers, description and (optionally) rules.

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

Order of subreddit listings and user posts/comments. With <b>New</b>, a <i>Posted after</i> date ends the listing as soon as it's reached.

## `searchSort` (type: `string`):

Order of search results. Comment search supports Relevance, Top and New.

## `timeframe` (type: `string`):

For <b>Top</b> and <b>Controversial</b> sorts and for searches.

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

Fetch each post's comment thread (one row per comment, with its depth and parent). Post URLs always include their comments.

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

Reddit shows logged-out readers up to 500 comments of a thread at a time. Above 500, the actor merges several comment orders (top, new, controversial, old) to reach deeper into big threads.

## `commentSort` (type: `string`):

Which comments come first (and are kept when a thread has more than the maximum).

## `userContent` (type: `string`):

A user's posts, comments or both. A user URL ending in <code>/comments/</code> or <code>/submitted/</code> overrides this.

## `userProfile` (type: `boolean`):

A row per user: karma, account age, description, verified, moderator, employee.

## `includeSubredditInfo` (type: `boolean`):

A row per scraped subreddit: subscribers, description, creation date, type, icon.

## `includeRules` (type: `boolean`):

Add each community's rules to its row (subreddit info, community search, Explore).

## `postedAfter` (type: `string`):

Only posts from this date on: <code>2026-10-01</code>, or relative: <code>7 days</code>, <code>24 hours</code>, <code>1 month</code>. Schedule a daily run with <code>1 day</code> to collect what's new.

## `postedBefore` (type: `string`):

Only posts up to this date (same formats).

## `commentedAfter` (type: `string`):

Only comments from this date on (same formats).

## `minScore` (type: `integer`):

Skip posts (and searched or user comments) with a lower score.

## `minComments` (type: `integer`):

Skip posts with fewer comments.

## `onlyNew` (type: `boolean`):

Skip posts, comments, communities and users this monitor delivered in earlier runs (remembered 60 days). Skipped rows aren't charged. Schedule the actor for brand, keyword or community monitoring.

## `monitorName` (type: `string`):

Keep separate monitors apart (e.g. one per brand). Letters, digits and dashes.

## `maxItemsPerSource` (type: `integer`):

Posts per subreddit, search or user (and comments per comment search or user). Reddit ends any listing or search at about 1,000. Thread comments are capped by <i>Max comments per post</i> instead.

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

The run stops after this many rows (posts, comments, communities and users together).

## `proxyConfiguration` (type: `object`):

Apify's datacenter proxies work and cost least. Reddit allows each IP 100 requests per 10 minutes: the actor moves to a new IP before that runs out. If Reddit refuses datacenter IPs, the run switches to residential by itself.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/technology/"
    }
  ],
  "searches": [
    "espresso machine"
  ],
  "searchFor": [
    "posts"
  ],
  "includeExplore": false,
  "sort": "hot",
  "searchSort": "relevance",
  "timeframe": "all",
  "includeComments": false,
  "maxCommentsPerPost": 100,
  "commentSort": "top",
  "userContent": "both",
  "userProfile": true,
  "includeSubredditInfo": false,
  "includeRules": false,
  "onlyNew": false,
  "monitorName": "default",
  "maxItemsPerSource": 100,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `rows` (type: `string`):

Posts, comments, communities and users: title or text, author, subreddit, score, comments, date and link.

## `allFields` (type: `string`):

Every field of every row: body, upvote ratio, flair, media and gallery, comment depth and parent, community rules, user karma.

# 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.reddit.com/r/technology/"
        }
    ],
    "searches": [
        "espresso machine"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nextgensda/reddit-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.reddit.com/r/technology/" }],
    "searches": ["espresso machine"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nextgensda/reddit-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/technology/"
    }
  ],
  "searches": [
    "espresso machine"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nextgensda/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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