# Reddit Search Scraper - Posts by Keyword, Subreddit & Date (`socialscrapers/reddit-search-scraper`) Actor

Reddit Search Scraper: search Reddit posts by keyword, in all of Reddit or one subreddit, by relevance, new, top or comments, any date range: title, votes, author, subreddit and date, plus full text and comments if you want. No login or API key. $1.10 per 1,000 posts.

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

## Pricing

from $0.88 / 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** runs Reddit's own post search for **any number of keywords** and exports the results to CSV, Excel or JSON: title, votes, comment count, author, subreddit and date of every matching post, and, when you want them, its **full text** and its **comments**. Search all of Reddit or **one subreddit**, sort by relevance, new, top or most comments, limit to the past day, week, month or year, and go past Reddit's 250-result wall. **No login, no API key**, **$1.10 per 1,000 posts**.

> 💡 **Need a feature that isn't here? Just ask.** Open an issue on the **Issues** tab and tell us what you need: a new field, filter, input type or output format. We build requested features fast, usually within 24 hours, at no extra cost.

> ⭐ **Found it useful?** A short review on the **Reviews** tab helps other people find this scraper, and tells us what to build next.

### What does Reddit Search Scraper do?

- 🔎 **Keyword search at scale**: one search per keyword, as many keywords as you like in one run, all in one dataset.
- 📅 **Sort and date filters**: Relevance, New, Top or Most comments, over all time, the past year, month, week or 24 hours.
- 🎯 **All of Reddit or one subreddit**: leave **Search in one subreddit** empty, or give `Coffee` to search only r/Coffee.
- 📈 **Past the 250-result wall**: one Reddit search stops near 250 posts. Ask for more and the scraper also searches the same keyword in other orders and narrower time ranges, inside your range, each post once: thousands of posts per keyword.
- ✅ **Relevant results**: by default only posts whose title or text mentions every word of your keyword are kept (Reddit also returns posts that match only in their comments); turn it off to keep everything.
- 🧩 **Reddit's search syntax**: paste queries as you would type them on Reddit: `OR`, `-word`, `"exact phrase"`, `(groups)`, `title:`, `author:`, `subreddit:`, `flair:`, `site:`, e.g. `title:"standing desk" OR subreddit:homeoffice -ikea`. Results are kept when they match the query itself. Long OR lists are fine: a query longer than Reddit's search box takes is split at its ORs and run in parts, each post once.
- 📝 **Full text and comments on demand**: search results show a title, not the text. Turn on **Full post text** for each post's text, link, flair, upvote ratio and media, and **Include comments** for its comments.

### What data can you extract from Reddit search?

| Field | What it holds |
|---|---|
| `title` | The post's title |
| `body` | The post's full text with **Full post text** on; `null` otherwise (search results do not show it) |
| `score`, `numComments` | Votes and comment count |
| `author`, `authorId` | Username and account ID (`t2_…`) |
| `subreddit`, `subredditId` | Where it was posted |
| `createdAt` | When it was posted (ISO 8601, UTC) |
| `url` | Link to the post |
| `isOver18` | Marked NSFW |
| `upvoteRatio`, `flair`, `linkUrl`, `domain`, `imageUrls`, `videoUrl` | With **Full post text** on |
| `sourceInput` | The keyword that found it |

With **Include comments** on, each post is followed by its comments (`dataType: "comment"`), each with its text, author, votes, date, `depth` and `parentId`.

### How to scrape Reddit search results

1. Open **Reddit Search Scraper** and click **Try for free**.
2. Add your **search keywords**, one per line.
3. Choose **Sort results by** and a **Time range**; to search one community, fill in **Search in one subreddit**.
4. Set **Max posts per keyword** (`0` = as many as Reddit has).
5. Click **Start**, then download the results as CSV, Excel, JSON, XML or HTML, or read them through the API.

#### How to monitor new Reddit posts about a keyword

Sort by **New**, set the **Time range** to the past 24 hours, and schedule the scraper to run every day: you get each day's new posts that mention your brand, product or topic.

#### How to search inside one subreddit

Type the subreddit's name (`Coffee` or `r/Coffee`) in **Search in one subreddit**. Every keyword is then searched in that subreddit only.

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

You pay per result saved; platform usage and proxies are included.

