# Reddit Search Scraper - Keyword Posts, Date Range, No Login (`benthepythondev/reddit-search-scraper`) Actor

Returns Reddit posts that match your keywords, across Reddit or inside chosen subreddits: title, text, score, comment count, author, flair and links. Reads past the 240 posts one Reddit search shows, with a date range, exact-word matching and an only-new mode for monitoring. No login, no API key.

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

## Pricing

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

## 🔎 Reddit Search Scraper

Returns the Reddit posts that match your keywords, across all of Reddit or inside the subreddits you name, without a Reddit login or API key. One row per post: title, text, score, upvote ratio, comment count, author, subreddit, flair, media links and date. It reads past the 240 posts one Reddit search shows, cuts out a date range, can insist on every word, and has an only-new mode for monitoring.

**Price:** until October 18, 2026 $3.00 per 1,000 posts on the Apify Free plan ($2.55 from Gold up); from October 19 $1.50 ($1.28 from Gold up). A query without results costs nothing. Export to JSON, CSV or Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🔎 What is the Reddit Search Scraper?

It asks Reddit's own search through Reddit's API, so no browser runs and 512 MB of memory is enough. A default run of ten posts takes about five seconds.

One Reddit search ends after about 240 posts. Another order (new, top, most comments, hot) or time range of the same search is another list with partly other posts. When you ask for more than the first list holds, the Actor reads those lists too and saves every post once. For "web scraping" the first list held 238 posts and all lists together 1,194; a narrow search inside one subreddit had all of its 136 posts in the first list.

#### What data does it extract?

- **Post:** id, title, text (plain and Markdown), link and permalink, flair, type flags (self, video, adult, spoiler, pinned, locked)
- **Engagement:** score, upvote ratio, number of comments, awards
- **Author and subreddit**
- **Media:** preview images with sizes, thumbnail, linked domain
- **Dates:** creation time (UTC)
- **For AI use:** word count and estimated token count of the text
- **Search:** the query that found the post

#### What users of Reddit scrapers ask for, and what this Actor does

The issue pages of the four most used Reddit Actors on Apify were read on October 4, 2026:

| Asked for there | Here |
|---|---|
| Runs blocked by Reddit (403), empty runs | Reads Reddit's API instead of its web pages. A subreddit that is private or does not exist is named in the status message and the run still succeeds |
| A start and end date | `postedAfter` and `postedBefore`; with a date limit the newest-first list is read first and left when the date is reached |
| More than a few hundred results | Reddit's other lists are read as well: 1,194 different posts for one broad query instead of 238 |
| Results that do not contain the keywords | `strictMatch` keeps posts whose title or text has every word: 300 of 300 in a test, against 211 of 237 without it |
| Bills that grow beyond the limit, double charges | A limit is exact, a post found twice is saved once, and a run stops at its maximum charge with what it has saved |
| Adult communities missing from search | `includeNSFW`: 60 of 100 results of one test query were adult posts with it, none without |

### ⬇️ Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `queries` | array | | Words or phrases, each searched on its own |
| `subreddits` | array | all of Reddit | Search only inside these subreddits |
| `sort` | string | `relevance` | `relevance`, `new`, `top`, `comments`, `hot`: the order of the first list |
| `timeFilter` | string | `all` | `hour`, `day`, `week`, `month`, `year`, `all` |
| `maxResultsPerQuery` | integer | 25 | Posts per query (and per subreddit), up to 5,000 |
| `strictMatch` | boolean | false | Keep only posts that contain every word of the query |
| `postedAfter` | string | | A day (YYYY-MM-DD) or a period back from now (`12 hours`, `7 days`) |
| `postedBefore` | string | | Upper end of a date range (YYYY-MM-DD) |
| `includeNSFW` | boolean | false | Include posts marked as adult content |
| `onlyNew` | boolean | false | Skip everything an earlier run with the same monitor name delivered |
| `monitorId` | string | | Name of that memory |

#### Example input

Two brand names, everything from the last week:

```json
{
  "queries": ["apify", "crawlee"],
  "postedAfter": "7 days",
  "maxResultsPerQuery": 200
}
```

A topic inside two subreddits, exact words only:

```json
{
  "queries": ["standing desk"],
  "subreddits": ["BuyItForLife", "homeoffice"],
  "strictMatch": true,
  "maxResultsPerQuery": 300
}
```

