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

Search Reddit by keyword across all of Reddit or inside one subreddit. Sort by relevance/top/new/hot/comments over any time window. Keyless (RSS) by default; add a free Reddit app for scores, comment counts, deep pagination and comments. Reliable residential-proxy rotation.

- **URL**: https://apify.com/dami\_studio/reddit-search-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Social media, Integrations, AI
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 post returneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Posts Search Scraper

Search Reddit by keyword — across all of Reddit or inside a single subreddit — and get back clean, structured posts. Sort by relevance, top, new, hot, or most comments over any time window.

Reddit hard-blocks the anonymous JSON API and rate-limits IPs aggressively, which is why so many Reddit scrapers return empty or fail half their runs. This one defaults to Reddit's **RSS endpoints** (different infrastructure, resilient by design — no proxy needed), so runs actually finish. Add a free Reddit app and it switches to the authenticated API for full scores, comment counts, deep pagination, and comments. A proxy is **optional**: enable one (residential recommended, a fresh IP is rotated per attempt) only if you hit IP rate limits or run the authenticated path at high volume.

### Input

| Field | Notes |
|---|---|
| `query` | Keywords. Supports operators like `title:`, `author:`, and quoted phrases. |
| `subreddit` | Optional — restrict the search to one subreddit. |
| `sort` | relevance / hot / top / new / most-comments. |
| `time` | hour … all (applies to relevance/top/comments). |
| `maxItems` | Keyless RSS returns ~25; with Reddit app creds it paginates to this many. |
| `includeComments` | Top comments per post (needs Reddit app creds). |
| `redditClientId` / `redditClientSecret` | Optional free `script` app from reddit.com/prefs/apps for richer data. |

### Output

One row per post. Each row also carries `ok: true` and a `source` field (`rss` or `oauth`) showing which data path produced it.

**Always populated (both paths):** `title`, `author`, `subreddit`, `url`, `permalink`, `selftext`, `createdAt`, `isSelf`, `over18`.

**Keyless RSS (the default) leaves these `null`:** `score`, `numComments`, `upvoteRatio`, `flair`, `thumbnail`, `domain`. Reddit's RSS feed simply doesn't expose them. Add a free Reddit app (see below) to get every field populated, plus deep pagination and comments.

Searches with no matches return a single `ok: false` diagnostic row and **are not charged**. Blocked/error runs likewise push an `ok: false` diagnostic row (with an `errorCode`) and are never charged.

### Keyless vs authenticated

Keyless (default) is reliable but RSS only exposes ~25 newest-matching posts and leaves `score`/`numComments` null. For full metrics, deep pagination, and comments, drop in a free Reddit `script` app — takes two minutes to create and it's yours, kept private.

# Actor input Schema

## `query` (type: `string`):

Keywords to search Reddit for. Supports Reddit search operators (e.g. "title:layoffs", "author:spez", quotes for phrases).
## `subreddit` (type: `string`):

Search only within this subreddit (e.g. "MechanicalKeyboards" or "r/MechanicalKeyboards"). Leave empty to search all of Reddit.
## `sort` (type: `string`):

How to order the search results.
## `time` (type: `string`):

Applies to Relevance / Top / Most-comments sorts.
## `maxItems` (type: `integer`):

Keyless RSS returns up to ~25 newest-matching posts and leaves score, numComments, upvoteRatio, flair, thumbnail and domain null (only title, author, url, selftext, createdAt, permalink, subreddit, isSelf, over18 are populated). Add Reddit app credentials below to paginate up to this many posts with full scores/comment counts and all fields populated.
## `includeComments` (type: `boolean`):

Fetch top comments for each post. Requires Reddit app credentials (anonymous comment access is blocked by Reddit).
## `commentLimit` (type: `integer`):

Maximum number of top comments to fetch per post (when Include comments is on).
## `redditClientId` (type: `string`):

Optional. Create a free 'script' app at reddit.com/prefs/apps for richer fields (score, comment counts), deeper pagination, and comments. Without it the actor uses keyless RSS.
## `redditClientSecret` (type: `string`):

