# Reddit Lead Finder & Brand Monitoring: Leads, Mentions (`quarra/reddit-lead-finder`) Actor

Reddit leads and brand mentions by keyword: the posts and comments where people ask for a recommendation, complain about a product or show buying intent, each with its link to reply and an AI read of its intent, buying signal and relevance. New mentions only on a schedule.

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

## Pricing

from $2.20 / 1,000 posts

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reddit Lead Finder: Leads, Mentions & Brand Monitoring

Give keywords (or subreddits) and get only the Reddit posts and comments where someone asks for a recommendation or
is looking to buy, choose or switch, each with the link to reply and an AI read of what the author wants. The rest of
what the search finds stays out of your list and is not charged as a result. Clear the filter and you get every
mention instead, for brand monitoring. No login, no cookies, no API key. Export as JSON, CSV or Excel, or read it
through the Apify API.

- **Posts and comments**: keywords are searched in posts and, separately, in comments, on all of Reddit or inside one
  subreddit. You can also watch the latest posts of subreddits with no keyword.
- **The link to reply**: every record has its `url` (the post or the comment itself), its subreddit, author, date and
  score.
- **Leads only, by default**: every post and comment found is read by the AI, and only the ones where the author asks
  for help or a recommendation, or is looking to buy, choose or switch, and that are really about your keyword, are
  delivered. Pick other signals (a pain point, a complaint, a price mentioned, one of your own labels) or clear the
  filter to get everything.
- **An AI read of each one**: `intent` (seeking_recommendation, complaint, purchase_intent, comparison, advice,
  question, self_promotion…), `wantsHelp`, `buyingSignal`, `mentionsPrice`, `featureRequest`, `isVendor`, the
  `painPoint`, the brands and products named, a one-sentence summary and a `relevance` score from 0 to 1 against your
  keyword. Add up to 5 yes/no labels of your own.
- **Exact words when you need them**: strict search keeps only items with every word of your keyword, and excluded
  keywords drop the ones you do not want. Both are free for what they drop.
- **Brand monitoring on a schedule**: turn on **Only new since the last run** with a watch name, schedule the Actor,
  and each run returns and charges only the mentions earlier runs did not return.

**$2.50 per 1,000 posts, $2.50 per 1,000 comments** delivered, less on paid plans, plus **$0.50 per 1,000 posts and
comments analyzed** (the ones left out by the leads-only filter included: they pay their analysis only), plus $0.005
per run. Searches that fail, duplicates, items dropped by strict search or excluded keywords and analyses that fail
are not charged.

### What people use it for

- **Finding leads**: posts and comments where someone asks "what do you use for…?" or "is there an alternative to…?"
  in your niche, with the link to answer them.
- **Brand monitoring**: every post and comment that mentions your brand, product or a competitor's name, sorted by
  sentiment and intent, new ones only.
- **Reddit mentions for customer support and PR**: complaints and questions about your product, found as they appear.
- **Market research**: the pain points and the products people name when they look for a solution.

### How to find Reddit leads

1. Type keywords into **Keywords to find in posts**, **Keywords to find in comments**, or name **Subreddits to
   watch**, one per line. Quotes keep a phrase together: `"alternative to"`.
2. Optionally restrict the search to one subreddit, choose New to see the latest first, and set a time range.
3. Keep **Leads only** as it is (asks for help or a recommendation, or a buying signal; minimum relevance 0.5) or
   choose your own signals. **Posts or comments to check per keyword** sets how many search results are read; the
   leads among them are delivered.
4. Click **Start**. Sort the **Output** by `aiAnalysis.relevance`. The run's status says how many items the filter
   left out.

Through the API:

```json
{
  "searchQueries": ["CRM recommendation"],
  "commentSearchQueries": ["looking for a CRM"],
  "searchSubreddit": "smallbusiness",
  "searchSort": "new",
  "timeFilter": "week",
  "maxPostsPerSource": 50
}
```

Through the API, leave out `aiKeepOnly` and `aiMinRelevance` to get the defaults above.

A daily lead list, only the new ones, keeping the people who want to switch tools (one of your own labels):

```json
{
  "searchQueries": ["project management tool"],
  "commentSearchQueries": ["alternative to"],
  "searchSort": "new",
  "timeFilter": "day",
  "excludeKeywords": ["hiring"],
  "aiLabels": { "switching": "The author wants to switch from one product to another" },
  "aiKeepOnly": ["wantsHelp", "buyingSignal", "anyLabel"],
  "onlyNew": true,
  "watchName": "pm-leads"
}
```

