# Reddit Post Search (`datamagnet/reddit-post-searcher`) Actor

Search Reddit posts by keyword and get a clean list of matching results. Narrow results by subreddit, sort order, and time range to quickly find the most relevant posts.

- **URL**: https://apify.com/datamagnet/reddit-post-searcher.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 20.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Post Search — Reddit Scraper for Keyword-Based Post Discovery

Find the Reddit posts that matter most without scrolling endlessly. Reddit Post Search helps marketers, researchers, founders, and community managers quickly collect Reddit post data by keyword or phrase, then narrow results by subreddit, sort order, and time range. It is ideal for anyone who wants a clean Reddit data extractor for market research, trend tracking, content ideas, or audience listening. Get a simple list of matching posts with useful details like title, subreddit, author, score, comments, and post link.

### Key Features

- Extract Reddit posts that match a keyword or phrase so you can focus on the conversations that matter.
- Collect results from a specific subreddit to keep your research tightly targeted.
- Filter by sort order and time range to surface the newest, top-performing, or most relevant posts.
- Return a clean list of post details that is easy to review, share, and analyze.
- Gather more results automatically until your requested limit is reached, saving you manual work.
- Support practical research workflows such as trend discovery, brand monitoring, and content planning.
- Deliver readable post information that helps non-technical users make faster decisions.

### Use Cases

#### Market Research
Product teams and analysts use this Reddit scraper to see what people are saying about a topic, brand, or category. By reviewing fields like post title, subreddit, score, comment count, and created time, they can spot recurring pain points, compare sentiment, and identify emerging demand.

#### Brand Monitoring
Marketing teams and brand managers can search for their company name, product name, or campaign phrase inside a chosen subreddit. The returned author, post URL, score, and comments help them quickly find important discussions, respond to feedback, and track how a topic is spreading.

#### Content Planning
Content creators and SEO teams use the results to discover questions, opinions, and language that real Reddit users are already using. Post titles, subreddit names, and comment activity reveal what topics are getting attention, which helps shape blog posts, videos, newsletters, and social content.

#### Community Research
Community managers and moderators can review posts from a specific subreddit to understand what members care about most. The combination of title, author, score, and created time makes it easier to identify active discussions, recurring themes, and posts that may need attention.

#### Competitive Intelligence
Founders and business teams can search for competitor names, product categories, or industry terms to see how people compare options. Looking at post details such as score, comments, and post link helps them understand what users like, dislike, and recommend in public discussions.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| query | string | Yes | The word or phrase you want to search for in Reddit posts. | nike |
| sort | string | Yes | Choose how the matching posts should be ordered. | new |
| subreddit | string | Yes | Limit the search to one subreddit by entering its name. | python |
| time | string | No | Choose how recent the matching posts should be. | all |
| max_results | integer | No | The maximum number of posts to return. The actor keeps loading more results until it reaches this limit. | 10 |

### Output

| Field | Type | Description |
|---|---|---|
| title | string | The post headline, so you can quickly understand what the discussion is about. |
| subreddit | string | The community where the post was published. |
| author | string | The Reddit user who created the post. |
| score | number | A simple popularity indicator that helps you judge how much attention the post received. |
| comment_count | number | How many comments the post has, which helps show how active the discussion is. |
| post_url | string | A direct link to the Reddit post for quick viewing and follow-up. |
| created_time | string | When the post was published, shown in a human-friendly format. |
| selftext | string | The body text of the post, if the post includes written content. |
| permalink | string | A shorter Reddit link path that can be used to identify the post. |
| id | string | The unique post identifier, useful for tracking or deduplication. |
| url | string | The main link attached to the post, if the post points to an external page. |

### Sample Output

```json
{
  "title": "Best running shoes for long-distance training in 2026",
  "subreddit": "running",
  "author": "trailtempo",
  "score": 184,
  "comment_count": 67,
  "post_url": "https://www.reddit.com/r/running/comments/abc123/best_running_shoes_for_longdistance_training_in_2026/",
  "created_time": "2026-07-01 14:22:10",
  "selftext": "Looking for recommendations for long-distance training shoes that balance comfort, durability, and support...",
  "permalink": "/r/running/comments/abc123/best_running_shoes_for_longdistance_training_in_2026/",
  "id": "abc123",
  "url": "https://example.com/running-shoe-guide"
}
````

### How It Works

1. You enter the keyword or phrase you want to search for.
2. You choose the subreddit, sort order, and optional time range.
3. The actor searches Reddit posts that match your criteria.
4. It keeps collecting more results automatically until it reaches your requested limit.
5. You receive a clean list of posts that is ready to review, export, or share.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, fill in your search keyword, subreddit, sort order, and optional time range, then click **Run**. The actor will collect matching Reddit posts and present them in a clean format that is easy to review. You can download the results as JSON, CSV, or Excel depending on how you want to use the data.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users and researchers who want Reddit post data without dealing with complicated setup. Just enter your search terms, choose a subreddit, and run it.

#### How fast does it run?

It usually runs quickly for small searches and may take a bit longer when you request more results. The total time depends on how broad your search is and how many posts need to be collected.

#### What format is the output?

Your results are available in easy-to-use formats such as JSON, CSV, and Excel. That makes it simple to review the data yourself or share it with teammates.

#### Is this legal to use?

This tool is intended for collecting publicly available Reddit post information. You should always use the data responsibly and make sure your use complies with applicable laws, Reddit’s terms, and your own internal policies.

#### Can I schedule it to run automatically?

Yes, you can set it up to run on a schedule if you want regular updates. This is useful for ongoing brand monitoring, trend tracking, or recurring research reports.

# Actor input Schema

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

How to sort the results.

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

Limit results to posts from a specific time range.

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

The keyword or phrase to search for in Reddit posts.

## `subreddit` (type: `string`):

The name of the subreddit to search in.

## `max_results` (type: `integer`):

Maximum number of posts to return.

## Actor input object example

```json
{
  "sort": "new",
  "time": "all",
  "query": "nike",
  "max_results": 10
}
```

# 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 = {
    "sort": "new",
    "query": "nike"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/reddit-post-searcher").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 = {
    "sort": "new",
    "query": "nike",
}

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/reddit-post-searcher").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 '{
  "sort": "new",
  "query": "nike"
}' |
apify call datamagnet/reddit-post-searcher --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Post Search",
        "description": "Search Reddit posts by keyword and get a clean list of matching results. Narrow results by subreddit, sort order, and time range to quickly find the most relevant posts.",
        "version": "0.0",
        "x-build-id": "GKVjigcaY90SfMUC4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~reddit-post-searcher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-reddit-post-searcher",
                "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/datamagnet~reddit-post-searcher/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-reddit-post-searcher",
                "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/datamagnet~reddit-post-searcher/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-reddit-post-searcher",
                "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": {
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "confidence",
                            "top",
                            "new",
                            "controversial",
                            "old",
                            "qa"
                        ],
                        "type": "string",
                        "description": "How to sort the results."
                    },
                    "time": {
                        "title": "Time range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Limit results to posts from a specific time range."
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "The keyword or phrase to search for in Reddit posts."
                    },
                    "subreddit": {
                        "title": "Subreddit",
                        "type": "string",
                        "description": "The name of the subreddit to search in."
                    },
                    "max_results": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of posts to return."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
