# Reddit Scraper (`boncross/reddit-scraper`) Actor

Scrape Reddit posts, comment trees, subreddit feeds, user profiles and communities by keyword search or URL. Get title, body, author, score, upvote ratio, comment count, flair, media and timestamps. Filter by date, flair or keyword, or run only-new, with no proxy to set up. $1.20 per 1,000 items.

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

## Pricing

from $0.84 / 1,000 result-items

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

## Reddit Scraper

### What is Reddit Scraper?

Reddit Scraper gets you Reddit posts with their whole comment trees, the replies behind "load more" included, along with subreddit feeds, user histories and community details. Paste keywords, subreddit names or any Reddit URL. You don't need a Reddit account or an API key, and there's no proxy to set up.

Why people choose it:

- Whole threads arrive quickly. A 2,571-comment thread, a 50-post feed with its comments, a search and a user profile returned 3,916 results in 15 seconds.
- You can search comments by keyword across all of Reddit, not only posts. A keyword finds the comments that mention it, each as a full comment record.
- You pay for what you keep. Duplicates, items you've already had and anything your filters drop are free. A target that can't be read gives you a row saying why, and that row isn't charged.
- The engagement maths is done for you. Posts and comments come with score per hour, comments per hour and total engagement next to the raw score.
- It costs $1.20 per 1,000 posts on the Free plan, and half that for comments read from a thread, with proxy usage and platform usage included.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 38 of 38 live checks on its inputs and filters passed on 7 October 2026
- 14 targets run the same day, searches, subreddits, a user and two links: 145 posts, 11 comments, 1 user, 1 error row
- Charges matched the 157 rows
- An unreadable target gets an uncharged row saying why

What you can do with it:

- Search Reddit by keyword, or inside one subreddit, and sort by relevance, hot, top, new or comment count
- Read a subreddit feed by new, hot, top, rising or controversial, with a time window, or its latest comments across all its threads
- Expand a post's full comment tree, collapsed branches included
- Collect user profiles with karma, account age and history: posts, comments or both, by new, hot, top or controversial
- Find the communities and users that match a search term
- Filter by date range, post flair or keyword before anything is charged
- Tag rows with your own labels for campaign or client tracking
- Return only what you haven't seen before, for daily monitoring

Most runs are brand or product monitoring across a few subreddits, market research on what buyers ask before they purchase, or lead generation from questions your product answers. People also use it to track competitors inside industry communities and to spot trends for content research. The comment trees suit sentiment and topic analysis, academic work on discussion structure, and training or evaluation data for language models.

### What Reddit data do you get?

| | |
|---|---|
| Post title and body, plain and HTML | 🔗 Post URL, permalink and external link |
| Author, author id and premium status | 🏷 Post and author flair |
| Score and upvote ratio | 💬 Comment count and crosspost count |
| 📅 Created and edited timestamps | 🖼 Media, galleries, video and thumbnails |
| 🧵 Full comment tree with depth and parent | Comment body, score and submitter flag |
| Subreddit, id, type and subscriber count | Community stats and description |
| 👤 User karma, account age and verification | Locked, stickied, NSFW and Reddit's removal category |
| Awards and gilding | Your own custom labels |

### How to scrape Reddit

There's nothing to install. You fill in a form and download a file.

