# Reddit Buying-Intent Lead Monitor (`xtracto/reddit-intent-monitor`) Actor

Find people on Reddit asking for product recommendations, seeking alternatives to competitors, or voicing pain points. Scans posts and comments across subreddits, scores each lead by buying-intent strength, and de-duplicates across scheduled runs.

- **URL**: https://apify.com/xtracto/reddit-intent-monitor.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Buying-Intent Lead Monitor

Find people on Reddit who are actively looking to buy — asking for product recommendations, hunting for an alternative to a competitor, or venting about a tool they're tired of — and turn every match into a scored lead row. Scans both **posts and comments**, so you catch intent wherever it surfaces.

### Why use this actor

- **Real buying signals, not noise** — matches intent phrases like *"looking for a tool that"*, *"any recommendations for"*, and *"alternative to"*, then scores and labels each hit (high / medium / low) so you can work the hottest leads first.
- **Posts *and* comments** — buying intent often hides in a reply ("has anyone tried an alternative to X?"). This actor reads comment threads too and treats each qualifying comment as its own lead.
- **Category tagging** — every lead is tagged `recommendation-request`, `switching-intent`, or `pain-point`, plus the exact phrase that triggered it and a short context snippet.
- **Built for monitoring** — remembers what it already delivered, so a scheduled run only surfaces **new** leads each time. Point it at your target subreddits and let it run daily.
- **No account, no login, no API key required** — works out of the box.
- **Stable JSON output** — every row carries `_input`, `_source`, and `_scrapedAt` envelope fields plus the full Reddit post/comment object, ready for spreadsheets, CRMs, and databases. Export to JSON, CSV, or Excel.

### How it works

1. You give the actor a list of **intent phrases** (a strong starter set is prefilled), optionally a list of **subreddits** to watch and extra **keywords** to narrow to your product area.
2. For each phrase it searches the freshest matching posts in your chosen time window, then (optionally) opens each active post's comment thread.
3. Every post and comment is scored for buying intent, labelled, and tagged with a category and the matched phrase.
4. Leads below your minimum score are dropped; the rest stream into your dataset as one row each.
5. Already-delivered leads are skipped on later runs, so a scheduled monitor keeps giving you only fresh prospects.

You do not need to manage scrapers, browsers, logins, or blocks — it is all handled for you.

### Input

