# Reddit Purchase Intent Leads (`night111/reddit-purchase-intent-leads`) Actor

Turn Reddit post or comment records into ranked, evidence-backed Reddit demand signals.

- **URL**: https://apify.com/night111/reddit-purchase-intent-leads.md
- **Developed by:** [ng. night](https://apify.com/night111) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 actionable insights

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 Purchase Intent Leads

> **Extract recent public posts expressing a concrete need, replacement search or buying question.**

Built for **B2B sales and product teams**, this Actor turns current and historical Reddit post or comment records into a ranked, evidence-backed action queue. Bring the records; get the changes, priorities, risks, and source evidence that deserve attention.

### 🚀 What this Actor helps you do

- **Act on the workflow:** Extract recent public posts expressing a concrete need, replacement search or buying question.
- **Review exceptions, not raw feeds:** rank new, changed, removed, or optionally unchanged entities by priority.
- **Explain every result:** keep reasons, exact changed fields, confidence, source provenance, and a SHA-256 evidence digest.
- **Automate the handoff:** send structured results to a dataset, API client, webhook, spreadsheet, BI tool, CRM, or alerting workflow.

This is a **decision layer**, not a hidden scraper. You choose the lawful data source and can reproduce every result by supplying explicit current and previous snapshots.

### ✨ Workflow advantages

- **Intent Taxonomy** — Expose labels, reasons, and evidence that can be mapped into the team’s own operating taxonomy.
- **Spam And Self Promotion Suppression** — Suppress repeated input entities and produce canonical records that are ready for downstream grouping.
- **Explainable Lead Reasons** — Apply this workflow lens to the Actor’s matching, comparison, ranking, and evidence output.

Every run also applies deterministic entity matching, configurable field comparison, duplicate suppression, opportunity/risk term checks, and output limits.

### 🎯 Common use cases

1. **Core workflow** — Extract recent public posts expressing a concrete need, replacement search or buying question.
2. **Scheduled monitoring** — run on a cadence and compare the latest records with the prior snapshot.
3. **Team action queue** — route only high-priority results to B2B sales and product teams.
4. **Evidence export** — retain source records and field-level reasons for QA, reporting, or human review.

### 📥 Input options

For production, connect a customer-selected upstream Actor or dataset that returns the relevant public or authorized records.

| Mode | When to use it |
| --- | --- |
| `inline` | Fast tests, API integrations, or records assembled in your own code |
| `dataset` | Production pipelines that already write current records to Apify |
| `upstream-actor` | Run one explicitly selected upstream Actor and analyze its dataset |
| `official-api` | Read an authorized HTTPS JSON endpoint with secret request headers |

Add `previousRecords` or `previousDatasetId` to detect changes. Exact platform IDs are preferred; fuzzy matching is available when strong identifiers are missing.

**Default identity fields:** `id`, `name`, `permalink`, `url`

**Default comparison fields:** `title`, `body`, `subreddit`, `score`, `upvoteRatio`, `numComments`, `author`, `flair`, `isLocked`

### ⚡ Quick start

Paste this into the Actor input editor and replace the sample records with your own:

```json
{
  "sourceMode": "inline",
  "records": [
    {
      "id": "rd-demo-001",
      "subreddit": "smallbusiness",
      "title": "Looking for an affordable review-monitoring tool",
      "body": "Need a simple alternative to enterprise tools for five locations.",
      "score": 184,
      "upvoteRatio": 0.96,
      "numComments": 73,
      "observedAt": "2026-08-02T10:00:00Z",
      "productWorkflow": "reddit-purchase-intent-leads"
    }
  ],
  "previousRecords": [
    {
      "id": "rd-demo-001",
      "subreddit": "smallbusiness",
      "title": "Review monitoring options?",
      "body": "Comparing tools.",
      "score": 24,
      "upvoteRatio": 0.82,
      "numComments": 9,
      "observedAt": "2026-08-01T10:00:00Z",
      "productWorkflow": "reddit-purchase-intent-leads"
    }
  ],
  "minimumScore": 35,
  "maxEvents": 100,
  "includeNew": true,
  "includeChanged": true,
  "includeRemoved": false
}
```

Then adjust:

- `minimumScore` to control how selective the action queue is.
- `maxEvents` to cap delivered insights.
- `includeNew`, `includeChanged`, `includeRemoved`, and `includeUnchanged` to define which states matter.
- `customIdFields` and `customCompareFields` when your source schema uses different names.

### 📤 Output you can use immediately

Each delivered dataset item includes:

| Field | Meaning |
| --- | --- |
| `eventType` | `new`, `changed`, `removed`, or `unchanged` |
| `entityId` / `entityLabel` | Canonical machine ID and readable entity name |
| `priorityScore` | Deterministic 0–100 review priority |
| `riskScore` | Deterministic 0–100 caution signal |
| `confidence` | Evidence completeness and identity confidence from 0–1 |
| `reasons` | Plain-language reasons behind the ranking |
| `changedFields` | Exact fields that changed from the previous snapshot |
| `current` / `previous` | Sanitized source evidence used for comparison |
| `sourceType` / `sourceId` | Non-secret provenance for the input records |
| `evidenceDigest` | SHA-256 digest of canonical current/previous evidence |

The KVS `OUTPUT` record contains the run summary, counts, duplicate diagnostics, and score range.

### 🔌 API and automation

Run the Actor through the API:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/night111~reddit-purchase-intent-leads/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d @input.json
```

Use the returned `defaultDatasetId` to fetch results. For unattended workflows, combine the Actor with Apify schedules, webhooks, API clients, Make, Zapier, or your own orchestration service.

### 🧠 How decisions are produced

The Actor uses explainable rules over configured identity fields, field deltas, numeric movement, opportunity terms, caution terms, completeness, and identity confidence. It does not present a model-generated verdict as fact. Important actions should be checked against the attached source evidence.

### 🛡️ Responsible use and scope

- **Workflow-specific caution:** Public posts only; no sensitive-person profiling.
- Process only data you are authorized to use and follow source-site terms, privacy rules, retention duties, and applicable outreach laws.
- Product and platform names belong to their respective owners. This independent Actor is not endorsed by those platforms.
- Secret API headers are encrypted by Apify, omitted from outputs, and credential-like evidence fields are stripped.
- Do not place tokens in dataset or API URLs; common credential patterns are rejected.

### ⚠️ Limitations

- Output quality depends on the completeness, freshness, legality, and schema consistency of your input records.
- Fuzzy entity resolution is best-effort; stable source IDs produce better comparisons.
- State is explicit rather than hidden: provide a previous snapshot for reproducible change detection.
- Authorized API mode reads JSON responses; it is not an arbitrary HTML browser.
- Upstream Actors and external APIs may have separate availability, permissions, or usage constraints.

### ❓ FAQ

#### Does this Actor collect the source data itself?

Not silently. It analyzes records you provide inline, through datasets, via one explicitly selected upstream Actor, or from an authorized HTTPS JSON API.

#### Can I run it on a schedule?

Yes. Save each run’s current records as the next run’s previous snapshot, then use an Apify schedule or your orchestrator.

#### Can I use my own field names?

Yes. Set `customIdFields` and `customCompareFields` to align the workflow with your schema.

#### How do I keep a run bounded?

Use `minimumScore` and `maxEvents`. The Actor stops delivering new events once the configured output limit is reached.

### 💬 Support

Open the Actor **Issues** tab with a sanitized input example, run ID, expected entity key, and observed behavior. Never post credentials or private source data.

# Actor input Schema

## `sourceMode` (type: `string`):

Choose exactly one source. Inline is ideal for testing and integrations; dataset is safest for production pipelines.

## `records` (type: `array`):

Raw current records. Typical identity fields: id, name, permalink, url.

## `datasetId` (type: `string`):

Dataset ID or name containing current records. Tokens in URLs are rejected.

## `upstreamActorId` (type: `string`):

Optional Actor ID/name to call. The caller pays upstream costs; use only an Actor you trust and are authorized to run.

## `upstreamActorInput` (type: `object`):

JSON passed to the selected upstream Actor. Never paste credentials unless its schema marks them secret.

## `officialApiUrl` (type: `string`):

Optional first-party or licensed JSON endpoint. HTTPS only. Query-string tokens are rejected; use secret headers.

## `officialApiHeaders` (type: `object`):

Optional request headers such as Authorization. Stored encrypted by Apify.

## `officialApiItemsPath` (type: `string`):

Dot path to the result array, for example data.items. Leave blank when the response itself is an array.

## `previousRecords` (type: `array`):

Optional prior snapshot used for state comparison. Omit for a first-seen baseline.

## `previousDatasetId` (type: `string`):

Optional dataset ID/name containing the previous snapshot.

## `minimumScore` (type: `integer`):

Only deliver actionable records at or above this deterministic 0–100 score.

## `maxEvents` (type: `integer`):

Hard output cap in addition to Apify maxTotalChargeUsd. Highest-priority records are delivered first.

## `includeNew` (type: `boolean`):

Emit entities missing from the previous snapshot.

## `includeChanged` (type: `boolean`):

Emit entities with meaningful configured field changes.

## `includeRemoved` (type: `boolean`):

Emit entities present previously but absent now.

## `includeUnchanged` (type: `boolean`):

Usually off to avoid paying for non-actionable records.

## `customIdFields` (type: `array`):

Optional override. Defaults: id, name, permalink, url.

## `customCompareFields` (type: `array`):

Optional override. Defaults: title, body, subreddit, score, upvoteRatio, numComments, author, flair, isLocked.

## `fuzzyEntityResolution` (type: `boolean`):

Best-effort normalized-name matching when no strong identifier exists. Exact IDs always win.

## `debug` (type: `boolean`):

Store non-billable diagnostics in the OUTPUT record and verbose logs.

## Actor input object example

```json
{
  "sourceMode": "inline",
  "records": [
    {
      "id": "rd-demo-001",
      "subreddit": "smallbusiness",
      "title": "Looking for an affordable review-monitoring tool",
      "body": "Need a simple alternative to enterprise tools for five locations.",
      "score": 184,
      "upvoteRatio": 0.96,
      "numComments": 73,
      "observedAt": "2026-08-02T10:00:00Z",
      "productWorkflow": "reddit-purchase-intent-leads"
    }
  ],
  "upstreamActorInput": {},
  "officialApiItemsPath": "",
  "previousRecords": [
    {
      "id": "rd-demo-001",
      "subreddit": "smallbusiness",
      "title": "Review monitoring options?",
      "body": "Comparing tools.",
      "score": 24,
      "upvoteRatio": 0.82,
      "numComments": 9,
      "observedAt": "2026-08-01T10:00:00Z",
      "productWorkflow": "reddit-purchase-intent-leads"
    }
  ],
  "minimumScore": 35,
  "maxEvents": 100,
  "includeNew": true,
  "includeChanged": true,
  "includeRemoved": false,
  "includeUnchanged": false,
  "fuzzyEntityResolution": true,
  "debug": false
}
```

# Actor output Schema

## `insights` (type: `string`):

Ranked dataset records with evidence.

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

Counts, source diagnostics, score distribution, and budget-stop state.

# 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 = {
    "records": [
        {
            "id": "rd-demo-001",
            "subreddit": "smallbusiness",
            "title": "Looking for an affordable review-monitoring tool",
            "body": "Need a simple alternative to enterprise tools for five locations.",
            "score": 184,
            "upvoteRatio": 0.96,
            "numComments": 73,
            "observedAt": "2026-08-02T10:00:00Z",
            "productWorkflow": "reddit-purchase-intent-leads"
        }
    ],
    "previousRecords": [
        {
            "id": "rd-demo-001",
            "subreddit": "smallbusiness",
            "title": "Review monitoring options?",
            "body": "Comparing tools.",
            "score": 24,
            "upvoteRatio": 0.82,
            "numComments": 9,
            "observedAt": "2026-08-01T10:00:00Z",
            "productWorkflow": "reddit-purchase-intent-leads"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("night111/reddit-purchase-intent-leads").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 = {
    "records": [{
            "id": "rd-demo-001",
            "subreddit": "smallbusiness",
            "title": "Looking for an affordable review-monitoring tool",
            "body": "Need a simple alternative to enterprise tools for five locations.",
            "score": 184,
            "upvoteRatio": 0.96,
            "numComments": 73,
            "observedAt": "2026-08-02T10:00:00Z",
            "productWorkflow": "reddit-purchase-intent-leads",
        }],
    "previousRecords": [{
            "id": "rd-demo-001",
            "subreddit": "smallbusiness",
            "title": "Review monitoring options?",
            "body": "Comparing tools.",
            "score": 24,
            "upvoteRatio": 0.82,
            "numComments": 9,
            "observedAt": "2026-08-01T10:00:00Z",
            "productWorkflow": "reddit-purchase-intent-leads",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("night111/reddit-purchase-intent-leads").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 '{
  "records": [
    {
      "id": "rd-demo-001",
      "subreddit": "smallbusiness",
      "title": "Looking for an affordable review-monitoring tool",
      "body": "Need a simple alternative to enterprise tools for five locations.",
      "score": 184,
      "upvoteRatio": 0.96,
      "numComments": 73,
      "observedAt": "2026-08-02T10:00:00Z",
      "productWorkflow": "reddit-purchase-intent-leads"
    }
  ],
  "previousRecords": [
    {
      "id": "rd-demo-001",
      "subreddit": "smallbusiness",
      "title": "Review monitoring options?",
      "body": "Comparing tools.",
      "score": 24,
      "upvoteRatio": 0.82,
      "numComments": 9,
      "observedAt": "2026-08-01T10:00:00Z",
      "productWorkflow": "reddit-purchase-intent-leads"
    }
  ]
}' |
apify call night111/reddit-purchase-intent-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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