A mention monitor for a schedule (every hour or every day):

```json
{
  "queries": ["your brand"],
  "maxResultsPerQuery": 100,
  "onlyNew": true,
  "monitorId": "brand-mentions"
}
```

Input names of other Reddit Actors are read as well: `searches`, `searchTerms`, `searchCommunityName`, `withinCommunity`, `subredditName`, `searchSort`, `time`, `searchTime`, `timeframe`, `maxItems`, `maxPostCount`, `maxPostsCount`, `maxPosts`, `postDateLimit`, `dateFrom`, `dateTo` and `strictSearch`.

### ⬆️ Output

One row per post (the text is shortened here):

```json
{
  "id": "1wi5ego",
  "title": "What web scraping tools are you using right now?",
  "url": "https://www.reddit.com/r/AI_Agents/comments/1wi5ego/what_web_scraping_tools_are_you_using_right_now/",
  "permalink": "https://www.reddit.com/r/AI_Agents/comments/1wi5ego/what_web_scraping_tools_are_you_using_right_now/",
  "selftext": "Tired of constantly babysitting and checking if nothing broke, o started looking for some tools. I'm comparing a few options for pulling data from websites …",
  "selftext_markdown": "Tired of constantly babysitting and checking if nothing broke, o started looking for some tools. I'm comparing a few options for pulling data from websites …",
  "author": "OctoberFyre",
  "subreddit": "AI_Agents",
  "subreddit_id": "t5_8b5cvj",
  "score": 12,
  "upvote_ratio": 0.89,
  "num_comments": 34,
  "is_self": true,
  "is_video": false,
  "post_hint": null,
  "domain": "self.AI_Agents",
  "thumbnail": null,
  "images": [],
  "created_utc": "2026-09-16T18:25:10",
  "total_awards_received": 0,
  "link_flair_text": "Discussion",
  "over_18": false,
  "spoiler": false,
  "stickied": false,
  "locked": false,
  "word_count": 68,
  "token_count": 88,
  "query": "web scraping",
  "scraped_at": "2026-10-04T15:08:02.863030+00:00"
}
```

The run also writes a `SUMMARY` record with the number of posts per query and the queries that found nothing.

### 💰 What a run costs

| Apify plan | Per 1,000 posts until October 18, 2026 | From October 19, 2026 |
|---|---|---|
| Free | $3.00 | $1.50 |
| Bronze | $2.85 | $1.43 |
| Silver | $2.70 | $1.35 |
| Gold, Platinum, Diamond | $2.55 | $1.28 |

Apify's standard start event ($0.00005) is the only other charge; proxies are included. Not charged: a query without results, a subreddit that does not exist, a post outside your date limits, a post already delivered in only-new mode, and a post a second query finds again.

### ⏱️ Measured on Apify (October 4, 2026)

| Run | Posts | Time |
|---|---|---|
| Sample input (one query) | 10 | 5 s |
| One query, 300 posts over two of Reddit's lists | 300 | 19 s |
| Two queries in two subreddits, one of which does not exist, with a date limit and exact words | 2 | 31 s |
| A run with a maximum charge of $0.02 | 7 | 5 s |

A run of 500 posts that was aborted after eight seconds and resurrected ended with 500 rows, none of them twice. All at 512 MB.

### 🔔 Monitoring keywords

Turn on `onlyNew`, give the watch a `monitorId` and put the run on a schedule. The first run delivers the newest posts up to your limit. Later runs read each query newest first and leave it at the first page without anything new, so a quiet keyword costs nothing. Posts from before the oldest post of the first run stay outside the watch. The memory is a key-value store named `reddit-search-monitor` in your own account; delete a record there to start over.

### 🤖 For AI agents

Smallest useful call:

```json
{"queries": ["best standing desk"], "maxResultsPerQuery": 25}
```

Each row is one post with `title`, `selftext`, `score`, `num_comments`, `author`, `subreddit`, `created_utc` and `url`. `queries` and `subreddits` take several entries. Add `"postedAfter": "7 days"` for recent posts. A query without results returns no rows; the status message and the `SUMMARY` record name it. No credentials are needed.

### 💡 Use cases