```json
{
  "phrases": [
    "looking for a tool that",
    "any recommendations for",
    "alternative to",
    "is there a way to",
    "what do you use for",
    "tired of using",
    "recommend a",
    "best tool for"
  ],
  "subreddits": ["SaaS", "Entrepreneur"],
  "keywords": [],
  "includeComments": true,
  "timeWindow": "week",
  "maxPostsPerQuery": 100,
  "maxCommentsPerPost": 50,
  "maxItems": 200,
  "minIntentScore": 1,
  "dedupeAcrossRuns": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `phrases` | array | Intent phrases to search for and score against. Strong phrases (recommendation requests, competitor alternatives, pain points) score highest. Required. |
| `subreddits` | array | Communities to monitor (without `r/`). Leave empty to search all of Reddit. |
| `keywords` | array | Optional product/topic terms combined with every phrase to focus results (e.g. `CRM`, `email marketing`). |
| `includeComments` | boolean | Also scan the comment threads of active posts. Default `true`. |
| `timeWindow` | string | `hour`, `day`, `week` (default), `month`, `year`, or `all`. Use `day`/`week` for a live monitor. |
| `maxPostsPerQuery` | integer | Posts to pull per phrase, per subreddit. Default `100`. |
| `maxCommentsPerPost` | integer | Comments read per post when comment scanning is on. Default `50`. |
| `maxItems` | integer | Overall cap on lead rows per run. Default `200`. |
| `minIntentScore` | integer | Keep only leads scoring at least this. Default `1`. Raise to `2`–`3` for higher-confidence leads. |
| `dedupeAcrossRuns` | boolean | Skip leads already delivered on previous runs. Default `true`. |
| `redditClientId` | string | Optional Reddit app ID for a higher rate limit on heavy jobs. Leave blank for the public path. |
| `redditClientSecret` | string | Optional secret for the app ID above. Not needed for the default path. |
| `proxyConfiguration` | object | Apify Proxy settings. Residential recommended for the most complete results. |

### Output

Every lead is one row. Below are two **real** rows from a live run against `r/SaaS` (long text truncated to ~300 characters; each row also carries Reddit's full set of native fields — awards, flair, media, etc. — passed through unchanged).

#### A post lead

```json
{
  "_source": "S2-webauth",
  "_scrapedAt": "2026-07-10T19:28:27Z",
  "_input": "any recommendations for",
  "type": "post",
  "id": "1ushr4x",
  "fullname": "t3_1ushr4x",
  "subreddit": "SaaS",
  "author": "prasadpilla",
  "author_fullname": "t2_10axkh",
  "title": "Looking for RB2B Alternative",
  "selftext": "Looking for a good alternative to RB2B for my startup\n\nRB2B looks great, but it's a bit too expensive for us right now\n\nIf you've used any solid alternatives (especially for B2B SaaS)\n\nI'd love to hear your recommendations and experiences.",
  "body": null,
  "contextSnippet": "Looking for RB2B Alternative Looking for a good alternative to RB2B for my startup RB2B looks great, but it's a bit too expensive for us right now If you've used any solid alternatives (especially for B2B SaaS) I'd love to hear your recommendations and experiences.",
  "score": 1,
  "ups": 1,
  "upvote_ratio": 1.0,
  "numComments": 1,
  "createdUtc": 1783672519.0,
  "createdISO": "2026-07-10T08:35:19Z",
  "permalink": "https://www.reddit.com/r/SaaS/comments/1ushr4x/looking_for_rb2b_alternative/",
  "matchedPhrase": "alternative to",
  "intentScore": 3.0,
  "intentLabel": "high",
  "intentCategory": "switching-intent"
}
```

#### A comment lead

```json
{
  "_source": "S2-webauth",
  "_scrapedAt": "2026-07-10T19:28:15Z",
  "_input": "looking for a tool that",
  "type": "comment",
  "id": "owinlp7",
  "fullname": "t1_owinlp7",
  "subreddit": "SaaS",
  "author": "EmbarrassedBuddy9743",
  "author_fullname": "t2_1zb7sb27ty",
  "title": "I checked whether AI actually recommends challenger tools or just parrots the same two incumbents…",
  "selftext": null,
  "body": "Good question, and it's honestly neither pure SEO nor just hoping web search picks you up. From what I keep seeing, the biggest lever is legibility: your site has to describe the actual job a buyer is trying to do, in the words they'd use… The \"for small teams\", \"cheapest\", \"X vs Y\", \"alternative to Z\" phrasings are where challengers get named…",
  "contextSnippet": "…seem to actually move it. One, build pages around real buyer intents, not your category name. The \"for small teams\", \"cheapest\", \"X vs Y\", \"alternative to Z\" phrasings are where challengers get named, especially in frozen categories where the generic slot is already taken. Two, corroboration off…",
  "score": 2,
  "ups": 2,
  "numComments": null,
  "createdUtc": 1783613721.0,
  "createdISO": "2026-07-09T16:15:21Z",
  "permalink": "https://www.reddit.com/r/SaaS/comments/1urtdxa/i_checked_whether_ai_actually_recommends/owinlp7/",
  "link_id": "t3_1urtdxa",
  "parent_id": "t1_owiiolf",
  "depth": 1,
  "matchedPhrase": "alternative to",
  "intentScore": 3.0,
  "intentLabel": "high",
  "intentCategory": "switching-intent"
}
```

| Field | Type | Description |
|---|---|---|
| `_source` | string | Internal tag for the data path used. |
| `_scrapedAt` | string | ISO-8601 UTC time the row was collected. |
| `_input` | string | The phrase (plus any keywords) whose search surfaced this lead. |
| `type` | string | `post` or `comment`. |
| `id` | string | Reddit short ID. |
| `fullname` | string | Reddit "fullname" (`t3_` for posts, `t1_` for comments) — the stable dedupe key. |
| `subreddit` | string | Community the lead is in (without `r/`). |
| `author` | string | Username of the person expressing intent — your prospect. |
| `title` | string | Post title. For a comment, the title of the post it lives under. |
| `selftext` | string | null | Post body (posts only). |
| `body` | string | null | Comment text (comments only). |
| `contextSnippet` | string | ~300 characters of text centred on the matched phrase, for quick triage. |
| `score` | integer | Reddit score (upvotes). |
| `numComments` | integer | null | Comment count (posts only). |
| `createdUtc` | number | Creation time as a UNIX timestamp. |
| `createdISO` | string | Creation time as ISO-8601 UTC. |
| `permalink` | string | Full `https://www.reddit.com/...` link to the post or comment. |
| `matchedPhrase` | string | The highest-weight intent phrase found in the text. |
| `intentScore` | number | Summed weight of all intent phrases found. Higher = stronger intent. |
| `intentLabel` | string | `high`, `medium`, or `low`. |
| `intentCategory` | string | `recommendation-request`, `switching-intent`, `pain-point`, or `general`. |