Every mention of a brand, for monitoring (filter cleared):

```json
{
  "searchQueries": ["\"Acme CRM\""],
  "commentSearchQueries": ["\"Acme CRM\""],
  "strictSearch": true,
  "searchSort": "new",
  "aiKeepOnly": [],
  "aiMinRelevance": 0,
  "onlyNew": true,
  "watchName": "acme-mentions"
}
```

Like any Actor on Apify, it can be scheduled, connected to webhooks, Make, Zapier, n8n, or called by AI agents
through Apify's MCP server.

### Output

One record per lead (or per post and comment found, with the filter cleared), with `aiAnalysis` next to its own
fields. A real lead (October 21, 2026, from the search "best CRM for small business" with the default filter: 20
posts checked, 16 delivered, 4 left out; author replaced, text and some fields left out):

```json
{
  "type": "post",
  "id": "1wplyyc",
  "url": "https://www.reddit.com/r/CRMSoftware/comments/1wplyyc/best_crm_for_teams_what_works_when_everyone_needs/",
  "subreddit": "CRMSoftware",
  "title": "Best CRM for teams: what works when everyone needs to see the same leads?",
  "author": "example_user",
  "createdAt": "2026-09-25T03:36:32Z",
  "score": 9,
  "numComments": 31,
  "source": "search: best CRM for small business",
  "aiAnalysisStatus": "ok",
  "aiAnalysis": {
    "language": "en",
    "sentiment": "mixed",
    "sentimentScore": -0.2,
    "emotion": "frustration",
    "intent": "seeking_recommendation",
    "category": "business",
    "topics": ["crm", "team-collaboration", "event-photography"],
    "entities": [{"name": "Pipedrive", "type": "brand"}, {"name": "Monday", "type": "brand"}, {"name": "Google Calendar", "type": "product"}],
    "summary": "An event photography business owner seeks a CRM to centralize leads and improve team visibility over current spreadsheet chaos.",
    "painPoint": "Losing track of leads using scattered emails and spreadsheets",
    "wantsHelp": true,
    "buyingSignal": true,
    "mentionsPrice": false,
    "featureRequest": false,
    "isVendor": false,
    "relevance": 0.9,
    "labels": null
  }
}
```

| Field | What it holds |
|---|---|
| `url`, `subreddit`, `author`, `createdAt`, `score` | where to answer, and who wrote it and when |
| `title`, `body` (posts), `body`, `postTitle`, `postUrl` (comments) | the text, and for a comment the post it was written under |
| `aiAnalysis.intent` | what the author is doing: question, seeking_recommendation, complaint, praise, purchase_intent, comparison, advice (answering someone else), announcement, self_promotion, discussion, humor |
| `aiAnalysis.wantsHelp`, `buyingSignal`, `mentionsPrice`, `featureRequest`, `isVendor` | business signals, true or false: asks the readers for help or a recommendation for their own need, is looking to buy, choose, hire or switch, names a price or budget, asks for a feature, sells or builds what they talk about |
| `aiAnalysis.painPoint`, `summary`, `entities`, `topics` | the problem expressed, one sentence, the brands and products named |
| `aiAnalysis.relevance` | how much the item is really about your keyword, 0 to 1 (`null` for subreddits watched without a keyword) |
| `aiAnalysis.labels` | your own yes/no labels |

A comment record also has `postId`, `postTitle`, `postUrl` and `parentId`. The `aiAnalysis` fields are an AI's reading
of the text, not a guarantee: use `relevance` and `intent` together to sort, and check a lead before you answer it.
Field names stay the same between runs: a value Reddit does not provide is `null`, not missing. The run summary is
the `OUTPUT` record of the run's key-value store.

### AI analysis

On by default in this Actor, because it is what tells a lead from a mention. **$0.50 per 1,000 analyzed records, every
field and signal included.** Untick **AI analysis** to get the plain posts and comments for the scraping price alone.

- Charged once per post or comment analyzed in full, delivered or left out by the filter. Deleted, removed, bot
  (AutoModerator) and empty records are not analyzed and not charged.
- **Leads only** (`aiKeepOnly`): a post or comment is delivered when its analysis has at least one of the signals or
  intents you pick. Default: `wantsHelp` and `buyingSignal`. Also available: `painPoint`, `mentionsPrice`,
  `featureRequest`, `isVendor`, `anyLabel` (one of your own labels is true) and every intent. The others are not
  delivered and not charged as a post or comment.
