# Reddit Search Scraper (`scrapesmith/reddit-search-scraper`) Actor

Search Reddit by keyword across the entire site or within a specific subreddit. Run multiple search queries per run. Sort by relevance, top, new, hot, or comments. Filter by time range. Get titles, text, upvotes, media, flair, and author data. No login or cookies needed. Export JSON, CSV, Excel.

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

## Pricing

from $0.80 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Reddit Search Scraper — Search All of Reddit by Keyword, Instantly

Need to search **Reddit** at scale? This is the most comprehensive **Reddit search scraper** available — search across the entire platform or narrow down to one **subreddit**, run unlimited keywords in a single job, and get back clean, structured **Reddit data** in seconds. No login, no API keys, no manual scrolling through search results pages.

Built for marketers, researchers, growth teams, and analysts who need fast, reliable keyword search results from Reddit without the limitations of the native search UI.

### What It Does

Reddit Search Scraper runs one or more search queries against Reddit — either site-wide or restricted to a single subreddit — and returns full post data for every matching result: title, body text, author, upvotes, comment count, flair, media, and external links. Add a whole list of search terms and the scraper processes each one independently, merging everything into a single, ready-to-export dataset.

This is the fastest way to turn Reddit's native search into a real, structured data feed you can plug directly into your own tools, dashboards, or research pipeline.

### Features

- **Search all of Reddit or a single subreddit** — leave the subreddit field blank for a global search, or target a specific community like r/AskReddit or r/marketing
- **Batch keyword search** — run dozens of search terms in one job instead of searching one at a time
- **Five sort modes** — Relevance, Hot, Top, New, and Comment count
- **Time-range filtering** — restrict results to the past hour, day, week, month, year, or all time
- **NSFW toggle** — include or exclude adult content
- **Full post-level data** — titles, self-text, images, video, flair, upvotes, upvote ratio, comment counts, and author info
- **Resumable, checkpointed runs** — large multi-query jobs pick up where they left off if interrupted
- **No login or API key required** — fully anonymous Reddit search
- **One-click export** — download results as JSON, CSV, or Excel

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `searchQueries` | Array | One or more keywords/phrases to search for on Reddit |
| `searchCommunity` | Text | Optional — restrict the search to a single subreddit |
| `sort` | Select | Relevance, Hot, Top, New, or Comment count |
| `time` | Select | Hour, day, week, month, year, or all time |
| `maxResults` | Number | Maximum results to collect per search query |
| `includeNSFW` | Boolean | Include NSFW/over-18 posts in results |
| `maxItems` | Number | Hard cap on total items collected across all queries |

### Output Fields

| Field | Description |
|---|---|
| `id` / `parsedId` | Reddit's internal post ID |
| `url` | Direct link to the matching post |
| `username` | Post author |
| `title` | Post title |
| `communityName` | Subreddit the post belongs to |
| `subredditSubscribers` | Subscriber count of that subreddit |
| `body` | Post text content |
| `html` | Rendered HTML of the post body |
| `link` | External link (for link posts) |
| `domain` | Source domain of linked content |
| `numberOfComments` | Total comment count |
| `flair` | Post flair tag |
| `upVotes` / `upVoteRatio` | Post score and like ratio |
| `isSelf` / `isVideo` / `isStickied` / `isLocked` / `isSpoiler` | Post type flags |
| `over18` | NSFW flag |
| `videoUrl`, `videoDuration` | Video metadata (if applicable) |
| `thumbnailUrl` | Thumbnail image URL |
| `imageUrls` | Array of image URLs |
| `createdAt` | Post creation timestamp (ISO format) |
| `scrapedAt` | Time the data was scraped |
| `dataType` | Always `post` for search results |

### Sample Output