- 📣 **Brand and product monitoring:** every new post that mentions your name, on a schedule.
- 🔬 **Market research:** what people ask and complain about around a product category.
- 🧠 **Data for models:** thousands of posts on a topic with word and token counts.
- ✍️ **Content research:** the questions with the most comments in your niche.

### ⚠️ Limits, stated plainly

- **Reddit decides what a search finds.** A broad query gives about 1,000 to 1,200 different posts over all of Reddit's lists, not every post ever written. For complete history by date see the Reddit Archive Scraper.
- **The date range filters what Reddit's lists return.** Reddit's search has no exact-date query; a narrow range in the far past can come back with few posts.
- **Posts only.** Comments are not searched. Pass a row's `url` to the Reddit Comments Scraper for its thread.
- **Scores are the values at the time of the run.**
- **Deleted and removed posts are not returned;** a link post has no text of its own.

### ❓ FAQ

**Do I need a Reddit account or API key?** No.

**How do I get more than 240 posts for a query?** Set `maxResultsPerQuery` higher. The Actor reads Reddit's other lists by itself and saves each post once.

**Why do I get fewer posts than I asked for?** Reddit has no more for that query in any of its lists. The status message says so.

**Can I search several subreddits at once?** Yes. Each query is searched in each subreddit you name.

**Can I run it every hour?** Yes, with `onlyNew`. A query without new posts is left after one request.

**How do I call it from code?** With the Apify API or the Python and JavaScript clients; every run returns a dataset you can fetch as JSON or CSV. It also works as a tool through Apify's MCP server.

**Is it legal?** The Actor reads public Reddit posts. Posts carry usernames and can contain personal data: GDPR, CCPA and similar rules apply to how you store and use them, and Reddit's terms apply to you as well.

### 🔗 You might also like

- [Reddit Comments Scraper](https://apify.com/benthepythondev/reddit-comments-scraper): every comment and reply of a post
- [Subreddit Scraper](https://apify.com/benthepythondev/subreddit-posts-scraper): the posts of whole subreddits, past Reddit's 1,000
- [Reddit Scraper](https://apify.com/benthepythondev/reddit-scraper): posts with nested comment trees, users and search in one Actor
- [Reddit Archive Scraper](https://apify.com/benthepythondev/reddit-archive-scraper): historical posts and comments by exact date range

**Keywords:** reddit search scraper, reddit keyword search, reddit search api, scrape reddit posts by keyword, reddit brand monitoring, reddit mentions, reddit posts export, reddit data for ai, reddit market research, reddit search csv, no api key reddit scraper, reddit date range search

# Actor input Schema

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

Words or phrases to search for, one per line. Each query is searched on its own; a post that several queries find is saved once.

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

Names or links of subreddits (python, r/python). Each query is searched in each of them. Leave empty to search all of Reddit.

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

The order of the first list that is read. One Reddit search shows about 240 posts; for more, the Actor reads the other orders as well and saves every post once.

## `timeFilter` (type: `string`):

Reddit's own time range for the search.

## `maxResultsPerQuery` (type: `integer`):

Posts to save for each query, in each subreddit when subreddits are given. A broad query gives about 1,000 to 1,200 different posts over all of Reddit's lists.

## `strictMatch` (type: `boolean`):

Reddit's search also returns posts that only relate to your words. With this on, a post is kept only when its title or text contains every word of the query.

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

A day (YYYY-MM-DD) or a period back from now (12 hours, 7 days, 2 months). Posts from before are not saved and not charged.

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

Upper end of a date range (YYYY-MM-DD), that day included.

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

Reddit leaves posts marked as adult content out of a search unless this is on.

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

For scheduled runs: reads newest first and skips everything an earlier run with the same monitor name delivered, so you pay only for what is new. The memory is a key-value store in your own account.

## `monitorId` (type: `string`):

Name of the memory used by the option above. Give each watch its own name; without a name the list of inputs is the name.

## Actor input object example

```json
{
  "queries": [
    "web scraping"
  ],
  "sort": "relevance",
  "timeFilter": "all",
  "maxResultsPerQuery": 10,
  "strictMatch": false,
  "includeNSFW": false,
  "onlyNew": false
}
```

# Actor output Schema

## `results` (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 = {
    "queries": [
        "web scraping"
    ],
    "maxResultsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "queries": ["web scraping"],
    "maxResultsPerQuery": 10,
}

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

```

## MCP server setup

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