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

Find Reddit users showing buying intent or pain about your topic and turn them into a B2B lead list. Searches high-intent subreddits by keyword, labels each lead (buying-signal, recommendation, complaint, question). No login, no API key.

- **URL**: https://apify.com/logiover/reddit-lead-finder.md
- **Developed by:** [Logiover](https://apify.com/logiover) (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 $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Lead Finder — B2B Leads & Buying Intent

**Turn Reddit into a B2B lead list.** Reddit Lead Finder scans high-intent subreddits for people who are actively *looking to buy*, *asking for a recommendation*, or *complaining about a tool they already use* — then hands you a clean, sales-ready spreadsheet of those users. Every lead comes with the exact keyword that matched, a derived **intent label** (buying-signal, seeking-recommendation, complaint, question), the author's username and profile link, and the full text of what they said, so your team can open the thread and start a real conversation.

No Reddit login. No API key. No OAuth. It runs on a keyless public Reddit archive, so you can go from zero to a thousand leads in a single run.

> Perfect for **social selling, B2B lead generation, market research, finding your first customers, and competitor-mention monitoring** on Reddit.

---

### Why Reddit for lead generation?

Reddit is where buyers ask real questions before they purchase. Millions of people every day post things like *"looking for a CRM that isn't overpriced"*, *"any alternative to HubSpot?"*, or *"we're fed up with our current agency"* — pure, unfiltered buying intent, with the person's username attached. Reddit's own search can't search comment bodies and can't classify intent, so those leads normally stay buried. This actor surfaces them, labels them, and exports them.

Instead of blasting cold lists, you reach out to people **at the exact moment they've raised their hand**. That is the highest-converting lead there is.

---

### What it does

1. Takes your **keywords** (buying-intent phrases) and **subreddits** (the communities your buyers hang out in).
2. Runs a full-text search for each keyword inside each subreddit, across both **posts and comments**.
3. Classifies every match with an **intent label** using keyword + language heuristics.
4. Outputs a de-duplicated lead list you can filter by intent and export straight to your CRM.

Run it with **empty input** and it defaults to a strong buying-intent keyword set across ~40 high-traffic B2B subreddits (Entrepreneur, smallbusiness, SaaS, marketing, startups, ecommerce, sales, and more), returning **1,000+ leads** out of the box.

---

### Use cases

- **Social selling** — find people asking for exactly what you sell and reach out while intent is hot.
- **B2B lead generation** — build targeted prospect lists for your product category without scraping LinkedIn.
- **Finding your first customers** — indie hackers and founders: discover users describing the pain your product solves.
- **Competitor-mention monitoring** — search for a rival's brand name to catch users complaining about them or asking for alternatives, then swoop in.
- **Market & customer research** — quantify how often people ask for a solution in your space, and in which communities.
- **Content & SEO research** — mine the real questions your audience asks to fuel blog posts and landing pages.
- **Agency prospecting** — find businesses openly unhappy with their current marketing/dev/design vendor.

---

### Input

Everything is optional. Run with `{}` to get 1,000+ default buying-intent leads. Provide your own values to target a niche.

| Field | Type | Description |
|-------|------|-------------|
| `keywords` | array (text) | Intent phrases to search for, e.g. `looking for`, `alternative to`, `recommend`, `best CRM for`, `fed up with`. Multi-word phrases work. Empty → strong default buying-intent set. |
| `subreddits` | array (text) | Subreddits to search (no `r/` prefix), e.g. `SaaS`, `marketing`, `Entrepreneur`. Search is scoped to these communities. Empty → strong default B2B set. |
| `intentFilter` | select | `Any`, `Buying signals only`, `Questions`, or `Complaints`. Keeps only leads whose derived intent matches. |
| `contentType` | select | `Both`, `Posts`, or `Comments`. |
| `maxResults` | integer | Total number of leads to collect. Default `1000`. Raise to pull more. |
| `afterDate` | text (ISO) | Only leads created after this date (`YYYY-MM-DD`). Use it to find fresh leads. |
| `beforeDate` | text (ISO) | Only leads created before this date. Combine with `afterDate` for a window. |
| `minScore` | integer | Only posts/comments with a Reddit score at or above this. Optional. |
| `proxyConfiguration` | object | Optional Apify Proxy. Works fine on direct connection; fresh IP per retry with direct fallback. |

#### Example inputs

**Empty — 1,000+ default buying-intent leads:**

```json
{}
````

**Find people who want a CRM, in sales & startup communities:**

```json
{
  "keywords": ["looking for a crm", "best crm", "alternative to salesforce", "crm recommendation"],
  "subreddits": ["sales", "startups", "smallbusiness", "Entrepreneur"],
  "intentFilter": "Buying signals only",
  "maxResults": 500
}
```

**Catch complaints about a competitor (great for win-back / switch campaigns):**

```json
{
  "keywords": ["mailchimp", "fed up with mailchimp", "mailchimp alternative"],
  "subreddits": ["marketing", "Emailmarketing", "smallbusiness"],
  "intentFilter": "Complaints",
  "afterDate": "2026-01-01"
}
```

***

### Output

Each row is one lead. Fields:

| Field | Type | Description |
|-------|------|-------------|
| `type` | string | `post` or `comment`. |
| `redditId` | string | Reddit base-36 ID. |
| `subreddit` | string | Subreddit the lead was found in. |
| `author` | string | The Reddit username — the person to reach out to. |
| `authorProfileUrl` | string | Direct link to the author's Reddit profile. |
| `title` | string | Post title, or the thread title for a comment. |
| `text` | string | The post/comment body containing the signal. |
| `matchedKeyword` | string | The intent keyword that qualified this lead. |
| `intentLabel` | string | `buying-signal`, `seeking-recommendation`, `complaint`, `question`, or `general`. |
| `score` | number | Reddit score (upvotes − downvotes). |
| `numComments` | number | Comment count (posts only). |
| `upvoteRatio` | number | Upvote fraction (posts only). |
| `createdUtc` | string | ISO 8601 UTC timestamp. |
| `permalink` | string | Direct link to the post/comment. |
| `url` | string | Outbound URL (posts) or thread link (comments). |
| `flair` | string | Post flair, or author flair for comments. |
| `over18` | boolean | NSFW flag (posts only). |

#### Sample output item

```json
{
  "type": "post",
  "redditId": "1upoo77",
  "subreddit": "Entrepreneur",
  "author": "lilyjunalyn",
  "authorProfileUrl": "https://www.reddit.com/user/lilyjunalyn",
  "title": "Looking for companies/startups interested in advertising to an AI audience",
  "text": "We run a site with 8.5M monthly visits and want to open up ad inventory...",
  "matchedKeyword": "looking for",
  "intentLabel": "buying-signal",
  "score": 12,
  "numComments": 8,
  "upvoteRatio": 0.99,
  "createdUtc": "2026-07-05T14:12:24.000Z",
  "permalink": "https://www.reddit.com/r/Entrepreneur/comments/1upoo77/looking_for_companiesstartups_interested_in/",
  "url": "https://www.reddit.com/r/Entrepreneur/comments/1upoo77/looking_for_companiesstartups_interested_in/",
  "flair": "Marketing and Communications",
  "over18": false
}
```

***

### How the intent labels work

The `intentLabel` is what turns raw posts into **leads**. It's derived from the matched keyword plus language patterns in the text — not assigned randomly:

- **buying-signal** — actively shopping or switching: *"looking to buy"*, *"in the market for"*, *"switching from X"*, *"who do you use"*, *"willing to pay"*, *"hire someone to"*.
- **seeking-recommendation** — asking the crowd which product to pick: *"any recommendations"*, *"alternative to"*, *"best tool for"*, *"which CRM"*, *"anyone using X"*.
- **complaint** — frustrated with a current tool/vendor (prime switch target): *"fed up with"*, *"frustrated with"*, *"too expensive"*, *"keeps crashing"*, *"worst"*.
- **question** — a softer "how / can / does" question that still shows interest.
- **general** — the keyword matched but no strong intent pattern was present.

Use the `intentFilter` input to keep only the categories you care about — e.g. `Buying signals only` for outbound, or `Complaints` for competitor win-back.

***

### Exporting your leads

Open the run's **Dataset** tab and export to **CSV, Excel, JSON, or HTML** in one click — ready to import into HubSpot, Salesforce, Pipedrive, Notion, Google Sheets, or your outreach tool. You can also pull results via the [Apify API](https://docs.apify.com/api/v2) or connect them to 5,000+ apps with Apify integrations (Make, Zapier, webhooks). Filter by `intentLabel` before exporting to hand sales only the hottest leads.

***

### Frequently asked questions

#### How to find leads on Reddit?

Search the subreddits where your buyers hang out for phrases that signal intent — *"looking for"*, *"recommend"*, *"alternative to"*, *"fed up with"* — then reach out to the people who posted them. This actor automates exactly that: it runs those searches across dozens of communities at once, labels each result by intent, and gives you the username and thread link so you can respond.

#### How do I use Reddit for lead generation?

Point the actor at your niche (your keywords + the subreddits your audience uses), run it, filter the output to `buying-signal` and `seeking-recommendation`, and export the list. Each lead is a real person who just described a need you can meet — reply helpfully in the thread or reach out, and you're doing social selling at scale instead of cold outreach.

#### Can I scrape Reddit by keyword?

Yes. Provide any keywords (single words or multi-word phrases) and they're searched as full text across the subreddits you choose — including inside **comment bodies**, which Reddit's own search can't do. That's how you catch buying signals buried deep in discussion threads.

#### Do I need a Reddit API key or login?

No. Reddit Lead Finder uses a keyless, no-login public Reddit archive as its data source, so there's nothing to authenticate, no OAuth app to register, and no rate-limited developer key to manage. Just set your inputs and run.

#### Why does it search specific subreddits instead of all of Reddit?

Full-text search is scoped to the subreddits you give it — and that's a feature, not a limitation. A person saying *"looking for an alternative"* inside r/SaaS or r/marketing is a far better B2B lead than the same phrase in a random meme subreddit. Scoping to the right communities is what makes these leads sales-grade. Leave the field empty and it uses a strong default set of ~40 business subreddits.

#### How many leads can I get, and how do I get more?

The default run returns 1,000+ leads. Raise `maxResults`, add more `keywords`, or add more `subreddits` to pull more. Because every keyword is searched in every subreddit, adding either dimension multiplies your coverage. A single run is bounded by a time budget so it stays fast and cheap; run it on a schedule to keep a steady stream of fresh leads.

#### How do I find only fresh, recent leads?

Set `afterDate` to a recent date (e.g. the first of this month). The actor returns newest-first and only includes posts/comments created after that date — ideal for a daily or weekly "new leads" run so you catch buyers while their intent is still hot.

#### How is this different from a generic Reddit scraper or Reddit search actor?

A generic scraper dumps raw posts; this actor is purpose-built for **sales**. It combines intent keywords with the right communities, derives an **intent label** for every result, de-duplicates people across keywords, and outputs CRM-ready fields (author, profile URL, matched keyword, thread link). You get a lead list, not a data dump.

#### Is this affiliated with Reddit?

No. This is an independent tool that reads from a public, keyless Reddit archive. It is not affiliated with, endorsed by, or sponsored by Reddit, Inc. Use it responsibly and in line with Reddit's content policies and applicable laws when contacting users.

***

### Tips for the best leads

- **Use specific product/category keywords** (`"best email tool"`, `"alternative to notion"`) alongside generic ones (`"recommend"`) to sharpen relevance.
- **Add your competitor's name as a keyword** with `intentFilter: "Complaints"` to build a switch-campaign list.
- **Narrow subreddits to your exact niche** for higher-quality, lower-noise leads.
- **Run on a schedule** with a rolling `afterDate` to always work the freshest intent.

***

### Related actors

Looking for other Reddit and lead-gen tools? Check the owner's other actors for Reddit historical archive scraping, subreddit and comment-tree scraping, and B2B lead scrapers for other sources. Combine them to enrich your Reddit leads with data from across the web.

# Actor input Schema

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

Free-text phrases that signal buying intent or pain, e.g. "looking for", "alternative to", "recommend", "fed up with", "best CRM for". Multi-word phrases are supported. Each keyword is searched across every subreddit below. Leave empty to use a strong default buying-intent keyword set.

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

Subreddit names to search (no /r/ prefix needed), e.g. "SaaS", "marketing", "Entrepreneur". Full-text search is scoped to these communities — targeting the right subreddits is what makes the leads high-quality. Leave empty to use a strong default set of high-traffic B2B / business subreddits.

## `intentFilter` (type: `string`):

Keep only leads whose derived intent matches. 'Buying signals only' = purchase/switching signals + recommendation requests. 'Questions' = questions + recommendation requests. 'Complaints' = frustration with an existing tool/vendor. 'Any' keeps everything.

## `contentType` (type: `string`):

Search Reddit posts, comments, or both. Comments often contain the richest buying signals ('we switched from X because…'), while posts surface people openly asking for recommendations.

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

Total number of leads to collect across all keywords and subreddits. A bounded default keeps empty-input runs fast and cheap; raise it to pull thousands more.

## `afterDate` (type: `string`):

Only return leads created AFTER this date. Format: YYYY-MM-DD or full ISO timestamp. Great for finding FRESH leads (e.g. the last 30 days). Example: '2026-06-01'

## `beforeDate` (type: `string`):

Only return leads created BEFORE this date. Combine with After date for a precise time window. Example: '2026-07-01'

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

Only return posts/comments with a Reddit score (upvotes minus downvotes) at or above this value. Leave empty for no filter. Useful to focus on visible, high-engagement threads.

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

Optional. The data source is a keyless public archive that works fine on a direct connection. You can route through Apify Proxy for extra robustness; a fresh IP is used on each retry and the final retry falls back to a direct connection.

## Actor input object example

```json
{
  "keywords": [
    "looking for",
    "recommend",
    "alternative to",
    "best tool for"
  ],
  "subreddits": [
    "Entrepreneur",
    "smallbusiness",
    "SaaS",
    "marketing"
  ],
  "intentFilter": "Any",
  "contentType": "Both",
  "maxResults": 1000,
  "afterDate": null,
  "beforeDate": null,
  "minScore": null,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All leads found by this run. Open the Dataset tab to browse, filter by intent, and export as CSV, JSON, or Excel for your CRM.

# 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 = {
    "keywords": [
        "looking for",
        "recommend",
        "alternative to",
        "best tool for"
    ],
    "subreddits": [
        "Entrepreneur",
        "smallbusiness",
        "SaaS",
        "marketing"
    ],
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "keywords": [
        "looking for",
        "recommend",
        "alternative to",
        "best tool for",
    ],
    "subreddits": [
        "Entrepreneur",
        "smallbusiness",
        "SaaS",
        "marketing",
    ],
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "keywords": [
    "looking for",
    "recommend",
    "alternative to",
    "best tool for"
  ],
  "subreddits": [
    "Entrepreneur",
    "smallbusiness",
    "SaaS",
    "marketing"
  ],
  "maxResults": 1000
}' |
apify call logiover/reddit-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Lead Finder - Buying Intent B2B Leads",
        "description": "Find Reddit users showing buying intent or pain about your topic and turn them into a B2B lead list. Searches high-intent subreddits by keyword, labels each lead (buying-signal, recommendation, complaint, question). No login, no API key.",
        "version": "0.1",
        "x-build-id": "77VBmqrqMBuNiw36a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~reddit-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-reddit-lead-finder",
                "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/logiover~reddit-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-logiover-reddit-lead-finder",
                "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/logiover~reddit-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-reddit-lead-finder",
                "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",
                "properties": {
                    "keywords": {
                        "title": "Keywords / intent phrases",
                        "type": "array",
                        "description": "Free-text phrases that signal buying intent or pain, e.g. \"looking for\", \"alternative to\", \"recommend\", \"fed up with\", \"best CRM for\". Multi-word phrases are supported. Each keyword is searched across every subreddit below. Leave empty to use a strong default buying-intent keyword set.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits to search",
                        "type": "array",
                        "description": "Subreddit names to search (no /r/ prefix needed), e.g. \"SaaS\", \"marketing\", \"Entrepreneur\". Full-text search is scoped to these communities — targeting the right subreddits is what makes the leads high-quality. Leave empty to use a strong default set of high-traffic B2B / business subreddits.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "intentFilter": {
                        "title": "Intent filter",
                        "enum": [
                            "Any",
                            "Buying signals only",
                            "Questions",
                            "Complaints"
                        ],
                        "type": "string",
                        "description": "Keep only leads whose derived intent matches. 'Buying signals only' = purchase/switching signals + recommendation requests. 'Questions' = questions + recommendation requests. 'Complaints' = frustration with an existing tool/vendor. 'Any' keeps everything.",
                        "default": "Any"
                    },
                    "contentType": {
                        "title": "Content type",
                        "enum": [
                            "Both",
                            "Posts",
                            "Comments"
                        ],
                        "type": "string",
                        "description": "Search Reddit posts, comments, or both. Comments often contain the richest buying signals ('we switched from X because…'), while posts surface people openly asking for recommendations.",
                        "default": "Both"
                    },
                    "maxResults": {
                        "title": "Max leads",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Total number of leads to collect across all keywords and subreddits. A bounded default keeps empty-input runs fast and cheap; raise it to pull thousands more.",
                        "default": 1000
                    },
                    "afterDate": {
                        "title": "After date (ISO)",
                        "type": "string",
                        "description": "Only return leads created AFTER this date. Format: YYYY-MM-DD or full ISO timestamp. Great for finding FRESH leads (e.g. the last 30 days). Example: '2026-06-01'",
                        "default": null
                    },
                    "beforeDate": {
                        "title": "Before date (ISO)",
                        "type": "string",
                        "description": "Only return leads created BEFORE this date. Combine with After date for a precise time window. Example: '2026-07-01'",
                        "default": null
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "type": "integer",
                        "description": "Only return posts/comments with a Reddit score (upvotes minus downvotes) at or above this value. Leave empty for no filter. Useful to focus on visible, high-engagement threads.",
                        "default": null
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Optional. The data source is a keyless public archive that works fine on a direct connection. You can route through Apify Proxy for extra robustness; a fresh IP is used on each retry and the final retry falls back to a direct connection.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