| Result | Price per 1,000 | Silver plan (−10%) | Gold plan (−20%) |
|---|---|---|---|
| Post (search result) | **$1.10** | $0.99 | $0.88 |
| Post with full text (**Full post text** on) | **$1.10** | $0.99 | $0.88 |
| Comment (**Include comments** on) | **$0.72** | $0.648 | $0.576 |

Each run also carries a start charge of $0.002 (one per GB of run memory), and Apify then covers the run's first 5 seconds of compute. A result left out because it does not mention every keyword word costs nothing.

Examples:

- **5 keywords × 1,000 posts**: 5,000 posts = **$5.50**.
- **1,000 posts with full text**: **$1.10**.
- **500 posts with 20 comments each**: $0.55 + 10,000 comments × $0.00072 = $0.55 + $7.20 = **$7.75**.

Apify's free plan includes $5 of platform credit every month, enough for about 4,500 search results. Set a **maximum cost per run** in the run options and the scraper stops cleanly before the first result that would go over it.

### Input example

This month's top posts for two keywords, 500 each:

```json
{
  "searches": ["standing desk", "ergonomic chair"],
  "searchSort": "top",
  "searchTime": "month",
  "maxItemsPerSource": 500
}
```

A keyword in one subreddit, with full text and the 20 best comments of each post:

```json
{
  "searches": ["burr grinder"],
  "searchSubreddit": "Coffee",
  "maxItemsPerSource": 100,
  "searchIncludePostDetails": true,
  "includeComments": true,
  "maxCommentsPerPost": 20
}
```

### Output example

A search result with **Full post text** on (trimmed):

```json
{
  "dataType": "post",
  "id": "t3_1q9v2ks",
  "url": "https://www.reddit.com/r/StandingDesks/comments/1q9v2ks/best_standing_desks_in_2026_so_far/",
  "title": "Best standing desks in 2026 so far?",
  "body": "Hey guys, my friend asked me for standing desk recommendations and I realized I probably know way too much about them lol. ...",
  "author": "<username>",
  "authorId": "t2_<user-id>",
  "subreddit": "StandingDesks",
  "createdAt": "2026-01-11T09:24:51.000Z",
  "score": 10,
  "upvoteRatio": 0.86,
  "numComments": 45,
  "isOver18": false,
  "sourceType": "search",
  "sourceInput": "standing desk",
  "scrapedAt": "2026-11-13T09:00:00.000Z"
}
```

### Use cases

- **Brand and competitor monitoring**: every new post that names your brand, product or competitors.
- **Market research**: what people ask, recommend and complain about in a niche.
- **Content ideas and SEO**: the questions people really ask, and which ones get the most comments.
- **Lead research**: posts asking for the problem you solve.
- **Datasets for AI and NLP**: posts (and their comments) on any topic over a time range.

### Use Reddit Search Scraper via API, Python and JavaScript

