# Reddit Lead Finder: Find Buying Intent Leads (`labrat011/reddit-lead-finder`) Actor

Find Reddit posts with buying intent: people asking for a tool like yours, unhappy with a competitor, or ready to switch. Delivered scored, ranked, and with a suggested reply on each. No API key, no login.

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

## Pricing

from $20.00 / 1,000 qualified 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

<p align="center">
  <img src=".actor/logo.png" alt="Reddit Lead Finder" width="420">
</p>

## Reddit Lead Finder: Find Buying Intent & Competitor Complaints

Turn Reddit into a lead list. Reddit Lead Finder scans public Reddit for people **asking for a tool like yours, complaining about a competitor, or looking to switch**, then hands you the few posts that matter, scored, ranked, and with a suggested reply on each. No API keys, no login, no manual thread-reading.

Built for founders and marketers who want customers, not a 1,000-row data dump.

### Why this over a raw Reddit scraper?

A raw scraper returns 1,000 posts and leaves you to read them. This finds the 12 that are actually leads.

| | Raw Reddit scraper | 🎯 Reddit Lead Finder |
|---|---|---|
| Output | Every post that matched | Only scored buying-intent leads |
| Reading required | You read 1,000 rows | You read the ranked shortlist |
| Per lead | Intent? Unknown | Intent type + score + why |
| Off-topic keyword matches | Yours to spot | Dropped by a semantic gate (no API key) |
| Founders promoting their own product | Looks like a lead | Scored down as self-promo, not a buyer |
| Next step | Figure it out | Suggested reply on every lead |
| You pay for | Every row | Only qualified leads |

#### Buyers, not sellers

The trap in Reddit lead-gen is that *"I built a time tracker, check it out"* matches the same keywords as *"anyone recommend a time tracker?"* — one is a competitor, the other is a customer. Keyword tools can't tell them apart, so they hand you founders as leads.

This actor scores self-promotion down explicitly: "I made", "I built", "\[OS]", "my app", "looking for beta testers", "side project", plus roundup and content-marketing titles ("Best X 2026", "The 3 Tools That Helped Me", "I tested 5 apps", "\<Product> review"). The penalty is sized so a launch post or listicle can't reach a normal threshold even when it carries the same keyword, question, and first-person signals a real buyer does — which is exactly how these slip past keyword-only tools.

It stays a score penalty rather than a silent drop, so the reason shows up in `scoreReasons` and you can lower `minIntentScore` to audit what was held back.

### 👥 Who uses this

#### 🚀 Bootstrapped SaaS founders

You want customers from Reddit without spamming. Point it at your category and competitors, get back threads where someone is actively asking for what you sell.

```json
{
    "productDescription": "A lightweight time-tracking app for freelancers.",
    "keywords": ["time tracking app", "track freelance hours", "toggl alternative"],
    "competitors": ["Toggl", "Harvest", "Clockify"],
    "intentTypes": ["seeking_recommendation", "competitor_complaint", "switching_intent"],
    "timeFilter": "month",
    "maxLeads": 50
}
```

#### 📣 Growth marketers & agencies

Run social-selling and competitor-conquesting campaigns. Filter to `competitor_complaint` + `switching_intent` to catch people mid-churn from a rival.

```json
{
    "productDescription": "A CRM built for small real-estate teams.",
    "keywords": ["real estate CRM", "CRM for realtors"],
    "competitors": ["Follow Up Boss", "kvCORE"],
    "intentTypes": ["competitor_complaint", "switching_intent"],
    "minIntentScore": 65
}
```

#### 🔎 Market researchers

Surface unmet needs and feature requests in your space with `feature_request` + `problem_unaware`, scored so you can rank pain by frequency.

### 🧠 How it works

1. **Scans Reddit** for your keywords and competitor names (public data, residential proxies, no login).
2. **Scores every post** through a three-tier pipeline (details below).
3. **Delivers only qualified leads**, each with an intent type, a 0 to 100 score, the reasons it scored, and a suggested reply.

#### Three-tier scoring (precision without a key)

| Tier | What it does | Cost |
|------|--------------|------|
| **1. Lexicon** | Fast keyword and intent-cue match. Kills obvious noise. | Free, on by default |
| **2. Semantic gate** | Local embeddings check that a post is actually about your product, not just sharing a word. Drops "time tracking" in r/Porsche (track days) even though the phrase matches. | Free, on by default, no key |
| **3. LLM (optional)** | Set `scoringMode: llm` with your own API key for the sharpest read on ambiguous posts. Falls back to lexicon on any error. | Your key, only runs on posts that pass tiers 1 and 2 |

