# Reddit Lead Finder & Brand Mention Monitor (`whoareyouanas/reddit-lead-finder`) Actor

Reddit lead generation and keyword monitoring for AI agents. Search posts and comments in a subreddit, qualify buying intent, and track brand or competitor mentions. Export JSON or send Slack and Notion alerts. Reddit-wide keyword search requires ScrapeAtlas.

- **URL**: https://apify.com/whoareyouanas/reddit-lead-finder.md
- **Developed by:** [Anas Nadeem](https://apify.com/whoareyouanas) (community)
- **Categories:** Social media, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

Use this **Reddit lead finder and keyword monitoring Actor** to find buying-intent posts, search Reddit comments by keyword, and track brand or competitor mentions. The Actor returns structured JSON with discussion text, Reddit links, UTC timestamps, and optional AI labels. Run it in Apify Console, through the API, or from an AI agent using Apify MCP.

**Start with one subreddit.** Subreddit-scoped search and direct Reddit URLs need no Reddit API key and use the Arctic Shift archive. Reddit-wide keyword search requires a ScrapeAtlas API key. Archive ingestion can lag and engagement metrics can reflect an earlier snapshot.

### Run from an AI agent or API

Use Actor ID `whoareyouanas/reddit-lead-finder`. To expose it directly in an MCP client, connect to `https://mcp.apify.com?tools=whoareyouanas/reddit-lead-finder,storage,runs` and select `whoareyouanas--reddit-lead-finder`. [Apify MCP tool selection](https://docs.apify.com/mcp#tool-selection)

With the general Apify MCP tools, run the Actor as follows.

1. Call `fetch-actor-details` with the Actor ID for its schema and pricing.
2. Call `call-actor` with the Actor ID and a bounded JSON input. Set `withinCommunity` for an archive-backed search. Use one phrase, a date window, and explicit post and comment caps for the first call.
3. Wait for a terminal run status with `get-actor-run` if the run is still active. Pass the run’s dataset ID as `datasetId` to `get-dataset-items` and page through `limit` and `offset`.
4. Read record `OUTPUT` with `get-key-value-store-record` for counts, failures, and coverage warnings. Use `url` to cite the Reddit item and keep `createdAt` and `source` with any summary.

Running Actors and reading their results through Apify MCP requires an authenticated Apify connection. [Apify MCP tools](https://docs.apify.com/mcp)

For direct API access, send the same JSON input in an authenticated `POST` to `https://api.apify.com/v2/acts/whoareyouanas~reddit-lead-finder/runs`. Poll `GET /v2/actor-runs/{runId}` until it finishes, then read `GET /v2/datasets/{defaultDatasetId}/items?clean=true`. [Apify run and dataset API](https://docs.apify.com/academy/api/run-actor-and-retrieve-data-via-api)

### Quick start

Use the prefilled **Input** form in Apify Console to try a small subreddit search. For a lead search, change the community to one where your buyers participate and add phrases such as `"looking for an alternative"` or `"can anyone recommend"`.

For one existing discussion, add its permalink to `startUrls`, enable `crawlCommentsPerPost`, and set `maxCommentsPerPost` to bound the replies.

#### Find Reddit posts asking for CRM recommendations

This input searches r/smallbusiness and labels up to eight posts. Review the original posts where `customLabels.needs_software` is `true`.

```json
{
  "searchTerms": ["crm"],
  "withinCommunity": "smallbusiness",
  "postedAfter": "21 days",
  "searchPosts": true,
  "searchComments": false,
  "crawlCommentsPerPost": false,
  "maxPostsCount": 8,
  "aiAnalysis": true,
  "wantsHelp": true,
  "customLabels": {
    "needs_software": "True when the writer asks for a CRM recommendation, is actively choosing a CRM, or wants to replace their own CRM. Mark false if they promote or link to their own product, even if the post is framed as a question. Exclude guides, product announcements, and hiring."
  }
}
```

#### Track Notion mentions in Reddit posts and comments

This input searches r/productivity for up to six posts and six comments. To monitor a different brand or competitor, replace `Notion` with the product name and select a relevant subreddit. Each result includes `searchTerm` and a link to its source.

```json
{
  "searchTerms": ["Notion"],
  "withinCommunity": "productivity",
  "postedAfter": "14 days",
  "commentedAfter": "14 days",
  "searchPosts": true,
  "searchComments": true,
  "crawlCommentsPerPost": false,
  "maxPostsCount": 6,
  "maxCommentsCount": 6
}
```

### Reddit keyword monitoring and comment search

| Input | Source | Credentials |
| --- | --- | --- |
| Keywords with `withinCommunity` | Arctic Shift archive | None |
| Reddit-wide post or comment keyword search | ScrapeAtlas | Encrypted `scrapeAtlasApiKey` input or `SCRAPEATLAS_API_KEY` |
| Community discovery | Arctic Shift name prefixes or ScrapeAtlas topic search when configured | Optional |
| Direct posts, comments, subreddit feeds, and public profiles | Arctic Shift archive | None |

Use a subreddit name, `r/name`, or a subreddit home URL in `withinCommunity`. Use `subredditUrls` to collect newest posts from multiple feeds. Direct Reddit search URLs use the scope and ranking in the URL.

Dates are UTC. `postedAfter` and `commentedAfter` accept calendar dates, timestamps with time zones, or relative windows such as `"12 hours"`. A lower date bound sorts the corresponding results newest-first. Use `postedBefore` or `commentedBefore` for inclusive upper bounds. For scheduled archive searches, overlapping windows can help with ingestion lag. Deduplicate overlapping runs by `dataType`, `id`, and `searchTerm`.

Search caps apply independently to each phrase and result type. `maxCommentsCount` limits keyword comments. `maxCommentsPerPost` limits replies for each expanded post. Both comment switches can be turned off for posts-only runs. Archive rankings other than newest first are approximated and source metrics may reflect an earlier snapshot.

For a comment-only search, set `searchPosts: false`, `searchComments: true`, and `crawlCommentsPerPost: false`. To collect the replies on one known post, supply its URL in `startUrls`, set `crawlCommentsPerPost: true`, and use `maxCommentsPerPost` for the reply cap.

### Find Reddit leads with AI labels

Turn on `aiAnalysis` to get sentiment, intent, emotion, named entities, relevance scores, and post categories. Built-in signals include `wantsHelp`, `willingToPay`, `hasPain`, `painPoint`, and `competitor`. Enabling a flag or a custom label also enables analysis.

Add up to five custom labels. Start an instruction with “True when” to get a boolean answer. The **Lead qualification** dataset view includes AI status, sentiment, intent, and label fields. Reddit content is saved even if the AI provider fails.

Apify runs can use the Apify OpenRouter integration. You can also use your own encrypted `openRouterApiKey`. The default model is `openai/gpt-4o-mini`. Set `aiModel` to another model that supports structured JSON output.

Use a product category such as `CRM` or a phrase such as `"alternative to HubSpot"` when you need buying-intent results. A generic term such as `recommend` can return advice requests, suppliers, and product promotion. Check `removalStatus` and review the original posts before acting on AI labels.

### Track Reddit brand mentions and send alerts

Save the input as an Apify task and add it to a schedule. Connect Slack or Notion through Apify MCP connectors, select the connector in `mcpConnector`, and enter a destination in `mcpTarget`.

- **Per post** sends a message per saved post up to `mcpMaxItems`. **Summary** sends one digest.
- **Thread replies** can be bundled into a post message or sent separately in per-post mode. Keyword-search-only comments remain in the dataset.
- **Message templates** support fields such as `{{title}}`, `{{postUrl}}`, and `{{customLabels.needs_software}}`. Use `mcpTool` and `mcpArguments` when a destination requires custom arguments or Notion database properties.

Delivery runs after the results are saved. Apify records connector failures in the run summary. [Apify MCP connector setup](https://docs.apify.com/integrations/mcp-connectors/use-in-actors)

### Output

Export results as JSON or CSV from the Apify dataset. Posts, comments, communities, and public profiles are separate row types identified by `dataType`. Optional source fields can be null.

| Field | Meaning |
| --- | --- |
| `id`, `dataType` | Reddit item identity and record type |
| `searchTerm`, `communityName` | Matching phrase and subreddit, when known |
| `title`, `body`, `url` | Discussion text and a link back to Reddit |
| `postId`, `parentId`, `threadComment` | Parent post, immediate parent, and thread-expansion flag on comment rows |
| `createdAt`, `crawledAt` | Source timestamp and collection timestamp in UTC |
| `removalStatus` | Removal status reported by the source |
| `analysisStatus`, `aiFlags`, `customLabels` | Optional AI results |
| `source` | The data provider that returned the row |

Illustrative lead result

```json
{
  "dataType": "post",
  "id": "t3_example",
  "searchTerm": "recommend",
  "communityName": "r/smallbusiness",
  "title": "Can anyone recommend a tool for recurring invoices?",
  "source": "arctic_shift",
  "analysisStatus": "analyzed",
  "intent": "seeking_recommendation",
  "customLabels": { "needs_software": true }
}
```

The run’s key-value store contains an `OUTPUT` summary with counts, coverage warnings, analysis results, and any delivery errors. An empty dataset can reflect the date filters, source lag, or provider coverage.

### Frequently asked questions

#### Can I monitor Reddit without a Reddit API key?

Yes. Set `withinCommunity` for a subreddit keyword search, or provide a Reddit URL. These modes query the Arctic Shift archive. Reddit-wide keyword search needs a ScrapeAtlas API key.

#### Can I search Reddit comments without collecting whole threads?

Yes. Turn on `searchComments` and set `crawlCommentsPerPost` to `false`. Use `maxCommentsCount` to cap keyword comments per phrase. Thread replies have a separate cap in `maxCommentsPerPost`.

#### Can I get Slack or Notion alerts for Reddit mentions?

Yes. Configure an Apify MCP connector and schedule an Apify task. Delivery sends saved posts in a digest or per-post message and can include replies collected from those posts. Keyword-search-only comments stay in the dataset.

#### How fresh are archive results?

Results become available as the archive ingests Reddit content. Check `createdAt`, `source`, and the run summary. For recurring monitoring, use a rolling window and deduplicate posts and comments by `dataType`, `id`, and `searchTerm` across runs.

### Pricing

This Actor uses Apify’s pay-per-usage model. Platform usage and any optional provider or model charges depend on the features you enable. Start with a short date window and a small per-phrase result cap to measure usage.

### Run locally

Use Node.js 22 or newer. The included sample searches r/learnpython and returns at most three posts and three comments.

```bash
npm ci
mkdir -p storage/key_value_stores/default
cp examples/scoped-leads.json storage/key_value_stores/default/INPUT.json
npm start
```

Set `OPENROUTER_API_KEY` if you enable local AI analysis. Results go under `storage/datasets/default/`. The example inputs and `npm test` are included in the project.

# Actor input Schema

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

Search one or more buying-intent phrases, products, or brands. Set withinCommunity for subreddit search. Reddit-wide keyword search requires ScrapeAtlas. Post and comment caps apply per phrase.

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

Set this to search a single subreddit through the Arctic Shift archive without a Reddit API key. Use a subreddit name, r/name, or community URL. Leave it empty for Reddit-wide search with ScrapeAtlas.

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

Return posts that match each phrase.

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

Search comment bodies for each phrase. Cap these rows with maxCommentsCount. Collecting replies from startUrls or matched posts uses crawlCommentsPerPost and maxCommentsPerPost.

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

Return matching community rows. Keyless discovery matches the start of community names.

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

A custom lower date bound forces newest-first for the corresponding result type.

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

A preset lookback for keyword search. An explicit lower date bound takes precedence.

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

UTC date, timestamp with a timezone, or lookback such as 1 day.

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

Inclusive UTC date or timestamp. A relative duration excludes newer posts.

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

Lower UTC bound for search comments and replies.

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

Inclusive upper UTC bound for search comments and replies.

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

Keep posts with a flair.

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

Allow records flagged as adult content by the source.

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

Maximum saved posts per search phrase or direct target.

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

Maximum comments per search phrase or user URL.

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

Add individual comment rows for each saved post.

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

Maximum comments for each collected thread.

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

Maximum communities from each keyword search.

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

Provide post, comment, subreddit, user, or Reddit search URLs.

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

Enter subreddit names or home URLs to collect newest posts.

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

Add sentiment, intent, emotion, product entities, and relevance.

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

Seeking a product, service, recommendation, or someone to solve a problem.

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

The writer says or clearly shows that they own or operate a business.

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

The writer promotes or recruits users for a product or service of their own.

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

Describes a concrete problem, frustration, failed tool, or unmet need.

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

Mentions a price, subscription, fee, or spending.

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

Requests or wishes for a missing capability.

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

States a budget, requests a quote, or expresses willingness to pay.

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

Summarize the specific problem in at most 15 words. Use null if absent.

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

Name the competing product mentioned. Use null if absent.

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

Add up to five label names and plain-language classification instructions.

## `aiModel` (type: `string`):

Optional model identifier. Use a model that supports structured JSON output.

## `openRouterApiKey` (type: `string`):

Optional key. Apify runs can use the Apify OpenRouter integration.

## `scrapeAtlasApiKey` (type: `string`):

Enables Reddit-wide post and comment search. Scoped searches and direct URLs can use Arctic Shift without a key.

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

Select an authorized Slack, Notion, or compatible delivery connector.

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

A channel ID, Notion page ID, or another identifier expected by the tool.

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

Send one message per post or one digest.

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

Ignore, bundle the highest-scoring replies, or send them separately in per-post mode.

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

Maximum highest scoring replies to include per post.

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

Maximum distinct posts included in delivery.

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

Use {{field}} placeholders, including nested fields and array indexes.

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

Exact MCP tool name. Leave empty for compatible messaging and page creation tools.

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

Optional overrides. String values can use the same placeholders as the message template.

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

Optional HTTPS Streamable HTTP MCP endpoint for development or custom connectors.

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

Optional bearer token for the configured direct MCP server.

## Actor input object example

```json
{
  "searchTerms": [
    "python"
  ],
  "withinCommunity": "learnpython",
  "searchPosts": true,
  "searchComments": true,
  "searchCommunities": false,
  "searchSort": "new",
  "searchTime": "all",
  "postedAfter": "7 days",
  "commentedAfter": "7 days",
  "onlyWithFlair": false,
  "includeNSFW": false,
  "maxPostsCount": 3,
  "maxCommentsCount": 3,
  "crawlCommentsPerPost": false,
  "maxCommentsPerPost": 200,
  "maxCommunitiesCount": 2,
  "startUrls": [],
  "subredditUrls": [],
  "aiAnalysis": false,
  "wantsHelp": false,
  "isOwner": false,
  "isVendor": false,
  "hasPain": false,
  "mentionsPrice": false,
  "featureRequest": false,
  "willingToPay": false,
  "painPoint": false,
  "competitor": false,
  "customLabels": {},
  "mcpMode": "perPost",
  "mcpComments": "ignore",
  "mcpCommentsPerPost": 5,
  "mcpMaxItems": 50,
  "mcpMessage": "{{title}}\n{{postUrl}}",
  "mcpArguments": {}
}
```

# Actor output Schema

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

Structured Reddit records with content, links, timestamps, and retrieval source.

## `leads` (type: `string`):

Dataset view with buying-intent labels, sentiment, and analysis status when AI analysis is enabled.

## `summary` (type: `string`):

Row counts, warnings, coverage failures, and optional AI or delivery status.

# 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": [
        "python"
    ],
    "withinCommunity": "learnpython",
    "searchComments": true,
    "postedAfter": "7 days",
    "commentedAfter": "7 days",
    "maxPostsCount": 3,
    "maxCommentsCount": 3,
    "crawlCommentsPerPost": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("whoareyouanas/reddit-lead-finder").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": ["python"],
    "withinCommunity": "learnpython",
    "searchComments": True,
    "postedAfter": "7 days",
    "commentedAfter": "7 days",
    "maxPostsCount": 3,
    "maxCommentsCount": 3,
    "crawlCommentsPerPost": False,
}

# Run the Actor and wait for it to finish
run = client.actor("whoareyouanas/reddit-lead-finder").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": [
    "python"
  ],
  "withinCommunity": "learnpython",
  "searchComments": true,
  "postedAfter": "7 days",
  "commentedAfter": "7 days",
  "maxPostsCount": 3,
  "maxCommentsCount": 3,
  "crawlCommentsPerPost": false
}' |
apify call whoareyouanas/reddit-lead-finder --silent --output-dataset

```

## MCP server setup

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

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/KfmysnzsrLNRFZ7YY/builds/9xVifQFKVn2WzV3Io/openapi.json