Run a search and get the results in one call with the [Apify API](https://docs.apify.com/api/v2):

```bash
curl -X POST "https://api.apify.com/v2/acts/socialscrapers~reddit-search-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searches": ["standing desk"], "searchSort": "new", "searchTime": "week", "maxItemsPerSource": 200}'
```

Python, with the [Apify client](https://docs.apify.com/api/client/python):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("socialscrapers/reddit-search-scraper").call(run_input={
    "searches": ["standing desk", "ergonomic chair"],
    "maxItemsPerSource": 1000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["sourceInput"], item["subreddit"], item["score"], item["title"])
```

JavaScript, with the [Apify client](https://docs.apify.com/api/client/js):

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('socialscrapers/reddit-search-scraper').call({ searches: ['burr grinder'], searchSubreddit: 'Coffee' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

You can also schedule searches, send results to Google Sheets, Slack or a webhook through Make, Zapier or n8n, or let an AI agent run searches through the Apify MCP server.

### Limits

- **Public posts only.** Searching in a private, Premium-only or quarantined subreddit gives nothing without an account; the run says so and charges nothing.
- **Search results show no text.** Reddit's search shows a post's title, votes, comment count, author, subreddit and date; the text comes with **Full post text**, priced as its own result type because each post's page has to be read.
- **Reddit decides what matches.** Reddit's search ranks rather than filters; the "every keyword word" option removes posts that do not mention your words in their title or text.
- **Run timeout.** Shortly before a run's timeout (10% of the run's time, 15 to 90 seconds), the scraper stops starting new work, saves and charges what it collected, and ends as Succeeded with a status message saying so. Raise the timeout to get more.
- **Residential proxy.** Keep the default residential proxy: Reddit refuses most datacenter IPs.

### FAQ

**Do I need a Reddit account or API key?**
No. The scraper reads only what Reddit shows to logged-out visitors.

**How many results can I get per keyword?**
One Reddit search ends near 250 posts. With a higher **Max posts per keyword** (or `0`), the scraper searches the same keyword in other orders and narrower time ranges inside your range and removes duplicates; broad keywords give thousands of posts.

**Why do I get fewer posts than I asked for?**
The keyword has fewer matching posts, or results that do not mention every word were left out (turn off **Only posts that mention every keyword word** to keep them all). With **Full post text** and that option both on, a keyword whose results rarely mention every word ends early instead of reading page after page of results that would be left out; the log says "stopped early" for it.

**Why do my results have no text?**
Reddit's search does not show it. Turn on **Full post text**: each post's page is read for its text, flair, upvote ratio, links and media.

**Is it legal to scrape Reddit?**
The scraper collects only public data that anyone can see without logging in. Reddit's terms and data-protection laws such as the GDPR may still apply to how you use it, especially personal data; ask a lawyer if unsure.

**Can I use OR, quotes, title: or subreddit: in a keyword?**
Yes. Queries in Reddit's own search syntax go to Reddit as written, and only posts that match them are kept. A very long query (Reddit's search reads about 250 characters) is split at its ORs and run in parts.

**My run finished with 0 results. What happened?**
No post matched, or the subreddit you searched in is private: the status message says which for each keyword, and nothing was charged. When the input has nothing usable at all (for example **Search in one subreddit** is not a subreddit name), the run still ends as Succeeded, with a status message that starts "Nothing to scrape:" and says what to fix.

# Actor input Schema

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

Keywords to search Reddit posts for, one per line, for example "standing desk" or "best budget headphones". Each keyword is its own search and returns up to "Max posts per keyword" posts.

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

Order of the results, as on Reddit. When you ask for more posts than one search returns (about 250), the scraper also reads the other orders within your time range and removes duplicates.

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

Only find posts from this period, for example the past week.

## `searchSubreddit` (type: `string`):

Leave empty to search all of Reddit. Give one subreddit, like Coffee or r/Coffee, to search only its posts.

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

Most posts to take from each keyword. 0 = no limit: the scraper keeps going while Reddit has more, reading other orders and narrower time ranges once one search ends. Comments do not count here. Example: 1000.

## `searchMatchAllWords` (type: `boolean`):

Keep only posts whose title or text mentions every word of the keyword (plurals and accents count). Reddit's search also returns posts that match only in their comments. With this on, Reddit is first asked for posts with every word, so results are more relevant. Turn off to keep every post the search returns.

## `searchIncludePostDetails` (type: `boolean`):

Off by default: each result comes with its title, votes, comment count, author, subreddit and date. Turn on to also read each result's post page, for its full text, link, flair, upvote ratio, images and video. A result read this way is priced as "Search result with full text" ($1.45 per 1,000) instead of as a post.

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

Also collect each result's comments: one result per comment, right after its post, with its depth and parent.

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

Most comments to collect for each post when "Include comments" is on. 0 = every comment, including the replies Reddit folds behind "more replies". Example: 200.

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

The order comments are collected in, as on Reddit: Best (Reddit's default), Top, New, Controversial, Old or Q\&A.

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

Overall cap on results (posts plus comments) for the whole run. The run stops once it is reached. Leave empty (or 0) for no cap. Example: 10000.

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

Keep the default: Apify Proxy with the RESIDENTIAL group. Reddit refuses most datacenter IPs: with another Apify Proxy group, sessions Reddit refuses are retried on RESIDENTIAL (same country).

## Actor input object example

```json
{
  "searches": [
    "standing desk"
  ],
  "searchSort": "relevance",
  "searchTime": "all",
  "maxItemsPerSource": 20,
  "searchMatchAllWords": true,
  "searchIncludePostDetails": false,
  "includeComments": false,
  "maxCommentsPerPost": 50,
  "commentSort": "best",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searches": [
        "standing desk"
    ],
    "maxItemsPerSource": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("socialscrapers/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": ["standing desk"],
    "maxItemsPerSource": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("socialscrapers/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": [
    "standing desk"
  ],
  "maxItemsPerSource": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call socialscrapers/reddit-search-scraper --silent --output-dataset

```

## MCP server setup

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