Tiers 1 and 2 need no API key and run on every post, so you get semantic precision out of the box. The LLM tier is an optional top layer, and because it only sees posts that already passed the cheaper tiers, it stays cheap.

### 📤 Sample output

Each dataset item is one qualified lead. This is a real lead from a live run, not a mockup:

```json
{
    "leadId": "t3_1v8scw0",
    "type": "post",
    "intentType": "seeking_recommendation",
    "intentScore": 67,
    "scoreReasons": [
        "matched intent cue: 'looking for'",
        "mentions your keyword(s): time tracking app",
        "phrased as a question"
    ],
    "matchedKeywords": ["time tracking app"],
    "title": "FREE PLAN vs. FREE TRIAL in time tracking software: What's their difference? Here are some pros and cons.",
    "snippet": "\"Free\" is hard to resist, especially when you're looking for time tracking software for a growing team. But here's the catch: how many of the tools that show up when you search \"free time tracking app\" are actually free to keep using?...",
    "url": "https://www.reddit.com/r/TimeTrackingSoftware/comments/1v8scw0/",
    "subreddit": "TimeTrackingSoftware",
    "author": "nazoraya",
    "score": 3,
    "numComments": 3,
    "createdAt": "2026-07-28T08:39:36+00:00",
    "ageHours": 39.5,
    "suggestedAction": "Reply recommending your product. They are actively asking, so a direct, helpful answer fits.",
    "sentiment": "negative",
    "isAnswered": false
}
```

No free text to parse. Every field is typed and structured on arrival — an AI agent (or a human) can act on `suggestedAction` the moment the lead lands, with no summarization step in between.

### 🏷️ Intent types

| Intent | Catches | Example |
|--------|---------|---------|
| `seeking_recommendation` | People directly asking for a tool | "Any recommendations for a time tracker?" |
| `competitor_complaint` | People unhappy with a rival | "Toggl is too expensive now" |
| `switching_intent` | People actively leaving a tool | "Moving off Harvest, need a replacement" |
| `feature_request` | People describing a missing capability | "Wish there was a tool that could..." |
| `problem_unaware` | People with the problem, no solution named | "Spending hours reconciling invoices by hand" |

### 💸 Pricing (plain and honest)

Two line items. That is the whole bill.

- **$0.06 per search run**: charged once, only when the run delivers at least one qualified lead.
- **$0.02 per qualified lead**: charged only for leads delivered to your dataset.

**You are never charged when we deliver nothing.** Blocked run, zero matches, or zero leads above your threshold = **$0.00**. Set `ACTOR_MAX_TOTAL_CHARGE_USD` to hard-cap any run. Full detail: [docs/PRICING.md](docs/PRICING.md).

Example: 12 leads = `$0.06 + 12 × $0.02 = $0.30`.

### 📥 Bulk input

Driving from a spreadsheet or a prior run? Skip the keyword box:

- `keywordsDatasetId`: an Apify dataset of keyword strings or `{ "keyword": "..." }` objects.
- `keywordsFileUrl`: a public `.csv` (column `keyword`) or newline-delimited `.txt`.

All sources merge with the inline list and de-duplicate automatically.

### ⚙️ Input reference

| Field | Type | Default | Notes |
|-------|------|---------|-------|
| `productDescription` | string | - | **Required.** What you sell. Powers intent matching. |
| `keywords` | array | - | Category terms + competitor names. Optional if using bulk input. |
| `competitors` | array | `[]` | Names that boost complaint/switching scores. |
| `subreddits` | array | `[]` | Empty = all of Reddit. One value restricts search. |
| `intentTypes` | array | 3 core types | Which signals to surface. |
| `minIntentScore` | int | `55` | Below this: not returned, not charged. |
| `timeFilter` | enum | `month` | day / week / month / year / all. |
| `maxLeads` | int | `50` | Cap on delivered leads (1-500). |
| `scoringMode` | enum | `lexicon` | `lexicon` (free: tiers 1+2) or `llm` (adds tier 3, your key). |
| `openaiApiKey` | secret | - | Only for `scoringMode: llm`. Never stored. |
| `keywordsDatasetId` / `keywordsFileUrl` | string | - | Bulk keyword sources. |
| `proxyConfiguration` | object | Residential | Reddit blocks datacenter IPs. |

### 🤖 Using this from an AI agent

Like every actor on Apify, this one is callable over **MCP** (Claude, ChatGPT, Cursor, via the Apify MCP server) and payable via **x402** — an agent can run and pay for it in USDC on Base with no Apify account and no API key. Those are platform capabilities, so a raw Reddit scraper has them too.

