# Reddit Lead Finder — Buying Intent Leads (`apt_marble/reddit-lead-finder`) Actor

Find the Reddit threads where people are openly asking for what you sell — "looking for", "any recommendations", "alternative to". Every lead is scored 0-100 for buying intent, freshness and engagement, with the quote, thread link and the author's profile. A ranked warm-lead list, not a firehose.

- **URL**: https://apify.com/apt\_marble/reddit-lead-finder.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Lead Finder

Every day people go on Reddit and ask, in public, for exactly what you sell — "looking for a project management tool", "any recommendations for a CRM under $50?", "what do you all use for time tracking?". This actor hunts those threads down for you. Give it the words your buyers use, and it searches Reddit's posts and comments, scores every hit from 0 to 100 for buying intent, freshness and engagement, and hands you a ranked list with the exact sentence they wrote, a link to the thread and a link to the author's profile. It is a warm-lead list you can work through in an afternoon, not a firehose of mentions.

### What you can do with it

- **Find people shopping for your category right now** — combine `project management tool` with ten buying-intent phrases and get back only the threads where somebody is actually asking, not just talking.
- **Steal your competitor's unhappy customers** — search `alternative to <competitor>` and reach the people already looking for the door.
- **Feed a weekly outreach list** — schedule it, take the top 20 leads by score, reply where you can genuinely help.
- **Watch the communities that matter** — restrict the hunt to the handful of subreddits your buyers live in, and blacklist the ones that only produce noise.
- **Validate a new product or feature** — read the top-scoring threads for a keyword to see how people describe the problem in their own words.
- **Brief your sales or community team** — each lead ships with the quote, the subreddit, the upvotes and the age, so anyone can pick it up and act.

### What you get

One record per lead, best score first:

```json
{
  "leadScore": 90,
  "intentScore": 50,
  "recencyScore": 29.4,
  "engagementScore": 10.3,
  "matchedKeyword": "project management tool",
  "matchedIntent": "looking for",
  "matchedIntents": ["looking for"],
  "snippet": "…If customers are asking AI before looking for something online, then AI visibility becomes another channel of growth for your product…",
  "foundVia": "intent-phrase",
  "searchQuery": "\"project management tool\" \"looking for\"",
  "type": "post",
  "id": "1v8qmwd",
  "title": "I decided to test whether AI recommends SaaS products. The results have been… weird.",
  "url": "https://www.reddit.com/r/microsaas/comments/1v8qmwd/i_decided_to_test_whether_ai_recommends_saas/",
  "subreddit": "microsaas",
  "author": "Classic_Turnover_896",
  "authorProfileUrl": "https://www.reddit.com/user/Classic_Turnover_896/",
  "score": 15,
  "numComments": 23,
  "upvoteRatio": 1,
  "createdAt": "2026-07-28T07:01:45.000Z",
  "ageHours": 13.6,
  "isSelfPost": true,
  "over18": false
}
```

Comment leads carry the same shape, with `type: "comment"`, the parent thread in `title` / `postId` / `postUrl`, and a link straight to the comment in `url`.

#### Where comment leads come from

Reddit's own search covers posts, not replies. So when **Search comments too** is on, comment leads are drawn out of the strongest threads each keyword surfaced — and a reply earns a row only when the person writing it is themselves asking for something, not merely talking in a thread that matched. Those rows are marked `foundVia: "thread-comment"`. At most 20 threads per keyword and 100 per run are mined this way, so the extra reach is bounded and predictable.

### How the score works

`leadScore` is a plain sum of three capped parts, so you can always explain a ranking:

| Part | Out of | What it measures |
| --- | --- | --- |
| `intentScore` | 50 | How strong the matched buying phrase is, plus small bonuses when a second phrase matches, when the match is in the title, and when the text asks a question. |
| `recencyScore` | 30 | How fresh the thread is, decaying evenly across the time window you chose. A brand-new post gets the full 30; one at the edge of the window gets 0. |
| `engagementScore` | 20 | Upvotes (60%) and comment count (40%), both log-scaled, so 1,000 upvotes maxes out the upvote part and 100 comments maxes out the comment part. |

No AI, no black box, no extra cost — just arithmetic you can audit in the output, since all three parts are stored on every record.

