# Reddit Scraper: Lead Finder, Brand Monitor, Mentions & Alerts (`harshmaur/reddit-scraper-pro`) Actor

Find leads and track brand mentions on Reddit. Monitor buying-intent phrases like "is there a tool", competitor names and keywords, flag real buyers with an AI label, and get new posts in Slack or Notion on a daily schedule. Social listening with no Reddit API key, from $1.50 per 1,000 results.

- **URL**: https://apify.com/harshmaur/reddit-scraper-pro.md
- **Developed by:** [Harsh Maur](https://apify.com/harshmaur) (community)
- **Categories:** Social media, Lead generation, Agents
- **Features:** Limited permissions
- **Stats:** 3,961 total users, 417 monthly users, 99.9% runs succeeded, 122 bookmarks
- **User rating**: 4.88 out of 5 stars

## Pricing

from $1.20 / 1,000 result saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reddit Scraper: Lead Finder, Brand Monitor, Mentions & Alerts

**Find people on Reddit who are asking for a product like yours, track every mention of your brand and your competitors, and get the results in Slack or Notion each morning. No Reddit account or API key. From $1.50 per 1,000 results, no monthly fee.**

[![Try on Apify](https://img.shields.io/badge/Apify-Try%20Now-00C7B7?style=for-the-badge\&logo=apify)](https://apify.com/harshmaur/reddit-scraper-pro) [![Input Schema](https://img.shields.io/badge/Input-Schema-blue?style=for-the-badge)](https://apify.com/harshmaur/reddit-scraper-pro/input-schema) [![API Docs](https://img.shields.io/badge/API-Docs-orange?style=for-the-badge)](https://apify.com/harshmaur/reddit-scraper-pro/api)

[Find leads](#how-to-find-leads-on-reddit) • [Brand and competitor monitoring](#reddit-brand-monitoring-and-competitor-mentions) • [Daily schedule](#schedule-a-daily-reddit-monitor) • [Slack and Notion](#send-reddit-mentions-to-slack-or-notion) • [Output](#reddit-lead-data-output-example) • [Pricing](#how-much-does-reddit-lead-generation-cost) • [FAQ](#faq)

***

### Who this Reddit lead finder is for

SaaS founders, growth marketers and agencies who already know their buyers hang out on Reddit, but don't have time to read it every day.

People post questions like these every day:

- "Is there a tool that does X?"
- "Looking for an alternative to \[your competitor]"
- "Can anyone recommend a \[your category]?"
- "I would pay for something that…"

Each of these is a warm lead, and the first useful reply usually wins. Reading Reddit by hand misses most of them. Running the same search by hand every morning wastes an hour.

This Actor does three jobs:

1. **Reddit lead generation:** searches for buying-intent phrases and lets an AI label mark the posts where someone wants a product.
2. **Reddit brand monitoring:** collects every new post (and, if you want, every comment) that names your brand or a competitor, with sentiment.
3. **Daily delivery:** runs on a schedule and sends new threads to a Slack channel or a Notion database.

You set it up once. After that, the leads come to you.

***

### How to find leads on Reddit

Reddit lead generation works best as a small daily habit: a handful of short buying-intent phrases, posts from the last day only, and one AI question that removes the noise.

#### Step 1: Pick short buying-intent phrases

Reddit matches your words almost literally. A phrase of two to four words finds posts. A long sentence that describes your product ("software that helps agencies track client invoices") usually returns nothing, because nobody writes those exact words.

Good starting phrases for Reddit buying intent:

| Pattern | Examples |
| --- | --- |
| Asking for a tool | `is there a tool`, `is there an app`, `looking for software` |
| Asking for a recommendation | `recommend a CRM`, `best invoicing app` |
| Switching away | `alternative to Pipedrive`, `switching from Trello` |
| Ready to spend | `would pay for`, `worth paying for` |

Mix generic phrases with your category name. `is there a tool` on its own matches every topic on Reddit; `invoicing tool` only matches your market.

Quotes (`"would pay for"`) force an exact phrase. They cut noise, but they also return fewer posts, so start without them and add quotes only to phrases that bring back junk.

#### Step 2: Run the lead search

```json
{
  "searchTerms": [
    "invoicing tool",
    "alternative to FreshBooks",
    "recommend invoicing software",
    "would pay for invoicing",
    "QuickBooks alternative"
  ],
  "searchPosts": true,
  "searchComments": false,
  "crawlCommentsPerPost": false,
  "searchSort": "new",
  "postedAfter": "1 day",
  "maxPostsCount": 30,
  "customLabels": {
    "wants_software": "true only if the author wants to find, buy or switch to a software product; false for job posts, hiring a person, news, and authors advertising their own product"
  }
}
```

What each setting does:

- `searchTerms`: one search per phrase. Free Apify plans search the first 40 phrases of a run.
- `searchPosts: true`, `searchComments: false`: posts only. Most buying questions are written as posts, and comment search returns far more rows.
- `crawlCommentsPerPost: false`: skips the reply threads. The Console form starts with both comment limits at 0, but an API call or old task that leaves these fields out collects comments, so set them in every saved input.
- `postedAfter: "1 day"`: limits results to posts written in the day before each run, so a daily run never shows the same thread twice.
- `maxPostsCount: 30`: a ceiling per phrase that protects your budget on a busy day.
- `customLabels`: your own yes/no question for the AI, answered on every post.

#### Step 3: Keep only real buyers with one custom label

Open the dataset and filter on `customLabels.wants_software = true`. That is your lead list.

Why a custom label instead of the ready-made `wantsHelp` checkbox? `wantsHelp` is true for anyone who wants help of any kind, and that includes people hiring a freelancer and posts sharing news. In our own test on 14 October 2026 (three CRM searches, one day of posts, 35 posts in total), `wantsHelp` marked 14 posts and many of them were job ads. A `wants_software` label marked 7, and 5 of those were people actually choosing a tool.

Write your label instruction the same way: say what counts as true, then list the look-alikes that should be false.

Other checkboxes that help qualify a lead, each adding a field under `aiFlags`:

- `willingToPay`: the author names a budget or says they would pay.
- `isOwner`: the author runs a business (a decision maker, not an employee).
- `painPoint`: the problem in under 15 words, ready to quote in your reply.

AI labels need a paid Apify plan. On the Free plan the run still works and returns posts, without the AI fields.

#### Step 4: Searching comments too (optional)

Turning on `searchComments` finds buyers who ask inside other people's threads. In the same test, posts plus comments saved 380 rows instead of 35, so the run cost about ten times more. Start with posts only. Add comments later for one or two phrases that matter most, and cap them with `maxCommentsCount`.

***

### Reddit brand monitoring and competitor mentions

The same search finds Reddit mentions of a name. Put your brand and your competitors in `searchTerms`, keep the date window at one day, and turn on AI analysis for Reddit sentiment.

```json
{
  "searchTerms": ["YourBrand", "CompetitorOne", "CompetitorTwo"],
  "searchPosts": true,
  "searchComments": true,
  "maxCommentsCount": 50,
  "crawlCommentsPerPost": false,
  "searchSort": "new",
  "postedAfter": "1 day",
  "commentedAfter": "1 day",
  "maxPostsCount": 50,
  "aiAnalysis": true,
  "hasPain": true,
  "competitor": true
}
```

Here comments are worth it: many brand mentions sit in replies ("we moved to CompetitorOne last year and…"). `maxCommentsCount` caps the comment rows per name, and `commentedAfter` drops older comments.

What you get on each result:

- `searchTerm`: which name the result was found for, so you can split your brand from each competitor.
- `sentimentLabel` and `sentimentScore`: positive, negative, neutral, mixed or uncertain, with a score from -1 to 1.
- `intent`: for example `complaint`, `praise`, `comparison` or `purchase_intent`.
- `aiFlags.hasPain` and `aiFlags.competitor`: whether the author describes a problem, and which product they name.
- `entities`: the brands and products the text mentions.

#### Reddit competitor monitoring ideas

- **Unhappy competitor users.** Filter on `searchTerm = CompetitorOne` and `aiFlags.hasPain = true`. These people are already shopping.
- **Head-to-head threads.** Filter on `intent = comparison` to see how Reddit ranks you against others.
- **Your own support issues.** Filter your brand name on `sentimentLabel = negative` and answer before the thread grows.

#### Monitor one community only

To watch a niche instead of all of Reddit, set `withinCommunity` to one subreddit name, for example `SaaS` or `r/smallbusiness`. Each phrase is then searched inside that subreddit only.

Brand names that are common words (an app called "Notion" or "Linear") match a lot of unrelated posts. Add a word that only appears with your product (`Linear app`, `Notion template`), or filter on `relevanceScore`, an AI score from 0 to 1 for how well each result matches its search term.

***

### Schedule a daily Reddit monitor

A Reddit keyword monitor is the same search, run every day. Two ways to set it up in Apify:

1. **From a run:** finish one run with the input you want, then open **Actions → Schedule** and pick a time.
2. **From a saved task:** save the input as a task in Apify Console, then go to **Schedules → Create new** and add that task. A task keeps the input fixed, so you can run several monitors side by side (one for leads, one per competitor).

Keep `postedAfter` relative so the window moves with each run:

| Schedule | `postedAfter` | `commentedAfter` |
| --- | --- | --- |
| Every day | `1 day` | `1 day` |
| Twice a day | `12 hours` | `12 hours` |
| Every Monday | `7 days` | `7 days` |

The relative value is counted back from the moment the run starts. When `postedAfter` is set, the search runs newest-first and the `searchTime` dropdown is ignored, so you don't need to touch it.

A fixed date (`2026-10-01`) works too, for a one-off export of a past period.

***

### Send Reddit mentions to Slack or Notion

Reddit to Slack and Reddit to Notion work without code through the `mcpConnector` input. Your app login stays in your Apify account; this Actor only gets the connector's ID.

#### Set it up

1. In Apify Console, open **Settings → API & Integrations → MCP connectors** and connect Slack or Notion. You can also create the connector straight from the input field.
2. In this Actor's input, pick the connector in **Send results to an app (MCP connector)** (`mcpConnector`).
3. Set `mcpTarget` to where the messages should go: a Slack channel ID (open the channel details in Slack to copy it) or a Notion database ID.
4. Optional: change the message with `mcpMessage`.

#### Example: daily leads to a Slack channel

Add these fields to the lead search above:

```json
{
  "mcpConnector": "<your Slack connector>",
  "mcpTarget": "C07ABCDE123",
  "mcpMode": "perPost",
  "mcpMessage": "Buyer: {{customLabels.wants_software}} | {{communityName}}\n**{{title}}**\n{{postUrl}}",
  "mcpMaxItems": 50
}
```

`mcpMessage` accepts any post field in `{{double braces}}`, including nested ones such as `{{customLabels.wants_software}}` or `{{aiFlags.painPoint}}`. Putting the label at the start of the message lets you scan the channel and open only the buyers.

#### How delivery works

- **After the crawl.** Messages are sent once the search finishes, from the saved results, so they include the AI fields.
- **Posts are sent, not search comments.** Each message is one post. Comments found by comment search stay in the dataset. If `crawlCommentsPerPost` is on, `mcpComments` can add each post's top replies (`bundle`) or send them as their own messages (`separate`); the default `ignore` sends posts only.
- **One message per post or one digest.** `mcpMode: "perPost"` sends a message for each post, up to `mcpMaxItems` (default 50). `mcpMode: "summary"` sends one digest with the run's post titles and links.
- **A delivery problem never fails the run.** If the connector is down or rejects a message, the run still finishes, every result stays in the dataset, and the problem is written to the run log.
- **No connector, no delivery.** Leave `mcpConnector` empty and the Actor only saves results.

For Notion, `mcpArguments` lets you map fields to your database columns, for example `{"properties": {"Title": {"title": [{"text": {"content": "{{title}}"}}]}, "Link": {"url": "{{postUrl}}"}}}`.

***

### Reddit lead data output example

One post from the lead search, with the `wants_software` label and one AI flag. Values are shortened.

```json
{
  "dataType": "post",
  "id": "t3_1g7xk2p",
  "parsedId": "1g7xk2p",
  "searchTerm": "alternative to FreshBooks",
  "title": "Alternative to FreshBooks for a 3-person agency?",
  "body": "Our FreshBooks plan went up again. We send about 40 invoices a month...",
  "authorName": "agency_ops_kim",
  "communityName": "r/smallbusiness",
  "postUrl": "https://www.reddit.com/r/smallbusiness/comments/1g7xk2p/alternative_to_freshbooks_for_a_3person_agency/",
  "createdAt": "2026-10-16T21:04:37.000Z",
  "crawledAt": "2026-10-17T07:00:12.000Z",
  "score": 12,
  "upVotes": 12,
  "commentsCount": 9,
  "flair": "Question",
  "removalStatus": "active",
  "sentimentLabel": "negative",
  "sentimentScore": -0.4,
  "intent": "seeking_recommendation",
  "emotion": "frustration",
  "entities": ["FreshBooks"],
  "relevanceScore": 0.93,
  "contentCategory": "Business & Startups",
  "aiFlags": {
    "willingToPay": true
  },
  "customLabels": {
    "wants_software": true
  }
}
```

Fields used most for leads and monitoring:

| Field | What it tells you |
| --- | --- |
| `dataType` | `post` or `comment`; filter on it when you search both |
| `searchTerm` | The phrase or brand name that found the result |
| `title`, `body` | What the author wrote |
| `postUrl` | Link to the post (comments carry `url`) |
| `communityName` | The subreddit, with the `r/` prefix |
| `createdAt` | When the post was written (UTC); comments use `commentCreatedAt` |
| `customLabels` | Answers to your own AI questions, by label name |
| `aiFlags` | Answers to the ticked AI checkboxes |
| `intent`, `sentimentLabel` | Why the author posted and how they feel |
| `relevanceScore` | How closely the result matches its search term, 0 to 1 |
| `removalStatus` | Whether the post is still live, or was removed and by whom |

Every result has many more fields (media, flair, author details, engagement numbers). The full list is on the **Output** tab. Download results as JSON, CSV or Excel, or read them through the Apify API.

***

### How much does Reddit lead generation cost?

You pay per event. There is no subscription, and a month with no runs costs nothing.

| Event | Price |
| --- | --- |
| Actor start | $0.01 per GB of memory (default 512 MB run: $0.01) |
| Result saved (post or comment) | $0.0015 on the Free plan; $0.0014, $0.0013 or $0.0012 on paid plans |
| AI analyzed result | $0.0005 per result, only when AI analysis, an AI checkbox or a custom label is on |
| AI custom label | $0.0001 per label per result |

A custom label or AI checkbox always includes the full AI analysis, so a labeled result costs the analyzed-result fee plus $0.0001 for each label.

#### Worked example: a daily lead monitor

Five buying-intent phrases, posts only, about 20 new posts per phrase per day, one `wants_software` label, run daily for 30 days. AI labels need a paid plan, so this uses the $0.0014 paid-plan result price.

| Item | Calculation | Cost per month |
| --- | --- | --- |
| Starts | 30 runs × $0.01 | $0.30 |
| Results | 3,000 posts × $0.0014 | $4.20 |
| AI analysis | 3,000 × $0.0005 | $1.50 |
| `wants_software` label | 3,000 × $0.0001 | $0.30 |
| **Total** | | **$6.30** |

The same monitor on the Free plan without AI labels: $0.30 + 3,000 × $0.0015 = **$4.80 a month**, which fits inside the $5 monthly credit that comes with a free Apify account.

Searching comments as well can multiply the result count by ten or more, so keep `searchComments` off for lead searches unless you need it.

#### Keep the cost under control

- `maxPostsCount` caps posts per phrase; `maxCommentsCount` caps comment-search results per phrase.
- `crawlCommentsPerPost` and `searchComments` are on when an input leaves them out. Set both to `false` in API calls and saved tasks when you only need posts.
- A relative `postedAfter` (`1 day`) keeps a scheduled run from collecting old posts again.
- Set a maximum charge in the run options. The run stops cleanly at that amount and keeps what it saved.

> Collecting more than 100,000 results a month? Email harshmaur@gmail.com about volume pricing.

***

### Use the Reddit monitor with AI agents, n8n, Make and Zapier

- **AI agents (MCP).** Claude, ChatGPT, Cursor and other MCP clients can call this Actor as a tool through the Apify MCP server at `https://mcp.apify.com/?tools=harshmaur/reddit-scraper-pro`. Ask your agent "find Reddit posts from this week asking for an alternative to FreshBooks" and it fills in the input.
- **n8n, Make and Zapier.** Apify has an integration for each. Run this Actor and read its dataset items in the next step, then route the results to your CRM, a sheet or email.
- **Templates to start from.** These n8n and Make templates call the main Reddit Scraper. To run this listing, set the Actor to `harshmaur/reddit-scraper-pro` in the Apify step. In n8n: [subreddit posts to Slack](https://n8n.io/workflows/20980-send-new-subreddit-posts-to-slack-with-apify-reddit-scraper/) and [keyword mentions to Slack and Gmail](https://n8n.io/workflows/21035-track-reddit-keyword-mentions-with-apify-and-send-alerts-to-slack-and-gmail/). In Make: [daily keyword alerts](https://www.make.com/hq/template/20007) and [AI lead scoring](https://www.make.com/hq/template/20018).
- **Webhooks and API.** Start runs and read datasets over the Apify API, or have Apify call your URL when a run finishes.
- **Always run the latest build.** Leave the Build field empty in n8n, Make and Zapier, and do not send a `build` number to the API. Old builds stop working when Reddit changes. We delete them, so a pinned run fails with `build-not-found`.

***

### FAQ

#### Is it allowed to collect Reddit posts this way?

This Actor reads only public Reddit pages: no login and no private messages. Collecting public data is generally allowed, but you are responsible for following Reddit's terms and the privacy laws that apply to you, especially when you contact people. Apify explains the legal side in [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Does it need a Reddit API key, app or login?

No. You don't need a Reddit account, a Reddit app, or an API access request. Reddit's changes to its API and RSS feeds do not affect this Actor.

#### How fresh are the results?

Each run reads Reddit at the moment it runs. With a daily schedule and `postedAfter: "1 day"`, every morning's results cover the 24 hours before the run started. Run twice a day with `12 hours` if you need to reply faster.

#### Why did my search return no results?

The usual causes:

- **The phrase is too long.** Cut it to two to four words that a real person would type.
- **Too many quotes.** An exact phrase in quotes, especially inside one subreddit (`withinCommunity`), can match nothing on a quiet day.
- **The window is too short.** `postedAfter: "1 day"` on a niche phrase may have no new posts that day. Try `7 days` once to check that the phrase finds anything at all.

#### Should I search posts or comments?

For leads, start with posts: most people asking for a tool start a thread, and posts-only runs cost about a tenth of posts-plus-comments runs. For brand monitoring, add comments with a `maxCommentsCount` cap, because many mentions are replies.

#### How do I stop a run from costing more than I expect?

Set `maxPostsCount` and `maxCommentsCount`, turn off `crawlCommentsPerPost` unless you need full threads, and set a maximum charge in the run options. See [Keep the cost under control](#keep-the-cost-under-control).

#### Does sentiment analysis work on the Free plan?

No. `aiAnalysis`, the AI checkboxes and `customLabels` need a paid Apify plan. On the Free plan they are ignored and not charged, and the run returns results without the AI fields.

#### Can Slack or Notion get only the leads, not every post?

Delivery sends every post the run finds, up to `mcpMaxItems`. Put `{{customLabels.wants_software}}` at the start of `mcpMessage` so each message shows whether it is a buyer, or filter the dataset on `customLabels.wants_software = true` before you work the list.

***

### Other Reddit tools by the same developer

| Actor | Use it when you need |
| --- | --- |
| [Reddit Comments Scraper](https://apify.com/harshmaur/reddit-comments-scraper) | The full reply tree of threads you already have links for |
| [Reddit Search Scraper](https://apify.com/harshmaur/reddit-search-scraper) | Plain keyword search results without the monitoring setup |
| [Reddit User Scraper](https://apify.com/harshmaur/reddit-user-scraper) | Post and comment history of specific Reddit accounts |
| [Subreddit Scraper](https://apify.com/harshmaur/reddit-subreddit-scraper) | A large archive of one community, beyond the usual listing limit |

***

*Built by [Harsh Maur](https://github.com/harshmaur). Questions or a feature request? [Email support](mailto:harshmaur@gmail.com).*

# Actor input Schema

## `searchTerms` (type: `array`):

Enter one or more keywords to search Reddit (e.g. "recommend a CRM", "alternative to HubSpot", or your brand name). Keep each phrase short: Reddit search is literal, so a long sentence usually finds nothing. Each keyword runs as a separate search. Free Apify plans search the first 40 keywords per run (paid plans are unlimited) — extra keywords are skipped and noted in the run log. Quoted phrases return fewer posts, especially inside one community. Leave empty if you only want to scrape Direct URLs below.

## `searchPosts` (type: `boolean`):

Include posts in keyword search results.

## `searchComments` (type: `boolean`):

Include comments in keyword search results. Each comment is a billed result (up to 'Max search comments' per keyword).

## `searchCommunities` (type: `boolean`):

Include communities (subreddits) in keyword search results.

## `withinCommunity` (type: `string`):

Restrict keyword search to a single subreddit. This is a name, not a post limit. Accepts a bare name (developers), r/developers, or a full subreddit URL. Leave empty to search all of Reddit. Only applies to Search Keywords.

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

Controls how keyword search results are ranked. Only applies to Search Keywords, not Direct URLs.

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

Limit keyword search results to posts from a specific time window. Only applies to Search Keywords.

## `aiAnalysis` (type: `boolean`):

Adds AI-judged fields to posts and comments: `sentimentLabel` (positive / negative / neutral / mixed / uncertain), `sentimentScore` (-1 to 1), `intent` (question, seeking_recommendation, complaint, praise, purchase_intent, comparison, announcement, self_promotion, discussion), `emotion` (joy, excitement, anger, frustration, sadness, disappointment, fear, surprise, neutral), `entities` (brands, products and companies mentioned), and — for keyword-search results — `relevanceScore` (0 to 1). Posts also receive a `contentCategory`. The model understands Reddit slang and sarcasm; bot and moderator boilerplate is labelled `uncertain` free of charge. Each analyzed result is billed once as an `analyzed_item` event — see the Pricing tab. Requires a paid Apify plan and is ignored on free plans.

## `wantsHelp` (type: `boolean`):

Adds `aiFlags.wantsHelp` (true/false) to every analyzed post and comment: true when the author is looking for a product, service, or person to solve their problem — the classic lead signal. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `isOwner` (type: `boolean`):

Adds `aiFlags.isOwner` (true/false) to every analyzed post and comment: true when the author founded, owns, or operates a business (not a customer or employee). Billed as one `custom_label` event per result ($0.10 per 1,000).

## `isVendor` (type: `boolean`):

Adds `aiFlags.isVendor` (true/false) to every analyzed post and comment: true when the author is selling, promoting, or recruiting testers for their own product or service. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `hasPain` (type: `boolean`):

Adds `aiFlags.hasPain` (true/false) to every analyzed post and comment: true when the author describes a problem, a failed tool, or something not working. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `mentionsPrice` (type: `boolean`):

Adds `aiFlags.mentionsPrice` (true/false) to every analyzed post and comment: true when the text mentions a price, fee, retainer, subscription cost, or money spent. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `featureRequest` (type: `boolean`):

Adds `aiFlags.featureRequest` (true/false) to every analyzed post and comment: true when the author asks for or describes a feature or product that does not exist yet. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `willingToPay` (type: `boolean`):

Adds `aiFlags.willingToPay` (true/false) to every analyzed post and comment: true when the author names a budget, asks for a quote, or says they would pay. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `painPoint` (type: `boolean`):

Adds `aiFlags.painPoint` (text) to every analyzed post and comment: the problem or unmet need in under 15 words, or none. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `competitor` (type: `boolean`):

Adds `aiFlags.competitor` (text) to every analyzed post and comment: the competing product, brand, or tool mentioned, or none. Billed as one `custom_label` event per result ($0.10 per 1,000).

## `customLabels` (type: `object`):

Define your own labels as `{"label_name": "plain-language instruction"}` and the AI evaluates each one on every analyzed post and comment, returning them under `customLabels` on each result. Example: `{"mentions_pricing": "true if the text complains about pricing or cost", "competitor": "name the competing product mentioned, or none"}`. Up to 5 labels; names must be short identifiers (letters, digits, underscore). The AI flag checkboxes above do not count against this cap. Each label evaluated on each result is billed as one `custom_label` event — 3 labels on 1,000 results = 3,000 events. An evaluation that finds nothing (an empty/null answer, when your instruction allows it) is still an evaluation and is charged; nothing is charged for results the AI could not process. Setting custom labels enables the full AI Analysis on the same items — each labeled result is also billed once as an `analyzed_item`. Paid add-on: requires a paid Apify plan; ignored on free plans.

## `postedAfter` (type: `string`):

Only keep posts created on or after this date (00:00 UTC), or within a relative period counted back from the run start, e.g. '1 day' for a daily schedule or '7 days' for a weekly one. When set, results are fetched newest-first (sort=new) and the search Time range is ignored. Reddit caps each listing at ~1,000 posts, so a window behind a very high-volume query may be only partly reachable. Applies to Search Keywords, subreddit URLs, the Full Subreddit Scrape, and user profiles.

## `postedBefore` (type: `string`):

Only keep posts created on or before this date (the end of that day, 23:59:59 UTC). A relative value such as '1 day' keeps only posts at least one day old.

## `commentedAfter` (type: `string`):

Only keep comments created on or after this date (UTC), or within a relative period such as '1 day' for a daily schedule. Applies when comments are collected (comment search, or 'Scrape comments for each post').

## `commentedBefore` (type: `string`):

Only keep comments created on or before this date (UTC).

## `onlyWithFlair` (type: `boolean`):

When enabled, drop posts with no flair and keep only those that have a flair assigned. Applies to Search Keywords, subreddit URLs, the Full Subreddit Scrape, and user profiles.

## `mcpConnector` (type: `string`):

Pick an authorized MCP connector (Slack, Notion, GitHub, Airtable, Supabase, …) to receive the scraped posts. This is the recommended, secure path — your credentials stay in Apify and are never exposed to this actor (Apify's proxy injects them). Leave empty to scrape only. Create connectors under Settings → API & Integrations → MCP connectors, or inline here.

## `mcpMode` (type: `string`):

perPost: send one message/record per scraped post. summary: send a single digest of the whole run.

## `mcpTarget` (type: `string`):

Where to write — the destination ID the tool needs: a Notion database/page ID, a Google Sheet ID, a Slack channel, or owner/repo. Leave blank for connectors that post to a default location. Advanced shapes go in Arguments JSON below.

## `mcpComments` (type: `string`):

When 'Scrape comments for each post' is on, choose how comments reach your app. Ignore: send posts only (comments still saved to the dataset). Bundle: attach each post's top comments inside its message. Separate: send each top comment as its own message/record.

## `mcpCommentsPerPost` (type: `integer`):

How many top comments (by score) to include per post when bundling or sending comments. Requires 'Scrape comments for each post'.

## `mcpMessage` (type: `string`):

Template for each message. Use {{field}} placeholders from ANY post field — common ones: {{title}}, {{body}}, {{postUrl}}, {{authorName}}, {{score}}, {{upVotes}}, {{commentsCount}}, {{communityName}}, {{flair}}, {{createdAt}}. Nested/array fields work via dot or \[index] paths: {{mediaAssets.0.url}}, {{galleryImages\[0]}}, {{media.reddit_video.fallback_url}}. (Full field list in the README.) Missing fields render empty.

## `mcpTool` (type: `string`):

Force a specific tool name on the connector (e.g. send_message, create_page, append_row). Leave empty to auto-detect the connector's write/notify tool.

## `mcpArguments` (type: `object`):

Extra/override arguments merged into each tool call as JSON — e.g. {"channel": "#reddit"} for Slack. {{field}} placeholders work inside string values too, so you can nest live data into any shape the tool needs — e.g. Notion: {"properties": {"Title": {"title": \[{"text": {"content": "{{title}}"}}]}, "Link": {"url": "{{postUrl}}"}}}. Use it to satisfy required fields or fully control the payload.

## `mcpMaxItems` (type: `integer`):

Safety cap on how many posts are piped to the connector per run (perPost mode). Protects against flooding the destination.

## `mcpServerUrl` (type: `string`):

Advanced/testing only. Connect directly to a raw MCP server URL, bypassing the MCP Connector above. For real use prefer a connector — with a connector your credentials stay in Apify and are never seen by this actor. When set, this overrides the connector.

## `mcpServerToken` (type: `string`):

Bearer token for the dev MCP server URL above. Note: a token entered here IS visible to the actor at runtime — for production use an MCP Connector instead, so credentials never leave Apify. Ignored unless the URL is set.

## `crawlCommentsPerPost` (type: `boolean`):

When enabled, comments will be collected for every post found from both Search Keywords and Direct URLs. This significantly increases run time and data output. Each comment is a billed result: 50 posts × 200 comments can be 10,000 results.

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

Include posts marked as Not Safe For Work in results. Applies to both Search Keywords and Direct URLs.

## `maxPostsCount` (type: `integer`):

Maximum posts saved for EACH search keyword and EACH Reddit URL: 5 keywords × 50 = up to 250 posts. Full Subreddit Scrape uses this as one total. Each saved post is a billed result. Reddit search returns up to about 2,000 posts for a busy keyword; use Full Subreddit Scrape for more. Max: 50000.

## `maxCommentsCount` (type: `integer`):

Maximum comments returned per search keyword (when 'Search for comments' is enabled). Does not affect per-post comment scraping.

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

Maximum comments to scrape per individual post (when 'Scrape comments for each post' is enabled). Each comment is a billed result: 50 posts × 200 comments can be 10,000 results.

## `maxCommunitiesCount` (type: `integer`):

Maximum communities returned from keyword search (when 'Search for communities' is enabled).

## `startUrls` (type: `array`):

Add one or more Reddit URLs to scrape directly. Supports post URLs, subreddit URLs, user profile URLs, and search page URLs. The Search Keywords options above (sort, time, community filter) do NOT apply to these URLs.

## `subredditUrls` (type: `array`):

Subreddits to scrape in full. Enter subreddit names or links — e.g. `AskReddit`, `r/AskReddit`, or `https://www.reddit.com/r/AskReddit/`. This collects far more posts per subreddit than a standard scrape. It uses more requests, so runs take longer and cost more. Comments are also collected when 'Scrape comments for each post' is enabled — increase Max posts to allow more results per subreddit.

## Actor input object example

```json
{
  "searchTerms": [
    "recommend a CRM",
    "alternative to HubSpot",
    "looking for a CRM"
  ],
  "searchPosts": true,
  "searchComments": true,
  "searchCommunities": false,
  "withinCommunity": "",
  "searchSort": "new",
  "searchTime": "week",
  "aiAnalysis": false,
  "wantsHelp": false,
  "isOwner": false,
  "isVendor": false,
  "hasPain": false,
  "mentionsPrice": false,
  "featureRequest": false,
  "willingToPay": false,
  "painPoint": false,
  "competitor": false,
  "customLabels": {
    "wants_software": "true only if the author wants to find, buy or switch to a software product; false for job posts, hiring a person, news, and authors advertising their own product"
  },
  "onlyWithFlair": false,
  "mcpMode": "perPost",
  "mcpComments": "ignore",
  "mcpCommentsPerPost": 5,
  "mcpMessage": "**{{title}}**\n{{postUrl}}",
  "mcpMaxItems": 50,
  "crawlCommentsPerPost": true,
  "includeNSFW": false,
  "maxPostsCount": 25,
  "maxCommentsCount": 0,
  "maxCommentsPerPost": 0,
  "maxCommunitiesCount": 2,
  "startUrls": [],
  "subredditUrls": []
}
```

# Actor output Schema

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

All scraped Reddit data including posts, comments, communities, and user profiles. Use 'dataType' field to filter by type.

## `runSummaryMap` (type: `string`):

Visual report of this run: how many posts, comments and communities were saved, what was skipped and why, and any input we adjusted for you.

## `runSummaryJson` (type: `string`):

The same run summary as machine-readable JSON, for pipelines and monitoring.

# 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 = {
    "searchTerms": [
        "recommend a CRM",
        "alternative to HubSpot",
        "looking for a CRM"
    ],
    "searchSort": "new",
    "searchTime": "week",
    "customLabels": {
        "wants_software": "true only if the author wants to find, buy or switch to a software product; false for job posts, hiring a person, news, and authors advertising their own product"
    },
    "mcpMode": "perPost",
    "mcpComments": "ignore",
    "mcpCommentsPerPost": 5,
    "mcpMessage": `**{{title}}**
{{postUrl}}`,
    "mcpMaxItems": 50,
    "maxPostsCount": 25,
    "maxCommentsCount": 0,
    "maxCommentsPerPost": 0,
    "maxCommunitiesCount": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("harshmaur/reddit-scraper-pro").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 = {
    "searchTerms": [
        "recommend a CRM",
        "alternative to HubSpot",
        "looking for a CRM",
    ],
    "searchSort": "new",
    "searchTime": "week",
    "customLabels": { "wants_software": "true only if the author wants to find, buy or switch to a software product; false for job posts, hiring a person, news, and authors advertising their own product" },
    "mcpMode": "perPost",
    "mcpComments": "ignore",
    "mcpCommentsPerPost": 5,
    "mcpMessage": """**{{title}}**
{{postUrl}}""",
    "mcpMaxItems": 50,
    "maxPostsCount": 25,
    "maxCommentsCount": 0,
    "maxCommentsPerPost": 0,
    "maxCommunitiesCount": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("harshmaur/reddit-scraper-pro").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 '{
  "searchTerms": [
    "recommend a CRM",
    "alternative to HubSpot",
    "looking for a CRM"
  ],
  "searchSort": "new",
  "searchTime": "week",
  "customLabels": {
    "wants_software": "true only if the author wants to find, buy or switch to a software product; false for job posts, hiring a person, news, and authors advertising their own product"
  },
  "mcpMode": "perPost",
  "mcpComments": "ignore",
  "mcpCommentsPerPost": 5,
  "mcpMessage": "**{{title}}**\\n{{postUrl}}",
  "mcpMaxItems": 50,
  "maxPostsCount": 25,
  "maxCommentsCount": 0,
  "maxCommentsPerPost": 0,
  "maxCommunitiesCount": 2
}' |
apify call harshmaur/reddit-scraper-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,harshmaur/reddit-scraper-pro"
        }
    }
}
```

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/3XedXIRBcjfKrnsDJ/builds/ggnQKxnNPjzB2fEwB/openapi.json