# Reddit Search Scraper: Keywords & Mentions, $2/1K Posts (`actorforgehq/reddit-search-scraper`) Actor

Input: keywords, optionally in one subreddit, with sort order and time window. Output: one JSON row per matching post with title, author, subreddit, score, comment count, permalink and UTC date. Monitoring mode returns only posts new since your last run. $2 per 1,000 posts.

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

## Pricing

from $2.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 Search Scraper: Keywords & Mentions, $2/1K Posts

Search **all of Reddit or one subreddit by keyword** and get the matching posts as clean JSON:
title, author, subreddit, score, comment count, permalink and UTC date. Turn on comment search
to get matching comments too. Use only-new mode on a schedule to monitor mentions of a brand, a
product or a topic and get just the new hits each time.

It reads the same public search pages Reddit serves to a logged-out visitor's browser, over plain
HTTP with no page rendering, at a fixed pace that stays inside the request quota Reddit itself
announces for these pages.

This is the search member of our Reddit family. It shares its code, its field names and its
output format with the [Reddit Data Scraper](https://apify.com/actorforgehq/reddit-data-scraper),
the [Reddit Subreddit Scraper](https://apify.com/actorforgehq/reddit-subreddit-scraper) and the
[Reddit Comments Scraper](https://apify.com/actorforgehq/reddit-comments-scraper), so an input or
a pipeline written for one works with the others.

### What you get

One row per matching post:

```json
{
  "type": "post",
  "id": "1x5yu7p",
  "subreddit": "webdev",
  "author": "some_redditor",
  "title": "Which headless browser do you use for scraping in 2026?",
  "score": 44,
  "numComments": 21,
  "permalink": "https://www.reddit.com/r/webdev/comments/1x5yu7p/which_headless_browser_do_you_use_for_scraping/",
  "createdUtc": "2026-10-15T04:28:32.499Z",
  "nsfw": false,
  "spoiler": false,
  "stickied": false
}
```

Search results carry no post text and no external link: a result card shows the title, the
author, the subreddit, the score, the comment count, the date and the permalink, and that is what
a post row holds. For the body of a post, run the
[Reddit Comments Scraper](https://apify.com/actorforgehq/reddit-comments-scraper) on its
permalink: the post comes back as an extra row with its text.

With **Search comments too** on, matching comments come as extra rows with `type: "comment"`:
`id`, `postId`, `subreddit`, `author`, `score`, `body` (plain text), `createdUtc` and `permalink`.
`depth` is always 0 and there is no `parentId`: search results do not show where a comment sits
in its thread. Deleted authors come through as `[deleted]`, exactly as Reddit shows them.

### Input

| Field | Type | Description |
|---|---|---|
| `searches` | string\[] | Search phrases, e.g. `["web scraping", "headless browser"]`. Each phrase is a separate search. `searchTerms` is accepted as an alias. |
| `searchCommunityName` | string | Limit the search to one subreddit, name without `r/`. Empty searches all of Reddit. `withinCommunity` is accepted as an alias. |
| `sort` | string | `new` (default), `relevance`, `hot`, `top` or `comments` (most comments). |
| `time` | string | `hour`, `day`, `week`, `month`, `year` or `all` (default). |
| `maxItems` | integer | Max posts per phrase (default 100, hard cap 1,000). One request returns about 7 posts. With comment search on, the same limit applies separately to comments per phrase. |
| `postedAfter` / `postedBefore` | string | ISO date bounds (UTC). With `sort: "new"` the Actor stops paging at the first result older than `postedAfter`, so a narrow window costs fewer requests. With other sorts the bounds are applied after fetching. |
| `searchComments` | boolean | Default `false`. Also search comments for the same phrases and save them as comment rows, charged as comments. |
| `includeNSFW` | boolean | Default `false`. Results from posts marked NSFW are skipped unless you opt in. |
| `onlyNew` | boolean | Default `false`. Skip rows this Actor already gave you from the same searches in earlier runs. See [Only new since last run](#only-new-since-last-run). |
| `proxyConfiguration` | object | Defaults to Apify **residential proxies** with no country pin, which is the supported configuration. |

Example:

```json
{
  "searches": ["web scraping", "headless browser"],
  "searchCommunityName": "webdev",
  "sort": "new",
  "postedAfter": "2026-10-01",
  "maxItems": 200
}
```

### How to use it

1. Click **Try for free** or **Start** on this page.
2. Enter one or more search phrases and, optionally, a subreddit.
3. Pick a sort order and a time window, set date bounds and **Max posts per phrase** if you need
   them, and turn on comment search if you need it.
4. Run it. Posts land in the dataset as one row each. Export them as JSON, CSV or Excel, or pull
   them over the API.

To monitor mentions on a schedule, use Apify **Schedules** with `onlyNew: true`. Pricing has no
per-run start fee, so a scheduled check costs exactly the rows it delivers. To call it from code,
use the [Apify API](https://docs.apify.com/api/v2) or an official client. AI agents can call it
through the **Apify MCP server**: the description and the input fields above are written to be
read by an agent.

### Only new since last run

Turn on **Only new since last run** (`onlyNew: true`) for monitoring. Here "new" means "not
delivered to you before from the same search", not "newer by time": with `relevance` or `top` an
older post you have not received yet still counts as new.

- Rows you already got from a search are not written to the dataset and not charged.
- `maxItems` counts new rows only. Paging stops at the first page where every result was already
  delivered to you, and never goes past 60 pages per search. A quiet search costs one request and
  no row charges.
- The list of delivered rows lives in a named key-value store in your own Apify account, called
  `reddit-search-only-new-` plus a code made from your searches (the run log shows the exact
  name). Each set of searches (phrases with their subreddit, sort and time window) gets its own
  store, so changing a phrase or the sort starts a fresh list for the set. Filters (dates, NSFW,
  `maxItems`) do not. The store does not expire. The latest 2,000 rows per search are
  remembered. This Actor keeps its own list, separate from our other Reddit Actors.
- The list is saved once, at the end of the run. If a run is aborted or times out, the list stays
  as it was, so the next run delivers again what that run had delivered. For the same reason, do
  not let two runs with the same input overlap.
- To start over, delete that store in Apify Console under **Storage**, **Key-value stores**.

### Pricing

Pay-per-event, two events, nothing else:

| Event | Rate |
|---|---|
| `post-scraped` | **$2.00 per 1,000** ($0.002 each) |
| `comment-scraped` | **$2.00 per 1,000** ($0.002 each), only with comment search on |
| Run start | **free, there is no start event** |

**What you get for $1:** 500 posts. Platform usage (compute, proxy) is charged to us, not to
you, so the per-row price is the whole bill. A daily check of two phrases that finds 15 new posts
costs $0.03, every day, with no per-run surcharge. Rates are as
of the last README update. The Store page stays authoritative.

### Limits (honest)

- **Reddit's search decides what matches.** The Actor returns what Reddit's own search shows a
  logged-out visitor for your phrase, in the order Reddit ranks it. It is not an exhaustive scan
  of every post that contains the words. Reddit's search ends after a few hundred results per
  phrase, and the Actor pages at most 60 times per phrase, so `maxItems` above about 400 is
  rarely reached.
- **No post text and no external link.** A search result card carries title, author, subreddit,
  score, comment count, date and permalink, and that is what a post row holds. The body and the
  external link live on the post's page, which this Actor does not open. For them, run the Reddit
  Comments Scraper on the permalink (the post comes as an extra row with its text) or the Reddit
  Data Scraper.
- **Searching inside a subreddit keeps only that subreddit.** Reddit pads an in-subreddit search
  with posts from neighbouring communities; the Actor drops those, so a page can yield fewer than
  7 posts.
- **Date bounds reduce requests only with sort New.** It is sorted by time, so the Actor can stop
  at the first result older than `postedAfter`. The other sorts are not sorted by time, so there
  the bounds filter results after fetching. When a date bound is set, a result whose timestamp
  cannot be read is dropped rather than guessed.
- **Comment search returns flat comments.** A comment from search has no thread position, so
  `depth` is 0 and there is no `parentId`. For a whole thread use the Reddit Comments Scraper.
- **Text comes as plain text.** Bodies keep their paragraphs, list items and code blocks, but not
  formatting such as bold, italics or link targets.
- **A subreddit that does not exist gives an empty result.** Reddit serves such searches as
  ordinary pages with no results, so that phrase ends with 0 rows and no charge, not with an
  error. Check the spelling if a search comes back empty.
- **No login, no captcha solving.** The Actor reads only what Reddit serves to any logged-out
  visitor. It opens a session the way a browser does, completes Reddit's lightweight automated
  visitor check (a short script every visitor's browser runs), and then reads public pages with
  that session. If Reddit refuses a session, the Actor opens a new one from a fresh address. It
  fails honestly rather than fabricate data.
- If more than 5% of requests in a run fail, the run log says so loudly. A run in which every
  fetch failed is marked **failed**, not "succeeded with 0 items". A run whose filters
  legitimately match nothing (say, a strict date window) still succeeds, with an empty dataset
  and an empty bill.

### Rate-limit etiquette (built in, with numbers)

- **At most 20 requests per minute**, with a hard 3-second spacing between requests. Reddit
  announces a quota of 225 requests per 10 minutes for these pages in its `x-ratelimit-*`
  headers. A 3-second spacing means at most 200 requests per 10 minutes, so the Actor stays
  inside that quota by design.
- One search request carries about 7 posts, or 6 to 10 comments. A 100-post search is about 15
  requests, under a minute.
- On an HTTP `429` the Actor **waits 30 seconds**, opens a fresh session and retries. On any
  other transient refusal it backs off (3 s, then 6 s, then 9 s), rotates to a fresh proxy
  session and retries, at most 3 times.
- If five requests in a row fail after all retries, the run stops instead of grinding through
  the rest of the plan.

### FAQ

**Do I need a Reddit account or an API key?**
No. The Actor reads only publicly available data as a logged-out visitor, never logs in, and
does not use Reddit's developer API or anyone's credentials.

**How is this different from the Reddit Data Scraper?**
Same code, same output rows, narrower job. This Actor searches only, adds the sort orders Reddit's
search offers, stops early on `new` when you set a date, searches comments on request, and is
priced per post. The Reddit Data Scraper also reads subreddit feeds, post pages with their first
comments and user history.

**Can I monitor mentions of my brand?**
Yes. Put the brand name in `searches`, set `sort: "new"` and `onlyNew: true`, and run the Actor on
a schedule. Each run returns only the posts and comments that appeared since the previous run.

**Why do I get fewer than 7 posts per page?**
Inside a subreddit, Reddit pads results with neighbouring communities, which the Actor drops. The
NSFW filter and date bounds also remove results after fetching.

**Does it use a browser?**
Not for the data. Pages are fetched over plain HTTP and read straight from the HTML Reddit
serves, with no rendering. A real Chrome is kept on standby only as a last resort for opening a
session, when no page gives one over plain HTTP.

**Are NSFW results included?**
Only if you set `includeNSFW: true`. The default is off.

**Where is my data stored?**
In your run's dataset on your Apify account, under your control. The Actor keeps no copy of
scraped data outside your run and sends nothing to any third party. With **Only new since last
run** on, it also keeps the ids of rows it already gave you in a key-value store in your account
(see above), so you can delete them at any time.

### Legal

This is an **unofficial** scraper. It is not affiliated with, endorsed by, or connected to
Reddit, Inc. in any way, and it does not use Reddit's developer API. It reads only data that
Reddit serves publicly to any logged-out visitor: no login, no credentials, no captcha solving.
Website terms of service are a contractual matter between a website and its visitors, not
criminal law. You are responsible for ensuring that your use of the collected data complies with
the laws that apply to you and with Reddit's terms. Post and comment content belongs to its
authors.

### Personal data

Reddit is a pseudonymous platform: the `author` field contains the public username a person
chose to publish under, not their real identity. This Actor collects no emails, no real names,
no private messages, and performs no deanonymization. It stores exactly what any visitor sees
on a public page. Scraped data lives only in your own Apify dataset and is not retained by us
outside your run. If the data you collect contains personal data under the laws of your
jurisdiction (for example the GDPR), you act as its controller: it is your responsibility to
have a legal basis for processing and to honor data-subject requests, including deletion.

### Rate this Actor

If this Actor saved you time, a short rating or review on its Store page helps other people find
it. Missing a field, or did something break? Open the **Issues** tab on this page and tell us.

### Need a custom scraper?

We can build a custom version of this Actor, for example with extra fields, other filters or another output format, or a new Actor for a site we do not cover yet. It runs on Apify like this one. Email actorforge.hq+orders@gmail.com with the site, the data you need and how often you need it.

### Other Actors by ActorForge

- [Reddit Data Scraper](https://apify.com/actorforgehq/reddit-data-scraper): subreddit feeds,
  posts with their first comments, keyword search and user history in one Actor.
- [Reddit Subreddit Scraper](https://apify.com/actorforgehq/reddit-subreddit-scraper): the hot,
  new, top and rising posts of any subreddit, with date bounds and only-new mode.
- [Reddit Comments Scraper](https://apify.com/actorforgehq/reddit-comments-scraper): the whole
  comment thread of a post, with "more replies" branches and deep reply chains.
- [Reddit User Scraper](https://apify.com/actorforgehq/reddit-user-scraper): a user's public
  posts and comments, newest first, with the profile card.
- [Lazada Reviews Scraper](https://apify.com/actorforgehq/lazada-reviews-scraper): product
  reviews, ratings and buyer media from all six Lazada marketplaces.
- [Wildberries Scraper](https://apify.com/actorforgehq/wildberries-scraper): products, prices
  and reviews from Wildberries as clean, schema-validated JSON.
- [Avito Real Estate Scraper](https://apify.com/actorforgehq/avito-real-estate-scraper): full
  property inventory from Avito with freshness stamps.

### Changelog

- **0.1** (October 2026): first release. Keyword search across Reddit or inside one subreddit,
  five sort orders, time window, date bounds with early stop on `new`, comment search on
  request, only-new mode, $2 per 1,000 posts and $2 per 1,000 comments, no start fee.

# Actor input Schema

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

Search phrases, one per line, for example web scraping. Each phrase is a separate search with the sort order and time window below.

## `searchCommunityName` (type: `string`):

Limit the search to one subreddit, name without r/, for example webdev. Leave empty to search all of Reddit.

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

The order Reddit uses to rank results: new (default), relevance, hot, top or most comments. With new, a date in Posts after also stops paging early.

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

Keep only results from the past hour, day, week, month, year or all time (default). Reddit applies it to its own ranking.

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

How many posts to keep per keyword (default 100, hard cap 1,000). One search request returns about 7 posts, and Reddit's search itself ends after a few hundred results. With Search comments on, the same limit applies separately to comments per keyword.

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

Keep only posts submitted on or after this date (UTC). With sort New the Actor also stops paging at the first result older than this date, so a narrow window costs fewer requests. With other sorts the date is applied after fetching.

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

Keep only posts submitted on or before this date (UTC). Applied after fetching.

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

Off by default. Turn it on to also search comments for the same keywords and save the matching comments as rows with type "comment" (author, body, score, date, permalink), charged as comments.

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

Off by default: results from posts marked NSFW are skipped unless you turn this on.

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

Skip posts and comments this Actor already gave you in earlier runs with the same keywords, subreddit, sort and time window: they are not saved again and not charged. New means not delivered to you before, not newer by time. With this on, Max posts counts new rows only, and paging stops at the first page where everything was already delivered. The list of delivered rows is kept in a key-value store in your own Apify account named reddit-search-only-new- plus a code made from your searches (the run log shows the exact name). It does not expire. To start over, delete that store in Storage.

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

Residential proxies are the default and the supported configuration. No country pin is needed. The run rotates proxy sessions and visitor cookies whenever Reddit refuses one.

## Actor input object example

```json
{
  "searches": [
    "web scraping",
    "headless browser"
  ],
  "searchCommunityName": "webdev",
  "sort": "new",
  "time": "all",
  "maxItems": 100,
  "postedAfter": "2026-01-01",
  "postedBefore": "2026-06-01",
  "searchComments": false,
  "includeNSFW": false,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per matching post: title, author, subreddit, score, comment count, permalink and UTC date; comment rows carry author, body, score and permalink.

# 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": [
        "web scraping"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorforgehq/reddit-search-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": ["web scraping"] }

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

```

## MCP server setup

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