```json
{
  "id": "t3_1srchxx",
  "parsedId": "1srchxx",
  "url": "https://www.reddit.com/r/personalfinance/comments/1srchxx/best_budget_apps/",
  "username": "budget_guru",
  "title": "What's the best budget app in 2026?",
  "communityName": "r/personalfinance",
  "subredditSubscribers": 18400000,
  "body": "I've tried three apps this year and none of them stuck...",
  "numberOfComments": 128,
  "flair": "Budgeting",
  "upVotes": 940,
  "upVoteRatio": 0.94,
  "isSelf": true,
  "over18": false,
  "createdAt": "2026-06-28T11:45:00.000Z",
  "scrapedAt": "2026-07-06T09:15:00.000Z",
  "dataType": "post"
}
````

### Use Cases

1. **Market & competitor research** — search for brand names, products, or competitors across all of Reddit
2. **Content ideation** — find real questions people are asking around your niche or industry
3. **Trend discovery** — track how a keyword or topic is trending across time ranges and subreddits
4. **Sentiment & opinion mining** — pull large volumes of keyword-matched posts for NLP analysis
5. **Lead generation** — find people actively discussing problems your product or service solves
6. **SEO & keyword research** — discover the exact language real users use when discussing a topic
7. **Journalism & investigative research** — quickly gather primary-source posts mentioning a specific event or term
8. **Academic and social research** — study how specific topics are discussed across Reddit communities
9. **Reputation management** — monitor mentions of your name, brand, or product across the platform

### Pricing

Transparent pay-per-result pricing: **$0.80 per 1,000 results**. No subscriptions or minimums — pay only for the search results you actually collect.

### Tips for Best Results

- Leave `searchCommunity` empty for the broadest possible search across all of Reddit
- Use `time` filters to narrow in on recent discussions when tracking breaking topics
- Run multiple related keywords in one job to build a fuller picture of a topic
- Set `maxItems` to control cost and run size when searching very popular or broad keywords
- Combine with the Reddit Comments Scraper to pull full discussion threads from your top search results

### FAQ

**Can I search a specific subreddit instead of all of Reddit?**
Yes — just enter the subreddit name in `searchCommunity` and your query will be restricted to that community only.

**How many search queries can I run at once?**
As many as you want — add a list of keywords and each one is searched and combined into a single dataset.

**Do I need a Reddit account or API key?**
No. This is a fully anonymous Reddit search scraper with no login or API key required.

**What sort options are available?**
Relevance, Hot, Top, New, and Comment count — matching Reddit's own native search sort options.

**Can I filter by time range?**
Yes, choose from past hour, day, week, month, year, or all time.

**What formats can I export results in?**
JSON, CSV, and Excel are all supported for instant download after your run.

**Does this include NSFW search results?**
Only if you enable the "Include NSFW results" toggle — it's disabled by default.

**Can I run recurring searches to track a keyword over time?**
Yes, schedule repeated runs of the same query to build a timeline of how a topic or keyword trends across Reddit.

### Why Teams Choose This Scraper

Reddit's own search UI caps how much you can see and offers no easy way to export results. Reddit Search Scraper removes that ceiling entirely — search unlimited keywords, across unlimited subreddits, and walk away with a clean, structured dataset instead of a scrollable web page. It's built for teams who treat Reddit as a serious data source, not just a place to browse.

### Getting Started

Add your search queries, optionally restrict to a subreddit, pick a sort order and time range, then run. Results land in your dataset in real time and are ready to export the moment your job finishes.

### A Note on Reliability

Reddit search results can vary wildly in volume depending on how popular a keyword is — from a handful of niche mentions to thousands of matching posts across the platform. This scraper is built to handle both ends of that spectrum consistently, so whether you're tracking an obscure term or a viral keyword, you get complete, reliable results every run.

### Support

Questions or feature requests? Reach out via the contact/support options on this actor's Apify page — we're continually improving this tool to remain the fastest, most comprehensive Reddit search scraper available.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords or phrases to search for on Reddit. One per line. Each query runs as a separate search.

## `searchCommunity` (type: `string`):

Limit the search to a single subreddit, e.g. 'AskReddit'. Leave empty to search all of Reddit.

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

How to order search results.

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

Restrict results to posts from this time range.

## `maxResults` (type: `integer`):

Maximum number of results to collect for each search query.

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

Include posts marked as NSFW/over-18 in the results.

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

Hard cap on the total number of items collected across all search queries in this run.

## Actor input object example

```json
{
  "searchQueries": [
    "best budget headphones",
    "remote work tips"
  ],
  "searchCommunity": "AskReddit",
  "sort": "relevance",
  "time": "all",
  "maxResults": 10,
  "includeNSFW": false
}
```

# 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 = {
    "searchQueries": [
        "remote jobs"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/reddit-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "remote jobs"
  ]
}' |
apify call scrapesmith/reddit-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesmith/reddit-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Search Scraper",
        "description": "Search Reddit by keyword across the entire site or within a specific subreddit. Run multiple search queries per run. Sort by relevance, top, new, hot, or comments. Filter by time range. Get titles, text, upvotes, media, flair, and author data. No login or cookies needed. Export JSON, CSV, Excel.",
        "version": "0.0",
        "x-build-id": "kFMXjp4OBeKmDJg2A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~reddit-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-reddit-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesmith~reddit-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-reddit-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesmith~reddit-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-reddit-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords or phrases to search for on Reddit. One per line. Each query runs as a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchCommunity": {
                        "title": "Restrict to subreddit (optional)",
                        "type": "string",
                        "description": "Limit the search to a single subreddit, e.g. 'AskReddit'. Leave empty to search all of Reddit."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "hot",
                            "top",
                            "new",
                            "comments"
                        ],
                        "type": "string",
                        "description": "How to order search results.",
                        "default": "relevance"
                    },
                    "time": {
                        "title": "Time range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Restrict results to posts from this time range.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of results to collect for each search query.",
                        "default": 10
                    },
                    "includeNSFW": {
                        "title": "Include NSFW results",
                        "type": "boolean",
                        "description": "Include posts marked as NSFW/over-18 in the results.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of items collected across all search queries in this run."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
