# Reddit Scraper: Subreddit Posts and Comments (`kaleidoscopelabs/reddit-scraper`) Actor

Scrape Reddit data from any public subreddit, post link or search, no login or Reddit API key needed: posts with title, text, score, flair, link and time, plus comments and replies as a Reddit comments scraper. Filter by date, score, flair or type, or run a subreddit monitor for new posts.

- **URL**: https://apify.com/kaleidoscopelabs/reddit-scraper.md
- **Developed by:** [Kaleidoscope Labs](https://apify.com/kaleidoscopelabs) (community)
- **Categories:** Social media, AI, Lead generation
- **Features:** Limited permissions
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 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.
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? Subreddit scraper and subreddit monitor

**Scrape Reddit posts and comments from any public subreddit, post link or Reddit search, logged out, no Reddit API key needed: a subreddit scraper, a Reddit comments scraper and a subreddit monitor in one Actor.**

Public subreddits, post links or searches go in; one record per post comes out, with its title, text, score, upvote ratio, comment count, flair, link, creation time and author, in hot, new, top, rising or best order, and, when you ask for them, one record per comment and reply in Reddit's own order. $1.50 per 1,000 posts and $1.50 per 1,000 comments on Apify's free plan, less on paid plans; a monitor's check is $0.002 per subreddit.

Filter posts by date, type, score, flair or whether they take comments, or run it as a subreddit monitor that stores only the posts new since its last run. Each post and each comment is one dataset item and one charged event. Run it from Apify Console, call it through the API, schedule it, or let an AI agent call it.

[![Use it from your AI agent: copy the MCP setup prompt](https://assets.kaleidoscopelabs.io/afy/mcp/mcp-setup.5ac6bded.png)](https://mcp.apify.com/?tools=kaleidoscopelabs/reddit-scraper)

![One r/SaaS post's whole thread, read with Deep threads on: 237 of Reddit's 249 comments, each drawn under the comment it answers, with a chain of replies 13 levels deep.](https://assets.kaleidoscopelabs.io/afy/reddit/whole-thread.cf415466.png)

### What data can you extract from Reddit?

A run stores up to three kinds of record in one dataset: posts, and with Comments on, comments and one thread record per post whose comments were read. They are told apart by `recordType` (filter on it); the Post, Comment and Thread columns views each pick one kind's columns. The output schema lists every field.

| Record | Main fields |
|---|---|
| Post | `id`, `url`, `subreddit`, `title`, `body`, `postType`, `link`, `images`, `video`, `flair`, `score`, `upvoteRatio`, `commentCount`, `createdAt`, `nsfw`, `stickied`, `locked`, `query`, `sort`, `rank` |
| Comment | `id`, `url`, `postId`, `parentId` (the post or comment it answers), `depth`, `position`, `body`, `authorFlair`, `score`, `createdAt`, `editedAt`, `isSubmitter`, `deleted` |
| Thread (not charged) | `postId`, `commentsStored`, `commentCount` (Reddit's count), `ended` (why the reading stopped: readWhole, limit, depth, dateWindow and others) |

Posts and comments also carry `author` and `authorId` (Author names on, the default), `scrapedAt`, and `missing`: what the record lacks and why, such as author notRequested with Author names off, or a field Reddit's page did not give. Reddit's `commentCount` also counts comments it no longer shows, so a thread read whole stores fewer; its thread record says how many.

### How to use Reddit Scraper

1. Open Reddit Scraper in Apify Console.
2. Enter subreddits or post links in **Subreddits or posts**, or Reddit searches in **Searches**, and choose the order, the period and the posts per subreddit.
3. Narrow the posts under **Filters** if you need: posted after or before a day, post types, a minimum score, flairs, only posts open for comments.
4. Turn **Comments** on to get each post's comments, and set how many per post, their order and the reply depth.
5. For a schedule, name a **Monitor**: each run then stores only the posts new since the monitor's last run.
6. Turn Author names off if you do not need who wrote each post and comment.
7. Start the run, then download the dataset as JSON, CSV, Excel, XML or HTML, or read it through the API.

### How much does it cost to scrape Reddit posts and comments?

Reddit Scraper is priced per event, with no usage fees on top:

| Event | Price | When |
|---|---|---|
| `post` | $0.0015 | Each post stored |
| `comment` | $0.0015 | Each comment stored (Comments on) |
| `check` | $0.002 | Each subreddit a run with a monitor reads, new posts or not |
| Actor start | $0.00005 per GB of memory, at least one | Each run |

Prices shown are for Apify's free plan; on paid plans they are up to 30% lower.

For example, at the default 256 MB of memory:

- 1,000 posts cost $1.50, plus $0.00005 for the start.
- 200 posts with up to 10 comments each (2,000 comments) cost $0.30 + $3.00 = $3.30.
- A monitor of 10 subreddits run daily costs about $9.60 a month: 300 checks ($0.60) and, at 20 new posts per subreddit a day, 6,000 posts ($9.00). Run hourly, it costs about $23.40 a month: 7,200 checks ($14.40) and the same posts.

Not charged: thread records, posts a filter left out, posts a monitor stored in its earlier runs, pages that could not be read, and a run that stops on an input mistake (only the platform's start fee). Set a maximum total charge in the run options to cap a run; the Actor stops before it, and what it stored is kept.

### Input example

The prefilled input below is a small run that finishes quickly; it reads posts only, as Comments starts off. API and agent calls that leave a field out get its default instead, which is larger for `maxPosts` (100) and `maxComments` (100):

```json
{
  "queries": ["SaaS"],
  "sort": "new",
  "time": "day",
  "maxPosts": 20,
  "maxComments": 10,
  "commentSort": "best",
  "commentDepth": 0
}
```

**Last week's posts of two subreddits, with up to 10 comments each:**

```json
{
  "queries": ["SaaS", "r/startups"],
  "sort": "new",
  "postedAfter": "7 days",
  "maxPosts": 0,
  "includeComments": true,
  "maxComments": 10
}
```

**One thread, every comment:** `{"queries": ["<a post's link>"], "includeComments": true, "maxComments": 0}`.

**A daily monitor:** `{"queries": ["SaaS", "smallbusiness"], "monitorName": "saas-daily"}`, run on a schedule.

**A search:** `{"searches": ["\"customer support\""], "searchSubreddits": ["SaaS"]}` runs the phrase within r/SaaS; leave `searchSubreddits` out to search all of Reddit. `"searchType": "comments"` finds comments instead of posts.

Each field's description in the input tab gives its range and default. Filters apply to subreddits and searches; a post's link is read as given.

### Output example

![Records of one run: the post, three comments each tied by parentId to the one it answers, and the thread record with comments stored against Reddit's count.](https://assets.kaleidoscopelabs.io/afy/reddit/thread-records.ebd65d67.png)

One item of the default dataset, from r/SaaS in the New order with Author names off, copied from a run:

```json
[
  {
    "recordType": "post",
    "id": "t3_1xu4n0o",
    "url": "https://www.reddit.com/r/SaaS/comments/1xu4n0o/everyone_going_2x_within_a_month_is_it_all_fake/",
    "subreddit": "SaaS",
    "subredditId": "t5_2qkq6",
    "title": "Everyone going 2x within a month. Is it all fake?",
    "body": "Everyone posts a screenshot scaling exponentially on twitter reddit LinkedIn. We have been trying to scale but its still slow like 100% a year",
    "bodyHtml": "<p>\n      Everyone posts a screenshot scaling exponentially on twitter reddit LinkedIn. We have been trying to scale but its still slow like 100% a year\n    </p>",
    "postType": "text",
    "link": "https://www.reddit.com/r/SaaS/comments/1xu4n0o/everyone_going_2x_within_a_month_is_it_all_fake/",
    "domain": "self.SaaS",
    "score": 1,
    "upvoteRatio": 1,
    "commentCount": 4,
    "awardCount": 0,
    "createdAt": "2026-11-12T05:37:35Z",
    "language": "en",
    "stickied": false,
    "locked": false,
    "spoiler": false,
    "nsfw": false,
    "isCrosspost": false,
    "query": "saas",
    "queryType": "subreddit",
    "sort": "new",
    "rank": 17,
    "scrapedAt": "2026-11-12T10:39:33Z",
    "missing": [
      {
        "group": "author",
        "reason": "notRequested"
      }
    ]
  }
]
```

With Author names on, the default, the record carries `author` (the username) and `authorId`, and `missing` leaves out the author.

### For AI agents

AI agents can call Reddit Scraper through the Apify MCP server ([setup prompt for your agent](https://mcp.apify.com/?tools=kaleidoscopelabs/reddit-scraper)), or through the API like any other program.

- **Minimal input:** `{"queries": ["SaaS"]}` gives the newest 100 posts of r/SaaS. Add `"includeComments": true, "maxComments": 10` for comments (the default of 100 per post costs about $15 for 100 posts).
- **Fields to read:** `recordType` first; then `title`, `body`, `score`, `createdAt` on posts, `postId`, `parentId`, `body` on comments, `commentsStored` and `ended` on threads.
- **Empty results:** an input mistake ends the run SUCCEEDED with an empty dataset; the key-value record RUN_SUMMARY then has `inputError` (noQuery, invalidQuery, invalidSetting or notFound) and `message`. Its `complete` is false when the run ended short. `missing` says what a record lacks; an empty field is never silent.

Did it save you time? A rating on this page helps others find it; an Issue tells us what to fix.

### FAQ

#### Is it legal to scrape Reddit?

Reddit Scraper reads public pages only and needs no login. Whether you may use the data depends on your purpose, on the law that applies to you and on the terms of Reddit, so check them before you build on the results. When in doubt, ask a lawyer.

#### Does Reddit Scraper collect personal data?

These fields can carry personal data: each post's and comment's Author and Author ID. They are on by default, under Author names; turn it off to leave them out. Titles and texts are what people wrote and can name people too; with Author names off, records still link to the posts on Reddit, and a post made in a user's profile keeps that profile (u_name) in its subreddit and URL. Collect personal data only when you have a legal basis under the GDPR, KVKK or a similar law, and keep it no longer than you need it. When in doubt, ask a lawyer.

#### Why did my run return fewer posts or comments than I expected?

The target may have fewer matching posts than the maximum you set, a filter may have left posts out, or the run may have reached its maximum total charge; the run log says which. For comments, each thread record says how many were stored against Reddit's count and why the reading ended. A run has two hours by default: in our tests, 99 subreddits were read to the end in 45 minutes, and 1,000 posts with up to 10 comments each (5,666 comments) in 62 minutes.

#### How does the monitor work?

![One monitor on r/SaaS, r/smallbusiness and r/Entrepreneur: the first run stores 60 posts; an hour later the next run stores only the 8 posted since.](https://assets.kaleidoscopelabs.io/afy/reddit/monitor-new-posts.6d13ae89.png)

Name a monitor and schedule the run. Its first run stores up to Posts per subreddit from each subreddit as the baseline, charged as posts; after that, each run reads each subreddit in the New order down to the newest post the last run stored, so the dataset holds only new posts. Each subreddit read costs one check, new posts or not; the monitor's memory is a key-value store in your account named after it.

#### How do searches work?

Each line of Searches is run as you would type it into Reddit's search, across Reddit or within each subreddit under Search within, and its results are stored as posts, at the post price. Reddit's search results show less than a subreddit's feed, so with Comments off a search's post lacks its text, flair and link, named in `missing` as notInSearchResult; with Comments on, each post's own page is read and its record is whole. A monitor reads its searches in the New order, one check per search.

#### Can I connect Reddit Scraper to other tools?

Yes. Use Apify integrations, webhooks or the API to send the dataset to your tools every time a run finishes. AI agents can call it as a tool (see For AI agents).

#### Something went wrong: what should I check?

The run's last message says what happened. An input mistake names what to correct, and nothing is charged but the start. "Reddit has no subreddit named …" or "Reddit does not find the post" means the names or links are wrong, or the posts were removed. "Reddit stopped giving its pages" is usually temporary: run it again later. "The run's time ran out with pages left": resurrect the run to continue, or give it a longer timeout. For anything else, such as "a form this Actor does not read yet", open an issue with the Ref.

### Limits

- Reddit lists about 1,000 posts per subreddit and order at most; for more, read another order or period.
- Public subreddits only: Reddit does not show a private or banned subreddit to a logged-out reader, and the run names it in its log.
- No user pages as input yet.
- Reddit's search may list no more than about 40 posts a search, whatever Posts per subreddit asks; run a monitored search often enough to catch them.

### Tips

- Start from the prefilled input to see the output, then raise Posts per subreddit.
- Use the New order with Posted after to read a period exactly; in the other orders every post read is checked against the dates.
- With Comments on, set Comments per post: it decides most of a run's cost and time.
- Turn Deep threads on when the deepest replies matter: it also opens Reddit's "more replies" pages, and is slower.

### Support and feedback

Open an issue on the Issues tab with the run's ID and the Ref from the run's last message: it tells us what happened without your data.

### Other Actors

| Actor | Use it with this one to |
|---|---|
| [YouTube Transcript API & Scraper](https://apify.com/kaleidoscopelabs/youtube-transcript-scraper) | Turn the videos a subreddit discusses into text for the same research |
| [Ads Transparency Center: Google Ads Scraper](https://apify.com/kaleidoscopelabs/google-ads-transparency-data) | See which of the companies people discuss advertise, and what their ads say |
| [Meta Ad Library & Facebook Ad Library Checker](https://apify.com/kaleidoscopelabs/facebook-ads-library-checker) | See whether the companies people discuss run Facebook and Instagram ads, how many, and the day the newest started |

*Reddit Scraper is an independent tool, not affiliated with, endorsed by or sponsored by Reddit, Inc. Reddit is a trademark of Reddit, Inc.*

# Changelog

This Actor's version history is a separate document: https://apify.com/kaleidoscopelabs/reddit-scraper/changelog.md

# Actor input Schema

## `queries` (type: `array`):

What to read, one per line: a public subreddit (SaaS, r/SaaS, or its link; a link's order, such as /top/?t=week, is kept), or a post's link (that post, with its comments when Comments is on). Up to 100 subreddits and 100 post links.

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

The order the subreddit lists its posts in, as on Reddit: Hot, New, Top, Rising or Best.

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

For the Top order: the period its posts are the top of.

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

Reddit searches, one per line, as typed into Reddit's search: air fryer, or "customer support" in quotes for the phrase. Each gives the posts Reddit finds for it; a search's results show less than a subreddit's (no body, flair or link), and with Comments on each post is read whole. Each line goes to Reddit as typed, author: included. To run searches only, leave Subreddits or posts empty.

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

The order of a search's results, as on Reddit: Relevance, Hot, Top, New or Comment count. A monitor reads its searches in the New order.

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

For the Top search order: the period its results are the top of.

## `searchSubreddits` (type: `array`):

Run each search inside each of these subreddits (SaaS or r/SaaS); empty searches all of Reddit. Each search within each subreddit counts as one of the run's 100 subreddits and searches.

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

What the searches find: posts, or comments (each result a comment record, charged as a comment, up to Posts per subreddit per search; order Relevance, Top or New).

## `maxPosts` (type: `integer`):

How many posts each subreddit or search contributes, in its order; 0 takes as many as Reddit lists.

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

Keep only posts from this day on, in UTC: a date or a span such as 7 days. In the New order the subreddit is read back to that day only; in other orders each post is checked, so a run may read more than it keeps.

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

Keep only posts from before this day, in UTC: a date or a span such as 1 day. With Posted after 1 day and Posted before 0 days, a run keeps yesterday's posts. Newer posts are read past, not kept.

## `postTypes` (type: `array`):

Keep only posts of these types; none chosen keeps every type. Galleries include Reddit's mixed-media posts. On searches it needs Comments on, as a search's results do not show the type.

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

Keep only posts with at least this score. In the New order, young posts have not collected their votes yet.

## `flairs` (type: `array`):

Keep only posts whose flair is one of these lines, such as Question, letter case ignored; empty keeps every post. On searches it needs Comments on, as a search's results do not show it.

## `skipLocked` (type: `boolean`):

Leave out locked posts, which take no new comments. On searches it needs Comments on, as a search's results do not show it.

## `skipNsfw` (type: `boolean`):

Leave out posts Reddit marks NSFW (over 18). Off, every post is kept with its nsfw field.

## `pagesWithoutMatch` (type: `integer`):

Stop reading a subreddit after this many pages in a row (a page is about 24 posts) with no post that passes the filters; 0 reads on to Reddit's end. A filter that matches rarely may need more.

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

Name a monitor, such as saas-daily, to store only new posts: each subreddit, read in the New order, gives the posts since the monitor's last run. Its first run stores up to Posts per subreddit as the baseline. Searches are monitored too, in the New order. Each subreddit or search read is one check. Up to 40 letters, digits, hyphens.

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

Read each post's comments too, each a record of its own tied to its parent, and a thread record per post saying how many of Reddit's count were stored and why. Each comment stored is charged; off by default.

## `maxComments` (type: `integer`):

How many comments each post contributes, the first Reddit shows as the thread opens (top-level comments with their replies); 0 takes every comment Reddit shows, which on large threads is slow.

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

The order comments are read in, as on Reddit: Best, Top, New, Controversial, Old or Q\&A. With Comments per post set, it decides which comments are kept.

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

How deep into the replies to read: 1 keeps top-level comments only, 2 adds their replies; 0 reads every depth.

## `commentsPostedAfter` (type: `string`):

Keep only comments from this day on, in UTC: a date or a span such as 7 days. Each thread is still read whole; comments outside the dates are not stored or charged.

## `commentsPostedBefore` (type: `string`):

Keep only comments from before this day, in UTC: a date or a span such as 1 day.

## `deepThreads` (type: `boolean`):

Also open the "more replies" pages Reddit links to, for replies nested deeper than the thread's page shows. A run is slower; worth it when the deepest exchanges matter. Off, the thread record says when such pages were left.

## `includeAuthors` (type: `boolean`):

Add each post's and comment's author: username and account ID. Usernames are personal data; you decide whether and why you collect them. Off, posts and comments come without them.

## Actor input object example

```json
{
  "queries": [
    "SaaS",
    "https://www.reddit.com/r/SaaS/comments/1xhsv0i/"
  ],
  "sort": "new",
  "time": "day",
  "searchSort": "relevance",
  "searchTime": "all",
  "searchSubreddits": [],
  "searchType": "posts",
  "maxPosts": 20,
  "postTypes": [],
  "flairs": [
    "Question",
    "Discussion"
  ],
  "skipLocked": false,
  "skipNsfw": false,
  "pagesWithoutMatch": 20,
  "includeComments": false,
  "maxComments": 10,
  "commentSort": "best",
  "commentDepth": 0,
  "deepThreads": false,
  "includeAuthors": true
}
```

# Actor output Schema

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

The posts and comments 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 = {
    "queries": [
        "SaaS"
    ],
    "sort": "new",
    "time": "day",
    "searchSort": "relevance",
    "searchTime": "all",
    "searchSubreddits": [],
    "searchType": "posts",
    "maxPosts": 20,
    "postTypes": [],
    "flairs": [],
    "pagesWithoutMatch": 20,
    "maxComments": 10,
    "commentSort": "best",
    "commentDepth": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaleidoscopelabs/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 = {
    "queries": ["SaaS"],
    "sort": "new",
    "time": "day",
    "searchSort": "relevance",
    "searchTime": "all",
    "searchSubreddits": [],
    "searchType": "posts",
    "maxPosts": 20,
    "postTypes": [],
    "flairs": [],
    "pagesWithoutMatch": 20,
    "maxComments": 10,
    "commentSort": "best",
    "commentDepth": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("kaleidoscopelabs/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 '{
  "queries": [
    "SaaS"
  ],
  "sort": "new",
  "time": "day",
  "searchSort": "relevance",
  "searchTime": "all",
  "searchSubreddits": [],
  "searchType": "posts",
  "maxPosts": 20,
  "postTypes": [],
  "flairs": [],
  "pagesWithoutMatch": 20,
  "maxComments": 10,
  "commentSort": "best",
  "commentDepth": 0
}' |
apify call kaleidoscopelabs/reddit-scraper --silent --output-dataset

```

## MCP server setup

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