# Reddit Search Scraper — Keyword Posts with Velocity (`foxlabs/reddit-search-scraper`) Actor

Posts matching your keywords from Reddit's own search, across Reddit or inside chosen subreddits: title, address, author, subreddit, score, comment count, exact time, score and comments per hour, the query that found it. Body text and flair on request. Only-new mode. No login.

- **URL**: https://apify.com/foxlabs/reddit-search-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Marketing
- **Stats:** 5 total users, 4 monthly users, 71.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 search 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/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 — Keyword Posts, Velocity, Author Karma 🚀

**foXLabs Reddit series:** [Subreddit Posts](https://apify.com/foxlabs/reddit-subreddit-posts-scraper) · [Post Details](https://apify.com/foxlabs/reddit-post-details-scraper) · [Post Comments](https://apify.com/foxlabs/reddit-post-comments-scraper) · [User](https://apify.com/foxlabs/reddit-user-scraper)

🎉 Posts matching your keywords, as Reddit's own search shows them to a signed-out visitor — across all of Reddit or inside the subreddits you name, in any order and period. Every row carries the title, the address, the author, the subreddit, the score, the comment count, the exact time, the query that found it and what other Reddit search scrapers leave out: **score and comments per hour**. The body text, the flair and the media come from each result's own page when you ask (`includePostDetails`), and **each author's karma** with `includeAuthorInfo`. Only-new mode turns it into a brand/product/topic monitor. No login, no cookies of yours, no CAPTCHA solving.

### 🔍 What is the Reddit Search Scraper — and when should you use it?

Give this Actor keywords and it returns Reddit's search results as clean rows — across all of Reddit or inside chosen subreddits — with the votes, the comment count, the exact time and post velocity; the body text and the author's karma on request.

**Use it when you need:** to monitor a brand, product or topic across Reddit; keyword research with engagement signals; or a scheduled only-new feed of mentions.

**Use something else when:** you want a whole subreddit's feed → [Subreddit Posts](https://apify.com/foxlabs/reddit-subreddit-posts-scraper); a single post's comments → [Post Comments](https://apify.com/foxlabs/reddit-post-comments-scraper); one user's history → [User](https://apify.com/foxlabs/reddit-user-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/reddit-search-scraper`. An agent can discover it, run it and read the dataset over MCP.

**Real-time Standby API.** The same code answers HTTP requests on demand — `GET /search?query=apify&sort=new&maxResults=25` or `GET /search?query=pandas&subreddit=python&sort=top&time=year`. Parameters: `query`, `subreddit`, `sort`, `time`, `maxResults` (1–100), `postKinds`, `authors` (0/1); billed with the same `search-result` event.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want Reddit keyword search results using the Apify Actor
`foxlabs/reddit-search-scraper`.

Input: `queries` is a list of search terms (Reddit operators allowed); `subreddits` scopes the
search; `sort` is new/relevance/top/comments/hot; `time` is hour…all. Each row has title, text,
score, commentCount, scorePerHour and author; add includePostDetails for the body text and includeAuthorInfo for the karma.

Start with:
{ "queries": ["apify"], "sort": "new", "maxResultsPerQuery": 50 }

Ask me what to monitor, run the Actor, then summarise the posts as a table.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/reddit-search-scraper.md`.

### 📋 Overview

Everything you need to turn Reddit search into clean, structured data — matching posts with velocity, and their text and author karma on request — in one Actor, with no login, cookies or CAPTCHA solving.

**Why teams pick this Actor:**

- ✅ **Search all of Reddit or chosen subreddits** — five orders, six periods.
- ⚡ **Velocity** — score and comments per hour on every row, which bare search scrapers omit; the author's karma with `includeAuthorInfo`.
- 🎯 **Query provenance** — every row names the query that found it; a post several queries bring is delivered once.
- 🔁 **Only-new monitoring** — schedule the same queries and get only what's new.
- 💰 **Pay only for results** — one `search-result` event per row; filtered-out and status rows are free.
- 🤖 **Agent-ready** — MCP + a real-time Standby API.

### ✨ Features

- 🔍 **Keyword search** — brands, phrases in quotes, Reddit operators (`title:`, `author:`, `self:`, `nsfw:`).
- 📄 **Full post** — ids, title, text, link, domain, kind, flair, media (image/video/gallery/poll), flags.
- 📊 **Engagement** — score, upvote ratio, comments, awards, crossposts, and per-hour velocity.
- 👤 **Author karma** — link/comment karma and the cake day (`includeAuthorInfo`, one profile-page read per author, off unless asked).
- 📄 **The posts themselves** — body text, flair, media and kind with `includePostDetails` (one page read per result); a Reddit search result does not carry them.
- 🏷️ **Subreddit record** — subscribers on every row; full record with `includeSubredditInfo`.
- 🔁 **Only-new lists** for monitoring.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~reddit-search-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["apify"], "sort": "new", "maxResultsPerQuery": 50}'
```

### 🚀 Getting Started (3 steps)

1. **Enter your queries** — one per line, as typed into Reddit's search box; optionally scope with `subreddits`.
2. **Pick order & period** — `sort` (new for monitoring) and `time`.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Meaning |
|---|---|
| `queries` | one per line — a brand, phrase in quotes, or Reddit operators (`title:"exact"`, `author:name`, `self:yes`). |
| `subreddits` | optional: search each query only inside these subreddits. Empty = all of Reddit. |
| `sort` | `new` (default), `relevance`, `top`, `comments`, `hot`. |
| `time` | `hour`, `day`, `week`, `month`, `year`, `all` (default). |
| `maxResultsPerQuery` | results per query (default 100). Reddit ends a search after ~250. |
| `maxResults` | rows in the whole run (default 100,000). |
| `postKinds`, `minScore`, `minComments` | keep only these; the rest are skipped and not charged. |
| `includeAuthorInfo` | the author's karma and cake day — one profile-page read per author (default off). |
| `includePostDetails` | read each result's own page for the body text, flair, media and kind (default off). |
| `includeSubredditInfo` | each distinct subreddit's record (default off). |
| `onlyNewResults`, `listName` | remember delivered posts and skip them next time. |
| `proxyConfiguration` | nothing to change for normal use. |

```json
{ "queries": ["apify", "web scraping api"], "subreddits": ["python", "webdev"], "sort": "new", "time": "month", "maxResultsPerQuery": 100 }
```

### 📤 Output

One row per post (same fields as the [Subreddit Posts Scraper](https://apify.com/foxlabs/reddit-subreddit-posts-scraper)): ids and address, `title`, `text`, `link`, `domain`, `kind`, `author` and flair, `score`, `upvoteRatio`, `commentCount`, `awardCount`, `crosspostCount`, `createdAt`, `editedAt`, `hoursSincePost`, `scorePerHour`, `commentsPerHour`, flags, media, `subredditSubscribers` — plus:

| Field | What it is |
|---|---|
| `query` | the query line that found the post (delivered once, under the first) |
| `authorInfo` | link karma, comment karma, account creation date, avatar (null for a deleted author) |
| `subredditInfo` | subscribers, active users, creation date, type, language, description (with `includeSubredditInfo`) |
| `position` | the post's place in its query's results |

A query that matches nothing — or names a subreddit that can't be searched (private, Premium-only, no such name) — gets a **free status row**. A run never ends empty without a word.

### 💼 Use cases

**1. Brand & topic monitoring** — track mentions of a brand or product across Reddit.
*Input:* your terms, `sort: new`, `onlyNewResults` scheduled. *Output:* new matching posts + velocity. *Use:* a live mention feed.

**2. Market & keyword research** — see which posts on a topic gain traction.
*Input:* topic queries, `sort: top`, `time: year`. *Output:* top posts + author karma. *Use:* find influential threads and voices.

**3. Lead & community discovery** — find subreddits and authors discussing your space.
*Input:* queries with `includeSubredditInfo`. *Output:* posts + subreddit records. *Use:* map where your audience talks.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/reddit-search-scraper').call({
  queries: ['apify'], sort: 'new', maxResultsPerQuery: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/reddit-search-scraper').call(
    run_input={'queries': ['apify'], 'sort': 'new', 'maxResultsPerQuery': 50}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule → HTTP request to the Actor API with your `queries` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay per event, one event per delivered row: **`search-result`** — whatever it carries (the author's and the subreddit's records ride along free). Status rows are free; filtered-out posts aren't written or charged; a run Reddit doesn't answer ends FAILED and charges nothing; no start fee. [View current pricing.](https://apify.com/foxlabs/reddit-search-scraper)

### ❓ FAQ

**Do I need a Reddit account, login or API key?** No. It reads Reddit the way its own site does for a signed-out visitor — a guest token, no account, no cookies, no CAPTCHA solving.

**How many results per query?** Reddit ends a search after ~250 results, whatever you ask for. For more, split the period, subreddits or wording.

**Can I search inside specific subreddits?** Yes — list them in `subreddits`; empty means all of Reddit.

**Does it search comments?** No — posts only in this version. For a post's comments use the [Post Comments Scraper](https://apify.com/foxlabs/reddit-post-comments-scraper).

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **~250 results max per query** — Reddit's own end of a search; split period/subreddits/wording for more.
- **A query returns a status row** — it matched nothing, repeats another line, or names a private/Premium-only subreddit (free, not charged).
- **Scores look slightly off** — Reddit fuzzes scores by design; `score` is what the search shows at that moment.

**How it reads Reddit:** opens a listing as a signed-out visitor, takes the guest token Reddit hands that visitor, and calls Reddit's search API. Reddit hands that token to residential addresses only (measured: 7/7 residential, 0/8 datacenter), so Apify Proxy residential is used by default; four addresses rotate, a used-up one is replaced.

### ⚠️ Trademark

Independent, third-party tool. Reddit is a trademark of Reddit, Inc.; this Actor is not affiliated with, endorsed by or connected to Reddit. The mark is used here for identification only.

### ⚖️ Is it legal to scrape this data?

It reads only what Reddit shows anyone who is not signed in. Rows carry user names (public pseudonyms) and publicly posted text; you are responsible for using them lawfully (GDPR, CCPA, Reddit's User Agreement). Nothing is stored outside your own Apify datasets. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — the run's `SOURCE_REPORT` record holds what was seen, read, delivered and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.2.0 — 2026-10-17

Reddit closed its JSON API to signed-out visitors on 16 October 2026, so the results now come from Reddit's own
search page: 7 results a page with a cursor for the next. A result carries the title, address, author, subreddit,
votes, comment count, exact time and nsfw/spoiler flags; the body text, flair, media and kind are not in a Reddit
search result, so the new `includePostDetails` input reads each result's own page when you want them (and
`includeSubredditInfo` now needs it). `includeAuthorInfo` is off by default — the karma is one profile-page read
per author. Field names, the dataset shape, the `search-result` event and its price are unchanged.

#### 0.1.0 — 2026-10-10

- First release: keyword search across Reddit or inside chosen subreddits, five orders and six periods, velocity fields and author karma on every row, `query` provenance, kind/score/comment filters, only-new lists, free status rows for empty queries and unsearchable subreddits; Standby API prepared.

# Changelog

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

# Actor input Schema

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

One query per line, as you would type it into Reddit's search box: a brand, a product, a phrase in quotes, or Reddit's own operators (subreddit:python, author:spez, title:"exact words", self:yes, nsfw:no). A query written twice is read once.

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

Leave empty to search all of Reddit. Give subreddit names (python, r/python or an address) to search each query inside each of them: a post is delivered once per query even when several subreddits bring it.

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

new (newest first; the order to use for monitoring), relevance (Reddit's own ranking), top (highest score in the period), comments (most comments), hot.

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

Only posts from this period: hour, day, week, month, year or all time.

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

How many posts to deliver for each query (in all its subreddits together), from the top of the results. Reddit hands results out 100 a request and ends a search after about 250 results: a larger number stops where Reddit stops.

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

The run stops when this many rows have been delivered. You are charged only for delivered rows.

## `postKinds` (type: `array`):

Leave empty for every kind. Choose some to get only those; a post of another kind is skipped and not charged.

## `minScore` (type: `integer`):

Deliver only posts whose score is at least this.

## `minComments` (type: `integer`):

Deliver only posts with at least this many comments.

## `includeAuthorInfo` (type: `boolean`):

One request per 100 authors adds each post's author record (link and comment karma, account creation date, avatar) as authorInfo. A deleted author gets null.

## `includeSubredditInfo` (type: `boolean`):

One request per distinct subreddit among the results adds its subscribers, active users, creation date, type and description to the rows of it (subredditInfo). Off by default: results of a wide search come from many subreddits and every row already carries the subscriber count.

## `includePostDetails` (type: `boolean`):

A Reddit search result carries the title, the address, the author, the subreddit, the votes, the comment count and the exact time — not the post's body text, flair, media or kind. With this on, each result's own page is read as well (one extra page read per result: the run takes longer and uses more proxy traffic) and those fields are filled. Needed for the subreddit record too.

## `onlyNewResults` (type: `boolean`):

Remember delivered posts under the list name below and skip them in later runs. Schedule the same queries hourly with the order "new" and each run brings only the posts it has not delivered before — a brand or topic monitor. With this on, "Maximum results per query" is how far down the results the Actor looks.

## `listName` (type: `string`):

Name of the memory used by "Only posts not delivered before" (looked at only when that is on). Use a different name for each project. Letters, digits and hyphens (a hyphen not first or last), up to 40 characters; capitals are read as lower case.

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

Nothing to change for normal use: the Actor reads Reddit through Apify Proxy residential addresses, the only kind Reddit hands its guest token to (measured: residential 7 of 7 sessions, datacenter 0 of 8). Set a proxy here to send every request through it instead; a setting the platform refuses ends the run before anything is read.

## Actor input object example

```json
{
  "queries": [
    "apify"
  ],
  "subreddits": [],
  "sort": "new",
  "time": "all",
  "maxResultsPerQuery": 50,
  "maxResults": 100000,
  "includeAuthorInfo": false,
  "includeSubredditInfo": false,
  "includePostDetails": false,
  "onlyNewResults": false,
  "listName": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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": [
        "apify"
    ],
    "maxResultsPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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