The secret for the Reddit app above.
## `notionConnector` (type: `string`):

Optional. Write each post as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default) — results are always saved to the dataset regardless.
## `notionParentId` (type: `string`):

Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead.
## `proxyConfiguration` (type: `object`):

Optional. The default keyless RSS path runs on Reddit's RSS infrastructure (resilient by design) and needs no proxy. Only enable a proxy (RESIDENTIAL recommended) if you hit IP rate limits, or when using Reddit app credentials at high volume — a fresh IP is then rotated on every attempt.

## Actor input object example

```json
{
  "query": "best mechanical keyboard",
  "sort": "relevance",
  "time": "all",
  "maxItems": 50,
  "includeComments": false,
  "commentLimit": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

# Actor output Schema

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

Scraped rows are stored in the default dataset (one row per result). Blocked/empty/error runs return a single uncharged diagnostic row instead.

# 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 = {
    "query": "best mechanical keyboard"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = { "query": "best mechanical keyboard" }

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/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 '{
  "query": "best mechanical keyboard"
}' |
apify call dami_studio/reddit-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Posts Search Scraper",
        "description": "Search Reddit by keyword across all of Reddit or inside one subreddit. Sort by relevance/top/new/hot/comments over any time window. Keyless (RSS) by default; add a free Reddit app for scores, comment counts, deep pagination and comments. Reliable residential-proxy rotation.",
        "version": "0.1",
        "x-build-id": "YzXRwEMazxRCWAf58"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dami_studio~reddit-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dami_studio-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/dami_studio~reddit-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dami_studio-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/dami_studio~reddit-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dami_studio-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keywords to search Reddit for. Supports Reddit search operators (e.g. \"title:layoffs\", \"author:spez\", quotes for phrases)."
                    },
                    "subreddit": {
                        "title": "Restrict to subreddit (optional)",
                        "type": "string",
                        "description": "Search only within this subreddit (e.g. \"MechanicalKeyboards\" or \"r/MechanicalKeyboards\"). Leave empty to search all of Reddit."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "hot",
                            "top",
                            "new",
                            "comments"
                        ],
                        "type": "string",
                        "description": "How to order the search results.",
                        "default": "relevance"
                    },
                    "time": {
                        "title": "Time window",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Applies to Relevance / Top / Most-comments sorts.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Max posts",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Keyless RSS returns up to ~25 newest-matching posts and leaves score, numComments, upvoteRatio, flair, thumbnail and domain null (only title, author, url, selftext, createdAt, permalink, subreddit, isSelf, over18 are populated). Add Reddit app credentials below to paginate up to this many posts with full scores/comment counts and all fields populated.",
                        "default": 50
                    },
                    "includeComments": {
                        "title": "Include top comments",
                        "type": "boolean",
                        "description": "Fetch top comments for each post. Requires Reddit app credentials (anonymous comment access is blocked by Reddit).",
                        "default": false
                    },
                    "commentLimit": {
                        "title": "Comments per post",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of top comments to fetch per post (when Include comments is on).",
                        "default": 10
                    },
                    "redditClientId": {
                        "title": "Reddit app client ID (optional)",
                        "type": "string",
                        "description": "Optional. Create a free 'script' app at reddit.com/prefs/apps for richer fields (score, comment counts), deeper pagination, and comments. Without it the actor uses keyless RSS."
                    },
                    "redditClientSecret": {
                        "title": "Reddit app client secret (optional)",
                        "type": "string",
                        "description": "The secret for the Reddit app above."
                    },
                    "notionConnector": {
                        "title": "Notion connector (optional)",
                        "type": "string",
                        "description": "Optional. Write each post as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default) — results are always saved to the dataset regardless."
                    },
                    "notionParentId": {
                        "title": "Notion target data source ID",
                        "type": "string",
                        "description": "Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. The default keyless RSS path runs on Reddit's RSS infrastructure (resilient by design) and needs no proxy. Only enable a proxy (RESIDENTIAL recommended) if you hit IP rate limits, or when using Reddit app credentials at high volume — a fresh IP is then rotated on every attempt.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