### Input reference

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `productKeywords` | array of strings | `["project management tool"]` | **Required.** What you sell, in your buyers' words. Each keyword is searched alone and paired with every intent phrase. Up to 20 per run. |
| `intentPhrases` | array of strings | 10 shipped phrases | Phrases that signal somebody is asking for a recommendation: `looking for`, `any recommendations`, `recommend a`, `alternative to`, `anyone using`, `best tool for`, `worth it`, `help me choose`, `suggestions for`, `what do you use`. Pass your own list to override (up to 15), or an empty list to run bare keyword searches only. |
| `subreddits` | array of strings | `[]` (all of Reddit) | Limit the hunt to specific communities. `SaaS`, `r/SaaS` and a full subreddit URL all work. Up to 20 per run. |
| `excludeSubreddits` | array of strings | `[]` | Communities to drop from the results — job boards, meme subs, your own support community. Up to 50. |
| `searchComments` | boolean | `true` | Also pull leads out of the replies inside the best threads found. Many of the strongest leads are a comment inside somebody else's thread. |
| `time` | select | `month` | How far back to search: `hour`, `day`, `week`, `month`, `year`, `all`. Also sets the horizon the recency score decays over. |
| `maxLeadsPerKeyword` | integer | `50` | Highest-scoring leads to keep per keyword (1–1000). Everything below the cut is discarded before it reaches your dataset. |
| `minScore` | integer | `1` | Drop posts and comments below this upvote count. |
| `excludeKeywords` | array of strings | `[]` | Drop any lead whose text contains one of these words — very effective against `hiring`, `giveaway` or a competitor's name. Up to 50. |
| `maxConcurrency` | integer | `8` | Searches to run at the same time (1–20). Higher is faster. |
| `country` | select | `us` | Which country's view of Reddit your results should reflect. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `leadScore` | number | 0–100 overall lead quality. The dataset is sorted by this, highest first. |
| `intentScore` / `recencyScore` / `engagementScore` | number | The three parts of the score, so you can re-rank however you like. |
| `matchedKeyword` | string | The product keyword this lead was found for. |
| `matchedIntent` | string | null | The strongest buying-intent phrase actually found in the text. `null` when Reddit matched the thread but the phrase is not present verbatim. |
| `matchedIntents` | array | Every intent phrase found in the text, in the order they appear. |
| `snippet` | string | Roughly 150 characters either side of the match — the sentence you reply to. |
| `foundVia` | string | `intent-phrase` when a phrase query surfaced it, `keyword` when the bare keyword search did, `thread-comment` when it came out of a thread's replies. |
| `searchQuery` | string | The query that produced this lead — for a `thread-comment` row, the query that surfaced the thread it sits in. |
| `type` | string | `post` or `comment`. |
| `id` / `fullId` | string | Reddit's identifiers. Use `id` to de-duplicate across scheduled runs. |
| `title` | string | The post title, or for a comment the title of the thread it sits in. |
| `body` | string | null | Full text of the post or comment. |
| `url` | string | Direct link to the post or comment. |
| `permalink` | string | Reddit-relative path to the same place. |
| `subreddit` / `subredditSubscribers` | string / number | Where it was posted, and how big that community is. |
| `author` / `authorProfileUrl` | string | Who wrote it, and a link to their profile. |
| `score` / `upvoteRatio` | number | Upvotes and the share of votes that were upvotes. |
| `numComments` | number | Comments on the post (posts only). |
| `createdAt` / `ageHours` | date / number | When it was posted, and how old it was when the run happened. |
| `flair` / `authorFlair` | string | null | Post and author flair. |
| `linkUrl` / `domain` | string | null | For link posts, where it points. |
| `over18` / `locked` / `archived` / `stickied` | boolean | Thread state — `locked` and `archived` threads can no longer be replied to. |
| `postId` / `postUrl` / `isTopLevel` | string / boolean | For comment leads, the thread they belong to and whether the comment is a direct reply to the post. |

A `SUMMARY` record is also written to the run's key-value store with the keyword list, how many searches ran, how many candidates were considered, the top and average lead score, and the elapsed time.

### Pricing

This actor is **pay per event**, and there is exactly one event: the standard dataset item, `apify-default-dataset-item`, priced at **$0.0025 per lead — $2.50 per 1,000 leads**. There are no custom events and no surcharges. You are charged once for every lead that lands in your dataset, and nothing else — no charge per search, no charge per keyword, no monthly fee beyond your Apify plan.