- **Minimum relevance** (`aiMinRelevance`, default 0.5): keyword results scored below it are left out the same way.
  Subreddit posts have no keyword and no score, so it does not apply to them.
- If an analysis fails: with the filter on, the item is not delivered and nothing is charged for it (run again later
  to check it; with **Only new**, the next run checks it again). With the filter cleared, the item is delivered and
  charged as usual, its `aiAnalysisStatus` is `failed` with the reason in `aiAnalysisError`, and the analysis is not
  charged.
- Any language in, summaries in English. The first ~2,500 characters of a long text are analyzed.
- It adds time: 20 posts were read and analyzed in 17 seconds, 20 comments from comment search in 77 seconds, on
  Apify on October 21, 2026. Expect one to five minutes per 100 records.

**Your own labels**: up to 5, as `{"label_name": "what makes it true"}`, for example
`{"budget": "The author states a budget or a price they would pay"}`. Included in the price.

### Inputs

- **Keywords to find in posts** and **Keywords to find in comments**: one search per line, as typed in Reddit's
  search box. **Subreddits to watch**: their latest posts, no keyword needed. **Search only inside this subreddit**.
- **Strict search (exact words only)** and where the words must appear. **Excluded keywords**.
- **Posts or comments to check per keyword or subreddit** (Reddit lists about 250 per search) and **Max leads in
  total** (counted in delivered items).
- **Keyword sort**, **Subreddit sort** and **Time range**. **Posted after / before** and **Comments posted after /
  before**.
- **Include NSFW** (off by default).
- **AI analysis** (on), **Your own labels**, **Leads only** and **Minimum relevance**.
- **Only new since the last run** and **Watch name**, for scheduled runs.

### Pricing

Pay per event:

| Apify plan | Posts | Comments |
|---|---|---|
| Free | $2.50 / 1,000 | $2.50 / 1,000 |
| Starter | $2.40 / 1,000 | $2.40 / 1,000 |
| Scale | $2.30 / 1,000 | $2.30 / 1,000 |
| Business and above | $2.20 / 1,000 | $2.20 / 1,000 |

AI analysis: $0.50 / 1,000 posts and comments analyzed on every plan, the ones left out by the filter included.

Plus the start: $0.005 per GB of run memory. Not charged: searches that fail, error records, duplicates, items
removed by strict search or excluded keywords, failed analyses, results already returned to a watch. Items left out
by the AI filter pay their analysis only. Set **Maximum cost per
run** in the run options and the run stops before going over it.

### Limits

- It finds items by keyword or subreddit: it does not read direct messages and does not contact anyone.
- Reddit lists about 250 posts per search, and comment search a limited number of comments. Use the date fields and
  several runs to cover a longer period.
- **Dates and time range only cut a comment search with the New sort.** With Relevance or Top, Reddit ignores them; the
  date fields still filter the results.
- Comment search reads about 10 comments per page: 230 comments took 4 minutes 40 seconds on Apify (October 21, 2026).
- Reddit's search is loose (many results for "best CRM for small business" were not about CRMs). The `relevance`
  score and strict search are there for that.
- Comments found by keyword are mostly answers to someone else: on October 21, 2026, 1 of 20 comments for "looking
  for a CRM" was a lead, against 16 of 20 posts for "best CRM for small business". Search posts first, and check more
  comments per keyword when you search comments.

### FAQ

**How do I find people asking for recommendations on Reddit?** Search your topic, in posts and in comments, and keep
the default **Leads only** filter: you get the people asking for help or a recommendation and the ones looking to buy
or switch. Words they use ("recommend", "alternative to", "looking for") in the keyword bring more of them.

**How do I monitor mentions of my brand on Reddit?** Put the brand name in quotes in both keyword fields, turn on
strict search, sort by New, clear **Leads only** and set the minimum relevance to 0, set a **Watch name**, turn on
**Only new**, and schedule the run. You are charged only for mentions you have not received before.

**Can I keep only the leads with a buying signal?** Yes: set **Leads only** to the buying signal alone. The others are
not delivered and pay their analysis only.

**Why did a run return fewer results than "Posts or comments to check"?** That number is how many search results are
read and checked; only the leads among them are delivered. The run's status and its `OUTPUT` record
(`aiAnalysis.filteredOut`) say how many were left out. Check more per keyword, use broader keywords, or loosen the
filter.

**Do I need a Reddit account or API key?** No account, no cookies, no API key. Platform costs are included in the
price.