1. [Create a free Apify account](https://console.apify.com/sign-up) and open [Reddit Scraper](https://apify.com/boncross/reddit-scraper).
2. Add keywords, subreddit names or Reddit URLs. You can mix all three in one run.
3. Want comments? Set "Max comments per post" above 0. It starts at 0, which returns posts only.
4. Choose how many posts you want and add any date, flair or keyword filters.
5. Click Start, then download the results as Excel, CSV, JSON, XML or HTML.

### ⬇️ Input

Three boxes take your targets, and one run can use all of them: "Search terms" for keywords, "Subreddits" for feeds, and "Start URLs" for any Reddit link. What a link returns depends on where it points:

| You paste | You get |
|---|---|
| A post | The post and its comments |
| A subreddit or feed | Its posts |
| A user profile | The profile plus that user's posts and comments. A `/submitted` or `/comments` link narrows it |
| A search results page | That search |

Start URLs can also load links in bulk from a file, a Google Sheet or a remote list. Search terms accept Reddit's own search syntax: quotes, `subreddit:`, `author:`, `title:`, `self:yes` and `flair:`.

**Limits.** "Max posts per search / subreddit / user" (1 to 1,000, default 100) applies to each target on its own. Ten targets at 50 each returns 500. Comments have their own caps: "Max comments per post" (0 to 5,000, default 0, which means posts only) and "Max comments per search" (1 to 5,000, default 100). "Maximum results for the whole run" caps the lot. Nothing past it is fetched or charged for, and 0 means no cap.

**Search extras.** "Also search communities" and "Also search users" are off by default. Switch them on and each search term also returns the matching subreddits as community records and the matching user profiles. "Search within subreddit" restricts your search terms to one subreddit, by name or URL. Leave it empty to search all of Reddit.

**Dates and NSFW.** "Posts posted after" and "Posts posted before" keep posts created within those dates, and the two "Comments posted" fields do the same for comments. A bare date in a "before" field means the end of that day. "Include NSFW" is on by default and keeps posts, comments and communities marked over 18.

**Profiles and communities.** "Fetch author profiles" (off by default) adds a user record with karma, account age and description for each distinct author the run saw, up to "Max users" (default 50) per run. "Fetch community details" (off by default) adds a community record with subscribers, description and type for each subreddit seen.

Keyword search across Reddit, newest first:

```json
{
  "searches": ["nigara hamono"],
  "searchSort": "new",
  "searchTime": "month",
  "maxPosts": 100
}
```

A subreddit feed with full comment trees:

```json
{
  "subreddits": ["TrueChefKnives"],
  "feedSort": "new",
  "maxPosts": 50,
  "maxCommentsPerPost": 500,
  "commentSort": "top"
}
```

One thread, expanded as deep as it goes:

```json
{
  "startUrls": [{ "url": "https://www.reddit.com/r/AskReddit/comments/1wa3b2m/" }],
  "maxCommentsPerPost": 1500,
  "maxCommentDepth": 10
}
```

Comment search by keyword:

```json
{
  "searches": ["nigara hamono"],
  "searchComments": true,
  "searchSort": "new",
  "maxCommentsPerSearch": 60
}
```

A subreddit's newest comments across all its threads, and one user's top comments of all time:

```json
{
  "subreddits": ["TrueChefKnives"],
  "feedSort": "comments",
  "startUrls": [{ "url": "https://www.reddit.com/user/spez/" }],
  "userContent": "comments",
  "userSort": "top",
  "feedTime": "all",
  "maxPosts": 100
}
```

A daily brand monitor with date, flair and keyword filters:

```json
{
  "subreddits": ["TrueChefKnives", "chefknives"],
  "feedSort": "new",
  "maxPosts": 300,
  "postedAfter": "2026-09-01",
  "onlyWithFlair": ["Question", "State of the collection"],
  "filterKeywords": ["nigara", "kurosaki"],
  "filterKeywordMode": "any",
  "customLabels": { "campaign": "q3-monitor" },
  "dedupStoreName": "reddit-brand-seen"
}
```

#### For developers

- `maxPosts`, `maxCommentsPerSearch` and `maxCommentsPerPost` are the per-target limits and `maxItems` is the run-wide one (default 0, no limit). Error rows don't count toward `maxItems`.
- `maxCommentDepth` (default 50, 0 to 100) is the deepest reply level kept, and 0 keeps top-level comments only. `commentSort` (default `confidence`, also `top`, `new`, `controversial`, `old` and `qa`) is how Reddit ranks the tree before it's read.
- Scan guards: with a comment date, keyword or only-new filter, a tree stops being read once five pages of comments in a row match nothing. A comment search stops after five such pages. Reddit gives about 9 comment-search hits per page.
- Reddit search has no date parameter. `postedAfter` and `postedBefore` (and `commentedAfter` and `commentedBefore` for comments) are applied to the rows: on newest-first listings paging stops at the lower bound, and on other sorts the listing is read up to Reddit's cap before filtering.
- Comment search only knows `relevance`, `new` and `top`. With `searchSort` set to `hot` or `comments` it falls back to `relevance`.
- `feedTime` is the window for the Top and Controversial feeds, and for `userSort` when that's `top` or `controversial`. `userContent` is `overview`, `submitted` or `comments`, and a `/submitted` or `/comments` link overrides it.
- `dedupStoreName` names a key-value store that remembers what was returned. Set it on a scheduled run and each run yields only new posts, comments and profiles.
- `includeRawData` (default off) attaches Reddit's original record as `raw` on posts, communities and users. It makes records large.
- `maxConcurrency` (Parallel requests, default 4, 1 to 8) is how many requests run at once. The default is the fastest level measured clean. Lower it only if a run reports refusals or errors.
- Results are saved as they arrive. If the platform interrupts and restarts a run, it carries on without saving or charging any result twice.

### ⬆️ Output

One dataset holds the whole run. Each row has a `dataType` of post, comment, user or community, which is how you split it afterwards. A post:

```json
{
  "dataType": "post",
  "id": "1r0t58w",
  "fullName": "t3_1r0t58w",
  "url": "https://www.reddit.com/r/castiron/comments/1r0t58w/used_my_cast_iron_so_much_its_bad_for_my_health/",
  "permalink": "/r/castiron/comments/1r0t58w/used_my_cast_iron_so_much_its_bad_for_my_health/",
  "externalUrl": null,
  "title": "Used My Cast Iron So Much It's Bad For My Health",
  "body": "I had my blood results follow up today after two years of putting it off. She was going through all my levels and when she came to Iron, I had more th…",
  "bodyHtml": "<div class=\"md\">…</div>",
  "author": "cleverusername143",
  "authorId": "t2_1rjj7ol",
  "authorFlair": null,
  "authorIsPremium": false,
  "subreddit": "castiron",
  "subredditId": "t5_2s8x6",
  "subredditType": "public",
  "subredditSubscribers": 740229,
  "createdAt": "2026-02-10T06:15:16.000Z",
  "editedAt": null,
  "score": 590,
  "upvoteRatio": 0.68,
  "numComments": 292,
  "numCrossposts": 0,
  "awards": 0,
  "gilded": 0,
  "flair": "Humor",
  "flairCss": null,
  "postHint": null,
  "domain": "self.castiron",
  "isSelf": true,
  "isVideo": false,
  "isGallery": false,
  "isNsfw": false,
  "isSpoiler": false,
  "isOriginalContent": false,
  "locked": true,
  "stickied": false,
  "pinned": false,
  "archived": false,
  "distinguished": null,
  "quarantine": false,
  "thumbnail": null,
  "media": null,
  "crosspostParent": null,
  "crosspostParentUrl": null,
  "removedByCategory": null,
  "suggestedSort": null,
  "removedBy": null,
  "bannedBy": null,
  "removalReason": null,
  "modReasonTitle": null,
  "isRobotIndexable": true,
  "hidden": false,
  "edited": false,
  "mediaType": "text",
  "hasMedia": false,
  "videoUrl": null,
  "galleryCount": null,
  "galleryImages": null,
  "ageHours": 5175.17,
  "scorePerHour": 0.114,
  "commentsPerHour": 0.056,
  "engagementTotal": 882,
  "commentToScoreRatio": 0.495,
  "isHighEngagement": false,
  "titleLength": 48,
  "bodyLength": 815,
  "wordCount": 173,
  "outboundUrlHost": null,
  "searchTerm": "cast iron",
  "searchInput": "cast iron",
  "scrapedAt": "2026-09-13T21:25:16.049Z"
}
```

A comment row:

```json
{
  "dataType": "comment",
  "id": "o4kqgjs",
  "fullName": "t1_o4kqgjs",
  "url": "https://www.reddit.com/r/castiron/comments/1r0t58w/used_my_cast_iron_so_much_its_bad_for_my_health/o4kqgjs/",
  "permalink": "/r/castiron/comments/1r0t58w/used_my_cast_iron_so_much_its_bad_for_my_health/o4kqgjs/",
  "postId": "1r0t58w",
  "parentId": "t3_1r0t58w",
  "parentCommentId": null,
  "depth": 0,
  "body": "Donate blood and use cast iron all you want.",
  "bodyHtml": "<div class=\"md\">…</div>",
  "author": "Normal_Fun",
  "authorId": "t2_1p3p8702",
  "authorFlair": null,
  "authorIsPremium": false,
  "isSubmitter": false,
  "subreddit": "castiron",
  "subredditId": "t5_2s8x6",
  "createdAt": "2026-02-10T07:00:49.000Z",
  "editedAt": null,
  "score": 353,
  "scoreHidden": false,
  "controversiality": 0,
  "awards": 0,
  "gilded": 0,
  "locked": false,
  "stickied": false,
  "distinguished": null,
  "collapsed": false,
  "collapsedReason": null,
  "archived": false,
  "removedByCategory": null,
  "postTitle": "Used My Cast Iron So Much It's Bad For My Health",
  "parentKind": "post",
  "edited": false,
  "ageHours": 5174.41,
  "scorePerHour": 0.068,
  "commentsPerHour": 0,
  "engagementTotal": 353,
  "commentToScoreRatio": 0,
  "isHighEngagement": false,
  "titleLength": null,
  "bodyLength": 44,
  "wordCount": 9,
  "outboundUrlHost": null,
  "searchTerm": "cast iron",
  "searchInput": "cast iron",
  "scrapedAt": "2026-09-13T21:25:16.049Z"
}
```

A few things to know before you build on these rows:

- Comments found by keyword comment search have `source: "search"`. That's how you tell them from comments read out of a thread.
- User rows (`dataType: "user"`) have karma, account creation date and verification. Community rows (`dataType: "community"`) have subscribers, description and type.
- A community row also has `descriptionHtml`, the long `sidebar` text, `over18`, `lang`, `icon` and `banner` image links, `headerTitle`, `submitText`, `submissionType`, `advertiserCategory`, `suggestedCommentSort`, and the community's settings as true/false flags: `allowImages`, `allowVideos`, `allowVideogifs`, `allowGalleries`, `allowPolls`, `spoilersEnabled`, `originalContentTagEnabled`, `linkFlairEnabled`, `wikiEnabled`, `restrictPosting` and `restrictCommenting`.
- `removedBy`, `bannedBy`, `removalReason` and `modReasonTitle` are moderator columns. Reddit doesn't publish them to outside readers, and they were empty on all rows in our release check. `removedByCategory` is the public one.
- Any custom labels you set are added to each row as extra columns.

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.001 | $0.001 | $0.001 | $0.001 |
| `result-item`, per post, feed comment, community or user returned | $0.0012 | $0.00108 | $0.00096 | $0.00084 |
| `thread-comment`, per comment read from a post's comment tree | $0.0006 | $0.00054 | $0.00048 | $0.00042 |
| `comment-search-item`, per comment found by keyword comment search | $0.0012 | $0.00108 | $0.00096 | $0.00084 |

Enterprise plans pay the Business price.

**$1.20 per 1,000 results** on the Free plan, $0.84 on Business, for posts, feed comments, users and communities. Comments from a post's comment tree are $0.60 per 1,000 ($0.42 on Business), and comment-search hits are $1.20 per 1,000 ($0.84 on Business). That's the whole price: there are no proxy charges or platform usage on top. Duplicates, already-seen items and filtered items are free.

- 10,000 comments from a handful of big threads: $0.001 + 10,000 × $0.0006 = **$6.001** ($4.201 on Business).
- A daily brand monitor over five subreddits, about 50 new posts and 100 comments from their threads a day: 30 × ($0.001 + 50 × $0.0012 + 100 × $0.0006) = **$3.63** for the month ($2.55 on Business).
- 1,000 comment-search hits for a keyword: $0.001 + 1,000 × $0.0012 = **$1.201** ($0.841 on Business).

Apify's Free plan includes $5 of credits a month, which covers about 4,100 posts in runs of 100, or about 8,300 comments read from threads, before you pay anything.

### How fast is it, and how far back can you go?

| Run | Result |
|---|---|
| One search, a 50-post subreddit feed with comments, a 2,571-comment thread capped at 1,500, one user profile, plus author and community records | 3,916 results (107 posts, 3,791 comments, 10 users, 8 communities) in 15 seconds |
| Comment search, newest, cap 60 | 60 comments in 7 seconds, each a full comment record |
| Two subreddits, 40 top posts of the week each, up to 20 comments per post | 1,211 results (80 posts, 1,131 comments) in 7 seconds |
| Eight subreddits, 20 top posts of the month each, up to 10 comments per post | 1,742 results in 26 seconds |

These are whole runs on Apify, start-up included. The last two were measured on 2 and 3 October 2026.

Big jobs are paced to Reddit's published request rate. A run that reads many comment trees gets through roughly 6,000 posts with comments an hour, and posts alone go far faster. Comment trees for a page of posts are fetched together, which is why comments add little time per post.

How far back you can go is Reddit's call. It ends any listing, whether search, feed or user history, at roughly 1,000 items. To reach further, narrow the time window or split the query. Comment trees aren't subject to that cap and expand as deep as "Max comments per post" allows.

### Monitor Reddit daily, or call it from your own code

For brand monitoring we'd set it up like this: an Apify Schedule that runs once a day, the subreddits you care about on the New feed, and a name in "Only-new store name". Each run then returns only the posts and comments you haven't had yet. A webhook fires when the run ends, and the new rows can go straight into Slack or a Google Sheet. Zapier, Make and Airbyte connect the same way.

From code, one request runs the actor and returns the dataset:

```
POST https://api.apify.com/v2/acts/boncross~reddit-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN
```

Send the input JSON as the body. That call suits short runs, and the standard run endpoints handle long ones. The `apify-client` packages on NPM and PyPI wrap both.

An AI agent can read Reddit through it too. Point an MCP client at `mcp.apify.com` and reference the actor as `boncross/reddit-scraper`. Because each row says whether it's a post, comment, user or community, an agent can route the results without guessing.

### Limitations

- Reddit ends any listing at roughly 1,000 items.
- Reddit search has no date filter of its own. The date fields are applied to the rows after Reddit answers, which means a date-filtered search sorted by anything other than newest reads up to Reddit's cap first.
- Deleted and removed content is returned as Reddit serves it, with `[deleted]` or `[removed]` bodies and `removedByCategory` when Reddit gives a reason. The moderator-only columns stay empty.
- There's no sentiment analysis or AI tagging. You get Reddit's data and the engagement figures computed from it.
- Access depends on Reddit continuing to make this data available. If that changes, runs return error rows until access is restored.
- A search, feed or URL that can't be read, or a URL the actor doesn't recognise, gives you a row with `input` and an `error` message. Those rows aren't charged.

### FAQ

#### Is it legal to scrape Reddit?

The actor collects publicly visible posts and comments. That content includes personal data such as usernames, which means you need a lawful basis to collect and store it. You're responsible for complying with Reddit's terms and applicable law.

#### Do I need proxies or a Reddit account?

Neither. Posts, comments, feeds, users and communities need no proxy at all. Comment search has its proxy cost inside the per-hit price, and there's still nothing for you to configure.

#### Why did I get posts but no comments?

"Max comments per post" is 0 until you change it, and 0 means posts only. Set it to the number of comments you want from each post, up to 5,000.

#### How do I get all the comments on one post?

Paste the post's URL into Start URLs and set "Max comments per post" high enough to cover the thread. The tree is expanded through its collapsed branches, down to the reply depth you allow.

#### How do I find comments that mention a keyword?

Switch on "Also search comments" and set "Max comments per search". You get full comment records, charged at the comment-search rate of $1.20 per 1,000 on the Free plan ($0.84 on Business).

#### How do I pull posts from a date range?

Fill in "Posts posted after" and "Posts posted before". For comments, use the two "Comments posted" fields. On a newest-first listing the run stops as soon as it passes your earlier date, and you aren't charged for anything outside the range.

#### Can I keep only posts with a certain flair, or that mention a word?

"Only posts with flair" keeps posts whose flair matches one you name, ignoring case. "Filter keywords" matches titles, post bodies and comment bodies, and "Keyword mode" decides whether a row needs any of your words, all of them, or none. With comments switched on, the keyword filter keeps only the comments in a thread that mention your terms. Filtered items aren't charged.

#### How do I get only what's new since the last run?

Give "Only-new store name" any name and schedule the run. The actor remembers what it has returned under that name, and later runs give you only new posts, comments and profiles.

#### Why does my search stop at about 1,000 posts?

That's Reddit's ceiling on any one listing. Split a broad search into narrower ones (by subreddit, by time window, or by sort) and run them together. Results that turn up in two of them are returned and charged once.

### More from BonCross

- [Reed.co.uk Jobs Scraper](https://apify.com/boncross/reed-jobs-scraper): Reed.co.uk jobs by keyword and location with Reed's own filters: salary, contract,…
- [UK Government & NHS Jobs Scraper](https://apify.com/boncross/uk-public-sector-jobs): NHS Jobs, Civil Service Jobs (every department) and Ministry of Justice vacancies in…
- [Workday Jobs Scraper](https://apify.com/boncross/workday-jobs): Every open job from a Workday careers board.
- [Ashby Jobs Scraper](https://apify.com/boncross/ashby-jobs): Every open job on an Ashby careers board.
- [ATS Jobs Scraper](https://apify.com/boncross/ats-jobs): Jobs from any company careers page.
- [CharityJob Scraper](https://apify.com/boncross/charityjob-jobs): UK charity and non-profit jobs from CharityJob.

### Your feedback

Missing a field Reddit shows, or got a thread that looks short? Send us the link you ran on the Issues tab in Apify Console. We read every report and answer there. If there's a feed, a sort or a column you'd want added, ask for it in the same place.

# Changelog

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

# Actor input Schema

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

Keywords to search for posts across Reddit, or inside one subreddit if you set one below. Reddit search syntax works: quotes, subreddit:, author:, title:, self:yes, flair:.

## `searchCommunities` (type: `boolean`):

For each search term, also return matching subreddits as community records.

## `searchUsers` (type: `boolean`):

For each search term, also return matching user profiles.

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

Subreddit names or URLs whose feed to read, for example TrueChefKnives, r/AskReddit or https://www.reddit.com/r/pasta/.

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

Any Reddit URLs. A post returns the post and its comments, a subreddit or feed returns its posts, a user profile returns the profile plus that user's posts and comments (a /submitted or /comments link narrows it), and a search results page returns the search.

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

A run-wide ceiling across every target. The per-target limit above applies to each one separately, so ten targets at 50 each returns 500; set this to cap the total. Zero means no run-wide limit. Rows that report an input the actor could not resolve are not counted here and are never charged for.

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

Cap on posts per search, subreddit or URL. Reddit itself stops any listing at about 1,000.

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

Order of search results. Comment search only knows relevance, new and top; hot and comments fall back to relevance there.

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

Only posts from this period.

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

Restrict every search term to this subreddit, by name or URL. Leave empty to search all of Reddit.

## `feedSort` (type: `string`):

Which feed to read for each subreddit. Latest comments returns the subreddit's newest comments across all its threads, as comment rows, capped by Max posts.

## `feedTime` (type: `string`):

Time window for the Top and Controversial feeds.

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

For user profile URLs: posts and comments together, posts only, or comments only. A /submitted or /comments link overrides it.

## `userSort` (type: `string`):

For user profile URLs. Top and Controversial use the Top and Controversial time window above.

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

Keep posts created on or after this date or datetime, for example 2026-08-01 or 2026-08-01T12:00:00Z. On newest-first listings the actor stops paging once it reaches older posts. Reddit search has no date parameter, so other sorts still read pages up to Reddit's cap before filtering.

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

Keep posts created on or before this date or datetime. A bare date means the end of that day.

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

Keep comments created on or after this date or datetime.

## `commentedBefore` (type: `string`):

Keep comments created on or before this date or datetime.

## `onlyWithFlair` (type: `array`):

Keep only posts whose flair matches one of these, ignoring case. Posts without a matching flair are dropped before any comments are fetched.

## `filterKeywords` (type: `array`):

Words or phrases, matched ignoring case, against the post title and text and against comment text. Dropped items are not charged. With comments on, this keeps only the comments in a thread that mention your terms.

## `filterKeywordMode` (type: `string`):

any keeps items with at least one keyword, all needs every keyword, exclude drops items that contain any of them.

## `includeNsfw` (type: `boolean`):

Keep posts, comments and communities marked over 18.

## `searchComments` (type: `boolean`):

For each search term, also return matching comments sorted by relevance, new or top within the time window. Hits come back as full comment records.

## `maxCommentsPerSearch` (type: `integer`):

Cap on comments returned per search term when comment search is on. Reddit gives about 9 per page.

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

0 means posts only. Anything higher expands the full comment tree, including the collapsed branches, up to this many comments per post (at most 5,000). With a comment date, keyword or only-new filter, a tree stops being read once five pages of comments in a row match nothing, and a comment search stops after five such pages.

## `maxCommentDepth` (type: `integer`):

Deepest reply level to keep. 0 keeps top-level comments only.

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

How Reddit ranks the comment tree before it is read.

## `includeUsers` (type: `boolean`):

Return a user record with karma, account age and description for each distinct author seen, up to Max users.

## `maxUsers` (type: `integer`):

Cap on author profiles fetched per run.

## `includeCommunities` (type: `boolean`):

Return a community record with subscribers, description and type for each subreddit seen.

## `customLabels` (type: `object`):

Key and value strings added to every output record, for example {"campaign": "launch-sept"}, so you can tag runs.

## `dedupStoreName` (type: `string`):

Name of a key-value store that remembers what was returned. Set it on a scheduled run and each run yields only new posts, comments and profiles.

## `includeRawData` (type: `boolean`):

Attach Reddit's original JSON as raw on posts, communities and users. It makes records large.

## `maxConcurrency` (type: `integer`):

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## Actor input object example

```json
{
  "searches": [
    "nigara hamono"
  ],
  "searchCommunities": false,
  "searchUsers": false,
  "maxItems": 0,
  "maxPosts": 100,
  "searchSort": "relevance",
  "searchTime": "all",
  "feedSort": "new",
  "feedTime": "week",
  "userContent": "overview",
  "userSort": "new",
  "filterKeywordMode": "any",
  "includeNsfw": true,
  "searchComments": false,
  "maxCommentsPerSearch": 100,
  "maxCommentsPerPost": 0,
  "maxCommentDepth": 50,
  "commentSort": "confidence",
  "includeUsers": false,
  "maxUsers": 50,
  "includeCommunities": false,
  "includeRawData": false,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `dataset` (type: `string`):

Reddit results: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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 = {
    "searches": [
        "nigara hamono"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/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 = { "searches": ["nigara hamono"] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/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 '{
  "searches": [
    "nigara hamono"
  ]
}' |
apify call boncross/reddit-scraper --silent --output-dataset

```

## MCP server setup

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