Candidates that fail your filters (too few upvotes, an excluded subreddit or keyword, a deleted author, removed content) and everything below your `maxLeadsPerKeyword` cut are dropped before they are pushed, so you never pay for them. That makes the cost of a run easy to predict: at most `maxLeadsPerKeyword × number of keywords` items, usually fewer once duplicates across keywords are merged. Three keywords at the default 50 leads each works out at roughly $0.38 a run.

### Limits and what this actor cannot do

- **Results are a relevance-ranked sample, not an exhaustive archive.** Reddit itself limits any single feed to roughly 1,000 posts, and its search stops well short of that: expect a relevance-ranked selection of a few hundred results per query, with the best-matching threads first. "Every post that ever mentioned my product" is not achievable through Reddit search, by this actor or any other.
- **Searching more widely widens the net, but the results overlap.** Each keyword × intent phrase × subreddit combination is searched separately, so more phrases and more subreddits do reach further — measured at roughly 1.8× the hits of a single query across four combinations, not 4×, because the same strong threads come back in several of them. Duplicates are merged before you are charged.
- **A run performs at most 400 searches.** Very large combinations (many keywords × many phrases × many subreddits) are trimmed, keyword by keyword in turn, so every keyword still gets covered. The run log tells you when that happened.
- **Long input lists are trimmed too.** A single run uses at most 20 product keywords, 15 intent phrases, 20 named subreddits and 50 entries in each exclusion list; anything beyond that is ignored without failing the run. Split a bigger list across several runs.
- **Reddit has no comment search.** Asking it for comments gives back the same posts a post search would. That is why comment leads are drawn out of the threads themselves instead: only the threads your searches surfaced can contribute comments, up to 20 threads per keyword and 100 per run — and within each of those threads only the top few hundred replies are read, so a lead buried deep in a very long discussion can be missed.
- **Reddit decides what "matches".** Its search stems and loosens queries, so a thread can come back without containing your intent phrase word for word. Those leads keep a `null` `matchedIntent` and score on recency and engagement alone — usually landing well down the list.
- **Intent phrases are matched literally, on whole words.** "looking for" will not match "looking forward", which keeps false leads out — but it also means a phrase only counts when somebody wrote it the way you spelled it.
- **Private and banned communities are not readable.** If you name one it is skipped with a warning and the run continues; quarantined communities are expected to behave the same way, though that has not been confirmed. Moderator-only data (mod lists, removal reasons, mod queues) is not available at all.
- **There is no "users online now" figure.** Reddit does not make one available; use `subredditSubscribers` and posting activity to judge how alive a community is.
- **Deleted and removed content is dropped**, as are leads whose author is `[deleted]` or `AutoModerator` — you cannot reply to any of them.
- **Intent scoring is a transparent formula, not AI.** It reads phrases, dates and vote counts. It cannot tell sarcasm from sincerity, and it does not look at images or videos.
- **It finds and ranks leads. It does not contact anybody.** No posting, no commenting, no DMs, no voting. Reaching out is your job — and Reddit communities have their own rules about self-promotion, so read them before you reply.
- **Every run returns everything that matches**, including leads you have already seen. De-duplicate on `id` if you run it on a schedule.

### FAQ

**Do I need a Reddit account?**
No. You do not need a Reddit account, a login, or any credentials — just enter what you want and run it.

**How fast is it?**
Leads come back in large batches, so even big jobs finish quickly. A focused run — one keyword, one phrase, posts only — takes a couple of seconds; a broad run across several keywords, ten intent phrases and comments takes a few minutes, mostly determined by how many searches your settings imply and your `maxConcurrency`.

**Can I run it on a schedule?**
Yes, and it is designed for it — a daily run with `time: "day"` gives you that day's fresh leads. It always returns every current match, so de-duplicate on `id` against what you have already worked.

**Why do some leads score high without an intent phrase?**
Because the score also rewards freshness and engagement. A brand-new, heavily upvoted thread about your keyword can be worth reading even if nobody typed "looking for" — but it will never beat a genuine ask, which starts 50 points ahead.

**How do I get rid of job ads and giveaways?**
Put `hiring`, `[hiring]` or `giveaway` in `excludeKeywords`, and the subreddits they come from in `excludeSubreddits`. Those filters run before anything is pushed, so filtered noise costs you nothing.