The part that matters for an agent is **what comes back**. Point an agent at a raw scraper and it gets 1,000 posts it still has to read, classify, and summarize — every one of those tokens is yours. Point it here and each item is already a decision:

```python
for lead in dataset:                      # already filtered to qualified leads
    if lead["intentScore"] >= 75 and lead["intentType"] == "switching_intent":
        draft_reply(lead["url"], brief=lead["suggestedAction"])
```

`intentType` is a typed enum, `intentScore` is 0-100, `scoreReasons` explains the call, and `suggestedAction` is the reply brief. No summarization step, no LLM pass to figure out which rows matter, no prompt engineering to classify intent — that work already happened server-side, in the price of the lead.

### 🔌 Integrations

Output is a standard Apify dataset: export to **JSON, CSV, Excel**, pipe into **n8n, Zapier, Make**, or wire into your own stack via the Apify API. Schedule daily runs to catch leads while they are still fresh.

### ❓ FAQ

**Do I need a Reddit account or API key?** No. Public data only.

**Why residential proxies?** Reddit hard-blocks datacenter IPs. Residential is required for reliable results and is included in the price above.

**Is this against Reddit's terms?** It reads only public pages, takes no in-Reddit actions (no posting, voting, or DMing), and paces requests politely. Use the leads to engage authentically, not to spam.

**How accurate are the leads?** Default scoring runs two tiers with no key: a lexicon filter plus a local semantic gate that checks a post is genuinely about your product, not just sharing a keyword. This catches most false positives (like "time tracking" in a car forum). For the sharpest read on ambiguous posts, set `scoringMode: llm` with your own key to add a third LLM tier, which only runs on posts that already passed the first two.

**Can an AI agent run and pay for this by itself?** Yes. It supports x402, so an agent can pay per run in USDC on Base with no Apify account or API key. It is also exposed as an MCP tool for Claude, ChatGPT, and Cursor.

**What if a run finds nothing?** You pay nothing. No leads, no charge.

***

Made by mick\_. Companion to [Reddit Scraper](https://apify.com/labrat011/reddit-scraper), use that for raw data at scale, this for ready-to-act leads.

# Actor input Schema

## `productDescription` (type: `string`):

Used to match buying intent. Example: 'A lightweight time-tracking app for freelance designers.'

## `keywords` (type: `array`):

Search terms to seed discovery. Include your product category plus competitor names. Optional if you supply a keywords dataset or file below.

## `keywordsDatasetId` (type: `string`):

Dataset whose items are keyword strings or objects with a 'keyword' field. Merged with the list above.

## `keywordsFileUrl` (type: `string`):

Public link to a .csv (column 'keyword') or newline-delimited .txt. Merged with the list above.

## `competitors` (type: `array`):

Posts mentioning these plus complaint or switching language score higher.

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

Leave empty to search all of Reddit.

## `intentTypes` (type: `array`):

Which kinds of buying signal to return.

## `minIntentScore` (type: `integer`):

Leads below this score are not returned and never charged.

## `timeFilter` (type: `string`):

How far back to search. Fresher leads are easier to act on.

## `maxLeads` (type: `integer`):

Stop after this many qualified leads are delivered (1-500).

## `scoringMode` (type: `string`):

lexicon is deterministic and needs no API key. llm is sharper but needs your own LLM API key.

## `openaiApiKey` (type: `string`):

Your own key. Used only for scoring. Never stored.

## `proxyConfiguration` (type: `object`):

Passed through to the underlying Reddit scraper. Residential recommended.

## Actor input object example

```json
{
  "productDescription": "A lightweight time-tracking app for freelancers.",
  "keywords": [
    "time tracking app",
    "toggl alternative",
    "track freelance hours"
  ],
  "intentTypes": [
    "seeking_recommendation",
    "competitor_complaint",
    "switching_intent"
  ],
  "minIntentScore": 55,
  "timeFilter": "month",
  "maxLeads": 50,
  "scoringMode": "lexicon",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing all qualified leads

# 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 = {
    "productDescription": "A lightweight time-tracking app for freelancers.",
    "keywords": [
        "time tracking app",
        "toggl alternative",
        "track freelance hours"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("labrat011/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 = {
    "productDescription": "A lightweight time-tracking app for freelancers.",
    "keywords": [
        "time tracking app",
        "toggl alternative",
        "track freelance hours",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("labrat011/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 '{
  "productDescription": "A lightweight time-tracking app for freelancers.",
  "keywords": [
    "time tracking app",
    "toggl alternative",
    "track freelance hours"
  ]
}' |
apify call labrat011/reddit-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OtrJWZ45t35TzaE9f/builds/e5KuVXyxR1WPxNUKq/openapi.json