# Reddit Lead Miner — buying-intent post finder (`axiomworks/reddit-lead-miner`) Actor

Find buying-intent Reddit posts automatically. Point it at subreddits + keywords, get a ranked lead list scored 0-100 with ethical reply angles. No API keys, no login. $2 per 1,000 posts scanned.

- **URL**: https://apify.com/axiomworks/reddit-lead-miner.md
- **Developed by:** [Kyle Adkins](https://apify.com/axiomworks) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 post scanneds

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/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 Lead Miner — buying-intent post finder

Feed it subreddits + keywords and get back a **scored, ranked lead list** of
buying-intent posts: who asked, what they want, how hot the intent is (0–100),
and a suggested ethical reply angle. Built for agencies, SaaS founders, and
freelancers who currently hunt this by hand.

### How it works

1. Fetches Reddit's **public RSS feeds** (`/r/{sub}/new/.rss`, plus `hot`/`rising`
   if enabled) for each subreddit — 25 newest posts per feed.
2. Keyword-matches locally against post titles + bodies (your keywords plus an
   optional built-in list of buying-intent phrases: "looking for", "recommend",
   "alternative to", "worth it", …).
3. Scores each match 0–100:
   - **Keyword strength (45)** — exact phrase in title scores highest; multiple
     distinct keywords stack.
   - **Recency (30)** — fresher intent is more actionable; decays over 72h.
   - **Question signal (15)** — posts phrased as questions score higher.
   - **Author heuristic (10)** — weak prior only (throwaway-pattern names score
     lower, `[deleted]` scores 0). No karma data is available via RSS.
4. Pushes leads to the dataset, highest score first, tagged `hot` (≥70),
   `warm` (40–69), or `cold` (<40), each with a suggested reply angle.

### Sample input

```json
{
  "subreddits": ["SaaS", "smallbusiness"],
  "keywords": ["CRM", "email marketing"],
  "useBuiltInIntentPhrases": true,
  "feeds": ["new"],
  "maxResults": 100,
  "minScore": 40,
  "requestDelayMs": 2000
}
```

### Sample output (dataset item)

```json
{
  "post_url": "https://www.reddit.com/r/smallbusiness/comments/1wq2j2i/looking_for_b2b_suppliers_wholesalers/",
  "subreddit": "smallbusiness",
  "title": "Looking for B2B suppliers / wholesalers – Office Supplies",
  "snippet": "…",
  "author": "someuser",
  "published_at": "2026-09-26T03:12:00+00:00",
  "matched_keywords": ["looking for", "suggestions"],
  "matched_in": ["title", "body"],
  "intent_score": 73,
  "intent_tier": "hot",
  "score_breakdown": {"keyword_strength": 45, "recency": 21, "question_signal": 0, "author_heuristic": 7, "total": 73},
  "suggested_reply_angle": "Answer their criteria directly and specifically. Mention your product only if it genuinely fits…",
  "scraped_at": "2026-09-26T04:59:00+00:00"
}
```

### Honest caveats

- **No engagement data.** RSS feeds don't carry upvote scores or comment counts,
  so "engagement velocity" can't be scored. Recency is the proxy for actionability.
- **Newest posts only.** Each feed surfaces ~25 posts. This is a *fresh-intent
  radar*, not a historical search engine. Run it on a schedule for coverage.
- **Reddit's posture.** Reddit has locked down its unauthenticated JSON API
  (login required as of Sept 2026). This actor uses only the public RSS feeds
  Reddit publishes for syndication, with polite delays and backoff. Reddit can
  change or block those feeds at any time; if that happens the actor degrades
  loudly (per-feed failure notes in `run-stats`) rather than silently.
- **This tool finds leads; it doesn't contact anyone.** It never posts, comments,
  DMs, or votes. Outreach is the buyer's job — read each subreddit's self-promo
  rules first. Spam gets accounts banned; the reply angles are written
  helpful-first for a reason.
- **ToS.** Automated collection, even of public feeds, lives in a gray zone.
  Use at your own judgment; prefer Apify Proxy if you run it at high frequency.

### Pricing suggestion

Usage-based rental on the Apify store: **~$2 per 1,000 posts scanned**
(≈ $0.05–0.10 per finished lead list run at typical volumes). That undercuts the
$49/mo SaaS alternatives (Prems AI) for anyone running fewer than ~25k
posts/mo of scanning, while staying well above compute cost.

### Local dev

```bash
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
mkdir -p storage/key_value_stores/default
## put INPUT.json in storage/key_value_stores/default/
APIFY_LOCAL_STORAGE_DIR=./storage .venv/bin/python -m src.main
```

### Deploy (not yet done)

SOURCE\_FILES pattern per the apify skill: PUT version with `sourceFiles`,
then `POST /v2/acts/{actorId}/builds?version=X.Y`. Version cap is 10 — prune
old versions first. Store publication is a separate tap.

# Actor input Schema

## `feeds` (type: `array`):

Which Reddit listing feeds to scan per subreddit. 'new' catches fresh intent fastest.

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

Your product/category terms (e.g. 'CRM', 'email marketing tool'). Matched against post titles and bodies. Optional if built-in intent phrases are enabled.

## `maxResults` (type: `integer`):

Cap on leads returned per run (highest scores first).

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

Only return leads scoring at least this (0-100).

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

Optional. Direct connections work for Reddit RSS; enable Apify Proxy only if you see blocks.

## `requestDelayMs` (type: `integer`):

Politeness delay between feed fetches. Reddit rate-limits aggressively; 2000ms is conservative and recommended.

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

Subreddit names to mine, without the r/ prefix (e.g. SaaS, smallbusiness, webdev). Max 20 per run.

## `useBuiltInIntentPhrases` (type: `boolean`):

Also match generic buying signals ('looking for', 'recommend', 'alternative to', 'worth it', ...). Recommended ON.

## Actor input object example

```json
{
  "feeds": [
    "new"
  ],
  "keywords": [],
  "maxResults": 100,
  "minScore": 0,
  "requestDelayMs": 2000,
  "subreddits": [
    "SaaS",
    "smallbusiness"
  ],
  "useBuiltInIntentPhrases": true
}
```

# Actor output Schema

## `run-stats` (type: `string`):

posts\_scanned, posts\_matched, feeds\_ok, feeds\_failed, failures.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/reddit-lead-miner").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/reddit-lead-miner").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 '{}' |
apify call axiomworks/reddit-lead-miner --silent --output-dataset

```

## MCP server setup

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

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/RQE78tqbJN3jpQQLD/builds/jRurgxm13gy2psTGO/openapi.json