Each row also carries Reddit's full native fields (awards, flair, media previews, and — for comments — `link_id`, `parent_id`, `depth`), streamed through unchanged.

#### Error and notice rows

Failures and empty-but-legitimate runs emit structured rows instead of crashing:

```json
{ "_source": "none", "_input": "alternative to", "_warning": "all_matches_deduped",
  "_warningDetail": "7 intent match(es) found but all were already emitted on previous runs (dedupeAcrossRuns=true)." }
```

Filter on `_error` or `_warning` to triage.

### Notes / limits

- **Search coverage** — Reddit search returns roughly the first couple hundred results per phrase. For thorough coverage use several **narrow phrases** plus a **tight time window** (`day`/`week`) rather than one broad phrase.
- **Comment scanning cost** — reading comment threads is slower than posts alone. Lower `maxCommentsPerPost`, or set `includeComments` to `false`, for faster/cheaper runs.
- **Deduplication** — with `dedupeAcrossRuns` on, a scheduled monitor only returns new prospects. If a run finds matches but all were seen before, it records a notice row (it does not fail).
- **Proxy** — Residential is recommended; results from datacenter addresses can be incomplete.
- **Tune your phrases** — add phrases specific to your product ("switching from Salesforce", "Notion but for…") for sharper, higher-converting leads.

### Other Reddit Actors

| Actor | Best for |
|---|---|
| Reddit Search Scraper | Plain keyword search across Reddit or one subreddit. |
| Reddit Buying-Intent Lead Monitor | (this actor) Scored buying-intent leads from posts + comments, de-duplicated for scheduled monitoring. |

# Actor input Schema

## `phrases` (type: `array`):

Phrases that signal someone is shopping or frustrated (recommendation requests, competitor alternatives, pain points). Each phrase is searched and also used to score matches — the more (and heavier) the phrases a post or comment contains, the higher its intent score. Add phrases specific to your product for sharper leads.

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

Communities to monitor (without `r/`), e.g. `SaaS`, `Entrepreneur`, `smallbusiness`. Leave empty to search across all of Reddit.

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

Optional product/topic terms combined with every phrase to narrow results (e.g. `CRM`, `email marketing`). All keywords must appear alongside the phrase. Leave empty to match phrases alone.

## `includeComments` (type: `boolean`):

Also scan the comment threads of matching/active posts. Comments are where buying intent often hides ("has anyone tried an alternative to X?"). Turn off for a faster, posts-only run.

## `timeWindow` (type: `string`):

How far back to look. Use `day` or `week` for a live monitor on a schedule; widen to `month`/`year` for a one-off backfill.

## `maxPostsPerQuery` (type: `integer`):

How many posts to pull for each phrase (per subreddit). Reddit search returns roughly the first couple hundred results per phrase, so use several narrow phrases plus a tight time window for full coverage.

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

When scanning comments, how many to read per post before moving on. Higher = deeper threads but slower/costlier runs.

## `maxItems` (type: `integer`):

Overall cap on lead rows for the run. The actor stops once this many posts + comments have been collected.

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

Only keep leads scoring at least this. Strong phrases score 3, softer ones 1. Raise to 2–3 for higher-confidence (fewer) leads; keep at 1 for maximum reach.

## `dedupeAcrossRuns` (type: `boolean`):

Remember which posts and comments were already delivered, so a scheduled monitor only surfaces NEW leads each run. Turn off to always return every match.

## `redditClientId` (type: `string`):

Optional Reddit app client ID for a higher rate limit on very large or frequent runs. Leave blank to use the public path — it works for most jobs, no account needed.

## `redditClientSecret` (type: `string`):

Optional secret paired with the Reddit client ID above. Not required for the default public path; provide only if your Reddit app needs it.

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

Apify Proxy settings. Residential is recommended — Reddit is unreliable from datacenter addresses, so residential gives the most complete results. This is prefilled for you.

## Actor input object example

