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

Scrape Reddit posts, comments, users and subreddits from any URL, search, subreddit or username. Score, upvote ratio, comment count, full text, flair, images and video, comment threads with depth and reply counts. First results in seconds, no login, no browser.

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

## Pricing

from $0.79 / 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/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

### What does Reddit Scraper do?

Reddit Scraper gets Reddit posts, comments, users and subreddits from any Reddit URL, search term, subreddit or username: score, upvote ratio, comment count, full text, flair, images and video, and comment threads with replies (up to your per-post cap). No login, no browser, no cookies.

- **Fast:** the first row lands about 2 seconds after the start (median 2.2 s in 10 prefilled runs on Oct 20, 2026), and the prefilled run (100 results) finishes in about 6 seconds (median; 4 to 19 s).
- **Runs finish:** all 16 runs in the last 30 days succeeded (Apify's public count, Oct 20, 2026). The most-used Reddit scraper on the Store succeeded in 87.5% of its 337,696 runs in the same 30 days: about 1 in 8 did not.
- **One price for every row:** $0.99 per 1,000 results on Starter, whether the result is a post, a comment, a user or a community. No start fee, and you pay only for results you get.

These are real rows from the prefilled run (search "crm recommendation", past year, 20 posts with 4 comments each):

| Post | Community | Score | Comments | Posted |
|---|---|---:|---:|---|
| [HELP! What CRM do you recommend?](https://www.reddit.com/r/CRM/comments/1tupsg7/help_what_crm_do_you_recommend/) | r/CRM | 12 | 100 | 2026-06-02 |
| [Looking for a new CRM platform. Any recommendations?](https://www.reddit.com/r/CRMSoftware/comments/1upfhuq/looking_for_a_new_crm_platform_any_recommendations/) | r/CRMSoftware | 17 | 76 | 2026-07-07 |
| [Which CRM would you recommend for our small business?](https://www.reddit.com/r/CRM/comments/1t6jj1s/which_crm_would_you_recommend_for_our_small/) | r/CRM | 16 | 94 | 2026-05-07 |
| [CRM recommendations for a small service based business](https://www.reddit.com/r/CRM/comments/1vjgcfr/crm_recommendations_for_a_small_service_based/) | r/CRM | 8 | 61 | 2026-08-09 |
| [CRM Recommendations for Small Tech Startup that values customer exp...](https://www.reddit.com/r/CRM/comments/1tw9lzg/crm_recommendations_for_small_tech_startup_that/) | r/CRM | 18 | 78 | 2026-06-04 |

<sub>$0.99 per 1,000 results on Starter ($1.09 Free, $0.89 Scale, $0.79 Business). The prefilled run (100 results) costs about $0.10. No start fee.</sub>

### What can you scrape from Reddit?

- **Subreddits**: hot, new, top, rising or controversial posts, any period.
- **Search**: posts for any words (all of Reddit or one subreddit), comments that use your words anywhere on Reddit, plus communities (with their rules) and users.
- **Posts by URL**: the post, plus its comments when **Include comments** is on, up to **Max comments per post** (replies included, with `depth`, `parentId`, `rootCommentId` and `numberOfReplies` on every comment).
- **Users**: profile (karma, account age, verification, moderator), their posts and their comments (`/user/<name>/comments/` links work too).
- **Any Reddit link**: paste subreddit, post, user, search or front-page URLs into one list.

Filters: posted after or before a date (or "7 days"), minimum score, NSFW on or off, and for searches **Match** (every word, or the exact phrase, in the post's title and text or the comment). Filtered-out posts aren't charged.

### Use cases

- **Lead generation**: find people asking for a tool like yours ("crm recommendation", "alternative to X") and read what they need in the comments.
- **Market and product research**: collect what a community says about a product, a competitor or a problem, with scores to see what resonates.
- **Brand and topic monitoring**: run a search or a subreddit on a schedule with **Posted after** set to "1 day" to get only what's new.
- **Datasets for AI and analysis**: whole comment threads with `depth`, `parentId` and `rootCommentId`, ready to rebuild conversations.
- **Community and creator research**: subreddit size, age and rules; user karma, account age and post history.

### How much does it cost to scrape Reddit?

You pay per result in your dataset: a post, a comment, a user or a community, all at the same price.

| Apify plan | Price per 1,000 results |
|---|---:|
| Free | $1.09 |
| Starter | $0.99 |
| Scale | $0.89 |
| Business | $0.79 |

Each post, comment, user or community is charged once per run, even when several of your inputs find it. There's no start fee, and the run stops at your spending limit.

### Input

The prefill searches Reddit for "crm recommendation" (past year) and reads 20 posts with 4 comments each. To change it:

- **Reddit URLs**: any subreddit, post, user or search link.
- **Search terms**: one per line; choose posts, comments, communities or users in **Search for**.
- **Include comments** and **Max comments per post**: up to 100,000 comments per post. Reddit's first answer comes in its own order (Best, Top, New, Controversial, Old or Q\&A); on big threads the rest follow as they're read: 1,000 comments of a 4,277-comment thread took a 21 s run on 2026-10-19 (very large asks take longer).
- **Max posts per source**: per URL, search term, subreddit or user. Reddit lists about 1,000 posts per subreddit sort and about 250 per search sort; **Maximize coverage** reads a search in more sorts and periods and merges them without duplicates.
- **Max results (total)**: a cap for the whole run, every source, post, comment, user and community counted together. Leave it empty for no total cap.
- Below the first screen: **Subreddits and users** (names instead of URLs, sort and period, what to get per user), **Search options** (sort, period, one subreddit only, Match, Maximize coverage), **Filters** (dates, minimum score, NSFW) and **Advanced** (comment depth and sort, proxy).

```json
{
  "startUrls": [{ "url": "https://www.reddit.com/r/smallbusiness/top/?t=week" }],
  "searches": ["best crm for startups"],
  "includeComments": true,
  "maxCommentsPerPost": 50,
  "maxItemsPerSource": 100,
  "postedAfter": "30 days"
}
```

### Output

Every row goes to one dataset, where `dataType` says what it is: `post`, `comment`, `user` or `community`. The Output tab shows them all together, plus one table each for posts (with a stats view), comments, users and communities. Those tables are free copies: each row is charged once. Download as JSON, CSV, Excel or HTML, or read it through the Apify API.

A comment row (prefilled run, shortened):

```json
{
  "dataType": "comment",
  "id": "t1_opbsaek",
  "upVotes": 4,
  "createdAt": "2026-06-02T14:42:48Z",
  "depth": 0,
  "parentId": "t3_1tupsg7",
  "postId": "t3_1tupsg7",
  "postTitle": "HELP! What CRM do you recommend?",
  "communityName": "r/CRM"
}
```

**Post fields** (101): `id`, `url`, `title`, `body`, `communityName`, `username`, `upVotes`, `upvoteRatio`, `commentsCount`, `createdAt`, `flair`, `postType`, `contentUrl`, `domain`, `imageUrls`, `videoUrl`, `thumbnail`, `over18`, `ageHours`, `scorePerHour`, `commentsPerHour`, `engagementTotal`, `wordCount`, `bodyHtml`, `subredditSubscribers`, `authorId`, `authorFlairText`, `editedAt`, `isSelf`, `isVideo`, `isGallery`, `isDeletedOrRemoved`, `spoiler`, `locked`, `stickied`, `isAd`, `numCrossposts`, `numDuplicates` (filled when **Include comments** is on: it's only on the post's own page), `crosspostParentUrl`, `galleryImages`, `galleryCaptions`, `mediaAssets`, `embed`, `media`, `preview`, `permalink`, `oldRedditUrl`, `shortUrl` and more.

**Comment fields** (61): `id`, `url`, `body`, `username`, `upVotes`, `createdAt`, `depth`, `parentId`, `parentKind`, `rootCommentId`, `postId`, `postTitle`, `postUrl`, `postUpVotes`, `postCommentsCount`, `postCreatedAt`, `postAuthor`, `communityName`, `numberOfReplies`, `isSubmitter`, `controversiality`, `edited`, `stickied`, `bodyHtml` and more.

**User fields** (37): `username`, `totalKarma`, `postKarma`, `commentKarma`, `createdAt`, `accountAgeDays`, `iconUrl`, `snoovatarImg`, `previousNames`, `profileVisibility`, `isVerified`, `isMod`, `isEmployee`, `description` and more. **Community fields** (53): `communityName`, `title`, `subscribers`, `weeklyActiveUsers` and `weeklyContributions` (the weekly visitors and contributions Reddit shows on the community's page), `onlineUsersCount` (filled when Reddit sends it; its logged-out data has no online count today, so it is usually empty), `whitelistStatus` (Reddit's ad status: `all_ads`, `some_ads`, `house_only` or `promo_adult_nsfw`), `description`, `descriptionHtml`, `headerTitle`, `rules` (name, description, kind and report reason of each rule), `createdAt`, `over18`, `language`, `iconUrl`, `headerImage`, `restrictCommenting`, `spoilersEnabled`, `linkFlairEnabled`, `suggestedCommentSort` and more.

Every row also has `input` (which of your inputs found it) and `scrapedAt` (when its page was read). Run totals, per-input counts and anything not found are in the run's OUTPUT record.

### Is it legal to scrape Reddit?

This Actor reads only public Reddit content that anyone can see without logging in. It doesn't log in and doesn't touch private or quarantined communities. If your results include personal data, you're responsible for handling it lawfully (for example under GDPR).

### FAQ

**What if Reddit fails in the middle of a thread?** Each call is tried up to 5 times, each time from a new IP. If one still fails, the comments read so far stay in your dataset, and the run's status and OUTPUT (`commentsIncomplete`) list the posts whose threads stopped early.

**Can it search comments?** Yes: set **Search for** to **Comments**, or paste a Reddit search link with `type=comments`. It reads Reddit's own comment search (relevance, new or top) and fills each comment in with its full record: author, score, time, parent, post and community. **Search only in this subreddit** uses Reddit's own subreddit search (and each row is checked again). Reddit's comment search has no period of its own, so **Search period** and **Posted after/before** are applied to what it returns: other comments are skipped and free, you pay only for the rows you get. A narrow period over a broad word reads more pages to find matches (it gives up after 15 pages in a row with none), so use sort **New** with a short period. Same price as any other row, no residential proxy needed.

**Why fewer posts than I asked for?** Reddit itself stops a subreddit sort at about 1,000 posts and a search sort at about 250. Use other sorts and periods, or **Maximize coverage** for searches.

**Is it fast?** Results arrive page by page as Reddit answers, and the next page is already being read while one is saved. In our runs on Apify (256 MB, datacenter proxy, October 20, 2026, builds 0.1.27 and 0.1.28) the first row came about 2 seconds after the Actor started, and memory peaked at 115 MB:

| Run | Results | Time |
|---|---:|---:|
| The prefill: search "crm recommendation", 20 posts with 4 comments each | 100 | 6 s (median of 10 runs; 4 to 19 s) |
| r/Python, newest, 1,000 posts asked (Reddit lists 951) | 951 | 46 s (first row at 1.6 s) |

Most of a big subreddit run is Reddit's own answer time: it serves one 100-post page at a time, about 3 seconds each in that run (30 of its 46 seconds), and each page needs the one before it.

**Does my Apify plan matter?** Only for very large runs. Reddit allows 100 requests per IP every 10 minutes, and the run uses your plan's datacenter proxy IPs: 5 on the Free plan (about 500 requests, or 50,000 posts, per 10 minutes), 30 or more on paid plans. When every IP has used its 100, the run pauses until Reddit's window resets and says so in its status, then carries on. If the pause would run past your run's timeout, it stops just before it and keeps every row it collected.

### Feedback

Found a bug or need a field? Open an issue on the Actor's Issues tab; we read every one.

# Actor input Schema

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

Any Reddit link, one per row: a subreddit (r/Python, r/Python/top/?t=week), a post, a user (u/spez), a search (reddit.com/search/?q=...) or the front page. Leave empty if you use Search terms or the sections below.

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

Words to search all of Reddit for, one per line, e.g. best crm for startups. 'Search for' picks posts, comments, communities or users.

## `searchType` (type: `string`):

What the search terms look for. Comments finds comments that use your words anywhere on Reddit (Search sort: relevance, new or top; Search period and Search only in this subreddit apply), each with its post and community.

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

Add each post's comments, replies included, right after the post. Each comment is one result.

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

Most comments to read per post, replies included, in Reddit's thread order (e.g. 4 for a quick look, 500 for whole threads).

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

Most posts (or communities or users) per URL, search term, subreddit or user. Reddit lists about 1,000 posts per subreddit sort and about 250 per search sort; 'Maximize coverage' gets more from a search.

## `maxResults` (type: `integer`):

Most rows for the whole run: every source, post, comment, user and community counted together. Empty = no total cap (Max posts per source and your spending limit still apply).

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

Subreddit names (Python or r/Python), one per line. Their posts are read in the order set by 'Subreddit sort'.

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

Order of subreddit posts, as on Reddit.

## `time` (type: `string`):

Period for the Top and Controversial sorts.

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

Reddit usernames (spez or u/spez), one per line.

## `userContent` (type: `array`):

The profile (karma, account age, verification), the user's posts, the user's comments, or any mix.

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

Order of search results.

## `searchTime` (type: `string`):

How far back a search looks. Comments older than this are skipped (Reddit's comment search has no period of its own, so it is applied here; skipped comments are free).

## `withinSubreddit` (type: `string`):

Optional subreddit name (e.g. CRM) to limit search terms to. With Comments, other communities' comments are skipped (free).

## `matchMode` (type: `string`):

How closely a post or comment must match your search terms.

• Reddit's match: whatever Reddit's search finds (it also matches word stems and other fields, so some results only touch your words).
• Every word: the post's title and text (or the comment) must hold every word of the search term, in any order.
• Exact phrase: the words in a row, as typed (case, punctuation and line breaks don't matter).

Results that don't match aren't delivered and aren't charged. A post's own comments (Include comments) always come with it.

## `maximizeCoverage` (type: `boolean`):

Reddit stops a search at about 250 posts per sort. On: each search is also read in other sorts and periods (new, top by year, month, week...) and merged without duplicates.

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

Only posts and comments from after this date: 2026-09-01, 2026-09-01T12:00:00Z, or a period like '7 days' or '12 hours'.

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

Only posts and comments from before this date (same formats).

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

Skip posts with a lower score (upvotes minus downvotes), e.g. 10. Empty = no minimum.

## `includeNSFW` (type: `boolean`):

Keep posts and communities marked 18+.

## `commentDepth` (type: `integer`):

How deep in reply chains to go: 1 = top-level comments only, 10 = Reddit's maximum.

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

Order of comments, as on Reddit.

## `includeCommunityRules` (type: `boolean`):

For community search results, also read each community's rules (one extra Reddit call per community; free).

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

Leave as is: Reddit answers Apify's datacenter proxy, the cheapest option. If you pick Residential, the run still reads through datacenter and uses your residential IPs only to retry a call Reddit refuses there.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/search/?q=crm+recommendation&sort=relevance&t=year"
    }
  ],
  "searchType": "posts",
  "includeComments": true,
  "maxCommentsPerPost": 4,
  "maxItemsPerSource": 20,
  "sort": "hot",
  "time": "day",
  "userContent": [
    "profile",
    "posts",
    "comments"
  ],
  "searchSort": "relevance",
  "searchTime": "all",
  "matchMode": "any",
  "maximizeCoverage": false,
  "includeNSFW": true,
  "commentDepth": 10,
  "commentSort": "confidence",
  "includeCommunityRules": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `posts` (type: `string`):

No description

## `comments` (type: `string`):

No description

## `users` (type: `string`):

No description

## `communities` (type: `string`):

No description

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.reddit.com/search/?q=crm+recommendation&sort=relevance&t=year"
        }
    ],
    "includeComments": true,
    "maxCommentsPerPost": 4,
    "maxItemsPerSource": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/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/search/?q=crm+recommendation&sort=relevance&t=year" }],
    "includeComments": True,
    "maxCommentsPerPost": 4,
    "maxItemsPerSource": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/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/search/?q=crm+recommendation&sort=relevance&t=year"
    }
  ],
  "includeComments": true,
  "maxCommentsPerPost": 4,
  "maxItemsPerSource": 20
}' |
apify call deepmine/reddit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/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/avf0RUdxmNzcfNrQL/builds/R1mKr4KQQChvOEwDh/openapi.json