**Is it legal?** It collects public posts and comments any logged-out visitor can see. Reddit's terms and privacy law
(GDPR in the EU) apply to how you use the data, including how you contact people.

**Does the Actor send anything to Quarra?** Only when a run fails or runs out of time: the Actor, its build, the error type, the line of our code where it happened, and the memory and time the run was given, so we can fix it fast. Never your input, your results, your account or the run ID.

### Related tools from Quarra

- [Reddit Scraper](https://apify.com/quarra/reddit-scraper): subreddits, searches, post URLs and users in one Actor.
- [Reddit Search Scraper](https://apify.com/quarra/reddit-search-scraper): posts and comments by keyword.
- [Reddit Comments Search Scraper](https://apify.com/quarra/reddit-comments-search-scraper): comments by keyword.
- [Reddit Comments Scraper](https://apify.com/quarra/reddit-comments-scraper): all the comments of posts from their
  links.
- [Reddit Subreddit Scraper](https://apify.com/quarra/reddit-subreddit-scraper): the posts of any subreddit.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords searched on Reddit, one query per line, as typed in Reddit's search box. Quotes keep a phrase together ("home assistant"); Strict search below enforces every word.

## `commentSearchQueries` (type: `array`):

Find COMMENTS containing your keywords, anywhere on Reddit (or in the subreddit above), one query per line: each comment with its text, score, date, parentId and its post's title and URL. Strict search and excluded keywords apply to the comment's text. Reddit's comment search ignores dates except with Search sort New: use New with a time range or date window to monitor.

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

Optional. Subreddit names (SaaS, r/SaaS) or URLs: their latest posts are read with the sort below and analyzed, with no keyword needed.

## `searchSubreddit` (type: `string`):

Optional. Restrict every search query and comment search to one subreddit (selfhosted, r/selfhosted or its URL).

## `strictSearch` (type: `boolean`):

Reddit's search returns loosely related posts (for home assistant, 17 of the top 100 contain it). When on, a post is kept only if its title or text contains EVERY word of the query, as whole words (ai never matches said; case and accents ignored). "Quotes" require a phrase, -word excludes, OR and parentheses group alternatives. Other sorts of the same time range are read to reach your limit. Rejected posts are never charged (counted in OUTPUT as filteredOut).

## `strictMatchIn` (type: `string`):

Where the words of a strict search and the excluded keywords must (or must not) appear.

## `excludeKeywords` (type: `array`):

Drop every post whose title or text contains one of these words or phrases, one per line (whole words, case and accents ignored; a comma belongs to the phrase, as in 10,000 views). Dropped items are not charged. Comment trees are not filtered; comments found by comment search are.

## `maxPostsPerSource` (type: `integer`):

How many search results (or subreddit posts) are read and checked by the AI for each keyword or subreddit. With the AI filter on, only the leads among them are delivered. Reddit's search lists about 250 results per keyword. With 'Only new', this is the window watched.

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

Optional hard cap for the whole run, counted in delivered posts and comments (the ones left out by the AI filter do not count). Respected exactly. Empty = no global cap.

## `searchSort` (type: `string`):

How search results are ordered. Comment searches use Relevance, Top or New (Hot and Most comments fall back to Relevance).

## `sort` (type: `string`):

How subreddit posts are ordered. Use Top or Controversial with a time range. For monitoring, New is the fastest and cheapest.

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

Used by the Top and Controversial subreddit sorts and by searches (comment search: with the New sort only).

## `postedAfter` (type: `string`):

Only items created after this date (2026-09-01, or relative: 7 days). Applies to posts, user history and listing URLs.

## `postedBefore` (type: `string`):

Only items created before this date.

## `commentsPostedAfter` (type: `string`):

Only comments written after this date (2026-10-01, or 12 hours), in threads and user histories. The tree is still walked, so a new reply under an old comment is found (reading stops after 10,000 comments in a row outside your dates); only matching comments are saved and charged.

## `commentsPostedBefore` (type: `string`):

Only comments written before this date.

## `includeNsfw` (type: `boolean`):

Include posts marked NSFW (18+). Off by default.

## `aiAnalysis` (type: `boolean`):

Adds aiAnalysis to every post and comment: language, sentiment and score (-1 to 1), emotion, intent (question, recommendation request, complaint, praise, purchase intent, comparison…), category, topics, named brands, products and people, a one-sentence English summary, the pain point, and business signals (wants help, buying signal, mentions a price, feature request, vendor). Search results also get a relevance score (0 to 1) against your query. Charged once per post or comment analyzed in full; deleted, removed, bot or empty records and failed analyses are free. Works with the items output format.

## `aiLabels` (type: `object`):

Up to 5 yes/no labels of your own, as {"label_name": "what makes it true"}. Each analyzed record gets labels: {label_name: true or false}. Example: {"switching": "The author wants to switch from one product to another", "budget": "The author states a budget"}. Included in the analysis price.

## `aiKeepOnly` (type: `array`):

Deliver only the posts and comments whose AI analysis shows at least one of these. Default: the author asks for help or a recommendation, or is looking to buy, choose or switch. The others are left out of the dataset and are not charged as a post or comment, only their AI analysis is. Clear it (and set the minimum relevance to 0) to get every post and comment found, for brand monitoring.

## `aiMinRelevance` (type: `number`):

0 to 1, default 0.5: leave out keyword results that the AI scores as less relevant to the keyword (Reddit's search also returns posts that only contain the word, or nothing like it). Keyword results only; subreddit posts are not scored. 0 = no minimum.

## `onlyNew` (type: `boolean`):

Remember what earlier runs of the same watch returned and output only new posts and new comments (with Include comments, also comments that earlier runs did not return under posts already seen; with Max comments per post, each run adds up to that many of them per thread, oldest included). Nothing already delivered is charged again, even after a run that timed out, was aborted or overlapped another. One run per watch at a time: a second one does nothing and charges nothing. Memory: key-value store quarra-reddit-watch-\<this Actor's ID, lowercase> of your account (a watch already kept in quarra-reddit-watch stays there). Set a watch name, then schedule the Actor.

## `watchName` (type: `string`):

Name of this watch's memory for 'Only new'. Recommended: runs with the same name share it even when you add or remove sources. Empty: the memory belongs to this exact set of inputs and filters, so adding a source starts a new watch that returns everything again (limits, output format and proxy don't count).

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

Connection. Keep the default (automatic). Costs are included in the price.

## Actor input object example

```json
{
  "searchQueries": [
    "best CRM for small business"
  ],
  "strictSearch": false,
  "strictMatchIn": "titleOrText",
  "maxPostsPerSource": 20,
  "searchSort": "relevance",
  "sort": "hot",
  "timeFilter": "all",
  "includeNsfw": false,
  "aiAnalysis": true,
  "aiLabels": {
    "switching": "The author wants to switch from one product to another or is unhappy with the one they use",
    "budget": "The author states a budget or a price they would pay"
  },
  "aiKeepOnly": [
    "wantsHelp",
    "buyingSignal"
  ],
  "aiMinRelevance": 0.5,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every record: posts, comments, profiles, communities and Markdown threads, each with a type field.

## `posts` (type: `string`):

Posts only (type post).

## `comments` (type: `string`):

Comments with parentId, depth and rootCommentId (type comment).

## `threads` (type: `string`):

With outputFormat threadMarkdown: one record per post with its whole comment tree as Markdown.

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

Per-input status, errors, posts dropped by filters, per-thread completeness and watch statistics.

# 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 = {
    "searchQueries": [
        "best CRM for small business"
    ],
    "maxPostsPerSource": 20,
    "aiLabels": {
        "switching": "The author wants to switch from one product to another or is unhappy with the one they use",
        "budget": "The author states a budget or a price they would pay"
    },
    "aiKeepOnly": [
        "wantsHelp",
        "buyingSignal"
    ],
    "aiMinRelevance": 0.5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("quarra/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 = {
    "searchQueries": ["best CRM for small business"],
    "maxPostsPerSource": 20,
    "aiLabels": {
        "switching": "The author wants to switch from one product to another or is unhappy with the one they use",
        "budget": "The author states a budget or a price they would pay",
    },
    "aiKeepOnly": [
        "wantsHelp",
        "buyingSignal",
    ],
    "aiMinRelevance": 0.5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("quarra/reddit-lead-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "best CRM for small business"
  ],
  "maxPostsPerSource": 20,
  "aiLabels": {
    "switching": "The author wants to switch from one product to another or is unhappy with the one they use",
    "budget": "The author states a budget or a price they would pay"
  },
  "aiKeepOnly": [
    "wantsHelp",
    "buyingSignal"
  ],
  "aiMinRelevance": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call quarra/reddit-lead-finder --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ig4EtIpnFeODLYoiP/builds/2abppuniZ0ZdRnC6k/openapi.json