```json
{
  "phrases": [
    "looking for a tool that",
    "alternative to"
  ],
  "subreddits": [
    "SaaS",
    "Entrepreneur"
  ],
  "keywords": [],
  "includeComments": true,
  "timeWindow": "week",
  "maxPostsPerQuery": 100,
  "maxCommentsPerPost": 50,
  "maxItems": 200,
  "minIntentScore": 1,
  "dedupeAcrossRuns": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "phrases": [
        "looking for a tool that",
        "any recommendations for",
        "alternative to",
        "is there a way to",
        "what do you use for",
        "tired of using",
        "recommend a",
        "best tool for"
    ],
    "subreddits": [
        "SaaS",
        "Entrepreneur"
    ],
    "keywords": [],
    "maxPostsPerQuery": 100,
    "maxCommentsPerPost": 50,
    "maxItems": 200,
    "minIntentScore": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/reddit-intent-monitor").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 = {
    "phrases": [
        "looking for a tool that",
        "any recommendations for",
        "alternative to",
        "is there a way to",
        "what do you use for",
        "tired of using",
        "recommend a",
        "best tool for",
    ],
    "subreddits": [
        "SaaS",
        "Entrepreneur",
    ],
    "keywords": [],
    "maxPostsPerQuery": 100,
    "maxCommentsPerPost": 50,
    "maxItems": 200,
    "minIntentScore": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/reddit-intent-monitor").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 '{
  "phrases": [
    "looking for a tool that",
    "any recommendations for",
    "alternative to",
    "is there a way to",
    "what do you use for",
    "tired of using",
    "recommend a",
    "best tool for"
  ],
  "subreddits": [
    "SaaS",
    "Entrepreneur"
  ],
  "keywords": [],
  "maxPostsPerQuery": 100,
  "maxCommentsPerPost": 50,
  "maxItems": 200,
  "minIntentScore": 1
}' |
apify call xtracto/reddit-intent-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Buying-Intent Lead Monitor",
        "description": "Find people on Reddit asking for product recommendations, seeking alternatives to competitors, or voicing pain points. Scans posts and comments across subreddits, scores each lead by buying-intent strength, and de-duplicates across scheduled runs.",
        "version": "0.1",
        "x-build-id": "fBGsMP8oFVcyLBDkh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~reddit-intent-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-reddit-intent-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/xtracto~reddit-intent-monitor/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-reddit-intent-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/xtracto~reddit-intent-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-reddit-intent-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "phrases"
                ],
                "properties": {
                    "phrases": {
                        "title": "Intent phrases",
                        "type": "array",
                        "description": "Phrases that signal someone is shopping or frustrated (recommendation requests, competitor alternatives, pain points). Each phrase is searched and also used to score matches — the more (and heavier) the phrases a post or comment contains, the higher its intent score. Add phrases specific to your product for sharper leads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits (optional)",
                        "type": "array",
                        "description": "Communities to monitor (without `r/`), e.g. `SaaS`, `Entrepreneur`, `smallbusiness`. Leave empty to search across all of Reddit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Extra keywords (optional)",
                        "type": "array",
                        "description": "Optional product/topic terms combined with every phrase to narrow results (e.g. `CRM`, `email marketing`). All keywords must appear alongside the phrase. Leave empty to match phrases alone.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Also scan the comment threads of matching/active posts. Comments are where buying intent often hides (\"has anyone tried an alternative to X?\"). Turn off for a faster, posts-only run.",
                        "default": true
                    },
                    "timeWindow": {
                        "title": "Time window",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "How far back to look. Use `day` or `week` for a live monitor on a schedule; widen to `month`/`year` for a one-off backfill.",
                        "default": "week"
                    },
                    "maxPostsPerQuery": {
                        "title": "Max posts per phrase",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many posts to pull for each phrase (per subreddit). Reddit search returns roughly the first couple hundred results per phrase, so use several narrow phrases plus a tight time window for full coverage.",
                        "default": 100
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "When scanning comments, how many to read per post before moving on. Higher = deeper threads but slower/costlier runs.",
                        "default": 50
                    },
                    "maxItems": {
                        "title": "Max leads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Overall cap on lead rows for the run. The actor stops once this many posts + comments have been collected.",
                        "default": 200
                    },
                    "minIntentScore": {
                        "title": "Minimum intent score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep leads scoring at least this. Strong phrases score 3, softer ones 1. Raise to 2–3 for higher-confidence (fewer) leads; keep at 1 for maximum reach.",
                        "default": 1
                    },
                    "dedupeAcrossRuns": {
                        "title": "Skip leads seen on previous runs",
                        "type": "boolean",
                        "description": "Remember which posts and comments were already delivered, so a scheduled monitor only surfaces NEW leads each run. Turn off to always return every match.",
                        "default": true
                    },
                    "redditClientId": {
                        "title": "Reddit client ID (optional)",
                        "type": "string",
                        "description": "Optional Reddit app client ID for a higher rate limit on very large or frequent runs. Leave blank to use the public path — it works for most jobs, no account needed."
                    },
                    "redditClientSecret": {
                        "title": "Reddit client secret (optional)",
                        "type": "string",
                        "description": "Optional secret paired with the Reddit client ID above. Not required for the default public path; provide only if your Reddit app needs it."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Residential is recommended — Reddit is unreliable from datacenter addresses, so residential gives the most complete results. This is prefilled for you.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