**Can I use my own intent phrases?**
Yes. Replace `intentPhrases` with the wording your market actually uses — anything you supply is treated as a strong buying signal, slightly below the built-in phrases that were tuned for this.

# Actor input Schema

## `productKeywords` (type: `array`):

What you sell, in the words your buyers would use. Each keyword is searched on its own and combined with every intent phrase below.

## `intentPhrases` (type: `array`):

Phrases that mean somebody is asking for a recommendation. Each one is paired with each product keyword to build a search. Leave the defaults unless you know the exact wording your market uses.

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

Limit the hunt to specific communities. Names, r/names or full URLs all work. Leave empty to search the whole of Reddit.

## `excludeSubreddits` (type: `array`):

Communities to drop from the results, for example job boards, meme subs or your own support community.

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

Also open the best threads found and pull leads out of their replies. Many of the strongest leads are a comment inside someone else's thread rather than a post of their own. Adds a little time per thread opened.

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

How far back to search. Fresh threads score higher, so a narrow window gives more actionable leads.

## `maxLeadsPerKeyword` (type: `integer`):

Highest-scoring leads to keep for each product keyword. Everything below the cut is discarded, not charged.

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

Drop posts and comments below this upvote count. 1 removes downvoted noise; raise it to keep only threads with an audience.

## `excludeKeywords` (type: `array`):

Throw away any lead whose text contains one of these words — handy for filtering out job posts, giveaways or a competitor's name.

## `maxConcurrency` (type: `integer`):

How many searches to run at the same time. Higher is faster; lower is gentler.

## `country` (type: `string`):

Which country's view of Reddit to use. Reddit content is the same almost everywhere, so the default suits nearly every run.

## Actor input object example

```json
{
  "productKeywords": [
    "project management tool",
    "time tracking app"
  ],
  "intentPhrases": [
    "looking for",
    "any recommendations",
    "recommend a",
    "alternative to",
    "anyone using",
    "best tool for",
    "worth it",
    "help me choose",
    "suggestions for",
    "what do you use"
  ],
  "subreddits": [],
  "excludeSubreddits": [],
  "searchComments": true,
  "time": "month",
  "maxLeadsPerKeyword": 50,
  "minScore": 1,
  "excludeKeywords": [],
  "maxConcurrency": 8,
  "country": "us"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productKeywords": [
        "project management tool",
        "time tracking app"
    ],
    "intentPhrases": [
        "looking for",
        "any recommendations",
        "recommend a",
        "alternative to",
        "anyone using",
        "best tool for",
        "worth it",
        "help me choose",
        "suggestions for",
        "what do you use"
    ],
    "subreddits": [],
    "excludeSubreddits": [],
    "searchComments": true,
    "time": "month",
    "maxLeadsPerKeyword": 50,
    "minScore": 1,
    "excludeKeywords": [],
    "maxConcurrency": 8,
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/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 = {
    "productKeywords": [
        "project management tool",
        "time tracking app",
    ],
    "intentPhrases": [
        "looking for",
        "any recommendations",
        "recommend a",
        "alternative to",
        "anyone using",
        "best tool for",
        "worth it",
        "help me choose",
        "suggestions for",
        "what do you use",
    ],
    "subreddits": [],
    "excludeSubreddits": [],
    "searchComments": True,
    "time": "month",
    "maxLeadsPerKeyword": 50,
    "minScore": 1,
    "excludeKeywords": [],
    "maxConcurrency": 8,
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/reddit-lead-finder").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 '{
  "productKeywords": [
    "project management tool",
    "time tracking app"
  ],
  "intentPhrases": [
    "looking for",
    "any recommendations",
    "recommend a",
    "alternative to",
    "anyone using",
    "best tool for",
    "worth it",
    "help me choose",
    "suggestions for",
    "what do you use"
  ],
  "subreddits": [],
  "excludeSubreddits": [],
  "searchComments": true,
  "time": "month",
  "maxLeadsPerKeyword": 50,
  "minScore": 1,
  "excludeKeywords": [],
  "maxConcurrency": 8,
  "country": "us"
}' |
apify call apt_marble/reddit-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/MndqigckaT2ESHas8/builds/W0Eawyf5pwaCFkt6N/openapi.json