# 🎯 Capterra Displacement Leads (`nexgendata/capterra-displacement-leads`) Actor

Mine 1-3 star reviewers on competitor Capterra listings and turn them into structured SDR leads with role, company, pain quote, intent score, and optional LinkedIn enrichment. Public-data, GDPR-defensible alternative to ZoomInfo Intent / Bombora / 6sense — pay per surfaced lead.

- **URL**: https://apify.com/nexgendata/capterra-displacement-leads.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 displacement lead surfaceds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are 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

## Capterra Displacement Leads — Turn Competitor 1-3⭐ Reviewers Into SDR Pipeline

**For:** SDR / outbound leaders running competitive-displacement campaigns at Outreach, Salesloft, Apollo, Gong, ZoomInfo competitors — and any B2B SaaS team that wants to put a name + role + company on the people publicly complaining about a competitor's product.

This actor mines low-star reviews on a competitor's Capterra listing and turns each reviewer into a structured outbound lead: role, company, company size, industry, country, one-sentence pain summary, and an intent score (0-100). Optionally, pipes each lead through `nexgendata/lead-list-enricher` to attach a LinkedIn URL and verified email so your SDRs can hit "send" the same day.

If you sell against Salesforce, HubSpot, Outreach, Salesloft, Gong, Clari, ZoomInfo, Apollo, NetSuite, Marketo, Pardot, Zendesk, Intercom, Asana, Monday, ClickUp, Jira, Notion, Airtable, Workday, BambooHR, Gusto, QuickBooks, Xero — anyone with hundreds or thousands of public Capterra reviews — this is a defensible, repeatable lead source the rest of your stack can't see.

---

### Why this works (the intent thesis)

In B2B, the highest-intent signal isn't "visited your pricing page." It's **"publicly told a search engine that your competitor's product is failing them."**

- A 5⭐ Capterra review is noise — happy customers don't switch.
- A 4⭐ review is mixed — usually a feature request, not a budget signal.
- **A 1-3⭐ review is a buyer-side declaration of dissatisfaction.** It's a person who has already (a) felt enough pain to write 200+ words about it on a public site, (b) self-identified their role and company, and (c) in many cases, explicitly used the word "looking for an alternative."

These are the warmest cold leads in B2B SaaS. They cost zero to source — Capterra is a public website. The only reason every SDR team isn't already doing this manually is that copy-pasting from Capterra into a CRM scales to about 20 leads/day per rep before everyone wants to quit. This actor does it at machine speed.

---

### The intent score formula (audit it yourself)

Buyers should never trust a black-box score. Ours is fully transparent.

````

base       = (6 - rating) \* 15        ## 1★=75, 2★=60, 3★=45
phrases   += min(20, 5 \* num\_phrase\_hits)
recency   += 10 if published <= 30 days else 5 if <= 90 days else 0
recommend += 10 if wouldRecommend == False
intentScore = min(100, base + phrases + recency + recommend)

````

Phrase list: `switching`, `switched`, `looking for alternative`, `alternatives`, `considering`, `evaluating`, `moving away`, `migrating`, `migration`, `frustrated`, `expensive`, `overpriced`, `cancelled`, `replace`, `replacing`, `leaving`.

A 1⭐ review with "we're looking for an alternative, the cost is too expensive" published yesterday with `wouldRecommend=false` scores: 75 + 10 + 10 + 10 = **105 → capped at 100**.

A 3⭐ review with no phrase hits, published 6 months ago, with `wouldRecommend=true` scores: 45 + 0 + 0 + 0 = **45**.

Use intentScore ≥ 70 as your "drop everything and call them today" threshold. Use 50-69 for sequence enrollment.

---

### Use cases (and why each one works)

1. **Salesforce displacement campaign for a HubSpot AE team.** Input `["salesforce-com", "salesforce-sales-cloud"]`, `maxRating=3`, `enrichToLinkedIn=true`. Output: a Salesforce-frustration leaderboard with verified emails. Topline pitch: "I saw your Capterra review about Salesforce being too complex for your team — we built HubSpot Sales Hub specifically for this." 8-12% reply rates in pilot tests vs 1-3% on cold lists.

2. **Outreach.io / Salesloft displacement for an Apollo AE.** Mine `["outreach-io", "salesloft"]` with `industryFilter=["Software","Information Technology"]`. Reviewers whose cons mention "pricing," "complex setup," or "support" are your direct ICP.

3. **Niche-SaaS battle cards.** For a vertical SaaS (Toast vs Square for restaurants, Procore vs Buildertrend for construction), mine the incumbent's industry-filtered reviews. You'll get a self-curated competitive intel report **plus** the leads.

4. **CSM churn-prevention research.** If you sell a product *adjacent* to one with growing 1-2⭐ reviews, the reviewer pool tells you what's about to be in market. Build a "switching-signal" alert via Apify scheduler running this actor weekly.

5. **VC due diligence on dissatisfaction signal.** Pre-investment, mine the target's largest competitors. A category with rising 1-2⭐ volume signals an open-window for displacement plays.

---

### Honest limits

- **Capterra anonymizes some reviewers** — about 15-25% will appear with just a first name and an initial. You'll still get role + company-size + industry, which is enough to hand-trace.
- **Company name is sometimes generic** — "Mid-size SaaS" or "Hospital & Health Care, 1,001-5,000 employees" appears when the reviewer opted out of naming their employer. Use `requireVerifiedReviewer=true` to reduce this; expect ~60-75% to have a usable company string.
- **LinkedIn / email enrichment success rate: ~60-70%** when company name is real (not generic). For anonymized reviewers we skip enrichment to avoid wasted spend.
- **Capterra rate-limits aggressive crawlers** — the actor uses Apify residential proxy. Per-competitor budgets above ~100 leads/run may take 2-4 min and partial-fail; rerun with a different slug or wait an hour.
- **Compliance:** All data is public. CAN-SPAM-compliant cold outreach is your responsibility — include unsubscribe + business identification. GDPR Article 14 (data-subject information notice) applies if reviewer is in the EU; include source attribution ("via Capterra review") in your sequence.

---

### Input schema

| Field | Type | Default | Description |
|---|---|---|---|
| `competitorCapterraSlugs` | string[] | **required** | Capterra product slugs, e.g. `["salesforce-com","hubspot-sales-hub"]` |
| `maxRating` | int 1-5 | `3` | Keep reviewers with rating ≤ this |
| `maxLeadsPerCompetitor` | int 1-500 | `50` | Per-slug emit cap |
| `requireVerifiedReviewer` | bool | `true` | Only Capterra "verified" reviews |
| `enrichToLinkedIn` | bool | `false` | Pipe each lead through `lead-list-enricher` |
| `industryFilter` | string[] | `[]` | Keep only matching industries (substring) |
| `companySizeBuckets` | string[] | `[]` | Keep only matching size labels |

---

### Output schema (one item per lead)

```json
{
  "leadId": "a91c2f3e8d4b1c5e7a90",
  "competitorProduct": "salesforce-com",
  "reviewRating": 2,
  "reviewTitle": "Powerful but painful — looking for alternatives",
  "reviewPros": "Customisable and powerful when configured...",
  "reviewCons": "Expensive, slow, the UI is dated, and our team is frustrated. We are evaluating HubSpot.",
  "wouldRecommend": false,
  "reviewerName": "Sarah K.",
  "reviewerRole": "Director of Sales Operations",
  "reviewerCompanyName": "Mid-size SaaS",
  "reviewerCompanyIndustry": "Computer Software",
  "reviewerCompanySize": "201-500 employees",
  "reviewerCompanyCountry": "United States",
  "verified": true,
  "painSummary": "Expensive, slow, the UI is dated, and our team is frustrated. We are evaluating HubSpot.",
  "intentScore": 90,
  "enriched": {
    "linkedinUrl": null,
    "email": null,
    "confidence": 0
  },
  "publishedAt": "2025-09-14T00:00:00Z",
  "scrapedAt": "2026-05-16T14:00:00Z"
}
````

***

### JSON input examples

#### 1. Salesforce displacement (3-product mine)

```json
{
  "competitorCapterraSlugs": ["salesforce-com", "salesforce-sales-cloud", "salesforce-essentials"],
  "maxRating": 3,
  "maxLeadsPerCompetitor": 100,
  "requireVerifiedReviewer": true,
  "enrichToLinkedIn": false
}
```

#### 2. Outreach.io displacement (industry-filtered, enriched)

```json
{
  "competitorCapterraSlugs": ["outreach-io"],
  "maxRating": 3,
  "maxLeadsPerCompetitor": 50,
  "requireVerifiedReviewer": true,
  "industryFilter": ["Computer Software", "Information Technology"],
  "companySizeBuckets": ["50-200 employees", "201-500 employees"],
  "enrichToLinkedIn": true
}
```

#### 3. Bulk enrich a mid-market HubSpot displacement list

```json
{
  "competitorCapterraSlugs": ["hubspot-sales-hub", "hubspot-marketing-hub", "hubspot-crm"],
  "maxRating": 2,
  "maxLeadsPerCompetitor": 200,
  "requireVerifiedReviewer": true,
  "companySizeBuckets": ["201-500 employees", "501-1,000 employees", "1,001-5,000 employees"],
  "enrichToLinkedIn": true
}
```

***

### Run via Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("nexgendata/capterra-displacement-leads").call(run_input={
    "competitorCapterraSlugs": ["salesforce-com"],
    "maxRating": 3,
    "maxLeadsPerCompetitor": 50,
    "enrichToLinkedIn": True
})
for lead in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(lead["reviewerRole"], "@", lead["reviewerCompanyName"], "→", lead["intentScore"])
```

### Run via cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~capterra-displacement-leads/run-sync-get-dataset-items?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"competitorCapterraSlugs":["salesforce-com"],"maxRating":3,"maxLeadsPerCompetitor":25}'
```

***

### FAQ

**Q: Why not also Trustpilot or G2?**
A: Trustpilot exposes only a username + country — no employer, no role, so the reviewer isn't an SDR-targetable lead. G2 is currently Cloudflare-blocked for programmatic access; we'll add G2 support when the surface stabilizes. Capterra is the only source today that gives role + employer + industry + company size in a single payload.

**Q: How fresh are the reviews?**
A: Capterra publishes reviews within hours of submission. The actor scrapes the live page, so freshness is real-time. Use `publishedAt` to filter for "last 30 days" cohorts; reviews in this window get a +10 intent boost.

**Q: How do you handle reviewer anonymization?**
A: We surface what Capterra exposes. If Capterra shows "Mid-size SaaS, Computer Software, 200-500 employees, US", we emit those four fields and skip enrichment (no domain to enrich). If Capterra shows "Acme Corp", we'll attempt domain derivation and enrichment. Roughly 60-75% of verified reviews include a usable company string.

**Q: What's your compliance / CAN-SPAM / GDPR posture?**
A: All input data is public. CAN-SPAM cold outreach is the buyer's responsibility (include unsubscribe + identification). For EU reviewers, comply with Article 14 by including source attribution in your sequence. We do not store any data — every run is stateless. We never bypass Capterra's robots.txt for protected sections.

**Q: Which other actor should I pair this with?**
A: `nexgendata/capterra-review-firehose` for ongoing monitoring (run weekly via Apify scheduler to catch new 1-2⭐ reviews as they land), and `nexgendata/lead-list-enricher` (already wired in via `enrichToLinkedIn`). For full ICP enrichment of the company side, pair with `nexgendata/company-enrichment-tool`.

**Q: What does a run cost?**
A: $0.05 per surfaced lead (PPE). 50 leads = $2.50. Enrichment is $0.20 per enriched lead — typically 60-70% of leads get enriched, so a 50-lead run with enrichment costs $2.50 + ~$7 = ~$9.50.

**Q: Coverage by industry?**
A: Strongest in: Software / SaaS, Marketing, Sales, HR Tech, Finance Tech, EdTech, Healthcare IT. Weaker in: hyper-vertical industrial software (Capterra has fewer reviews per product). For the latter, expect 5-20 leads/run vs 50-100 for mainstream SaaS competitors.

**Q: Can I run this on a schedule?**
A: Yes — use Apify Scheduler. Recommended cadence: weekly per competitor slug. Pair with deduplication on `leadId` in your CRM (the leadId is a deterministic hash of slug + reviewId, so re-runs won't create duplicates).

**Q: What happens if Capterra blocks the request?**
A: The actor uses Apify residential proxy. On rare anti-bot challenges, the run will emit a diagnostic item explaining the failure. Wait 30-60 min and retry, or rotate proxy group.

***

### Comparison: Apify-native vs incumbent intent platforms

| Tool | Annual cost | Intent source | Role/title | Pain context | Enrichment | GDPR-defensible |
|---|---|---|---|---|---|---|
| ZoomInfo Intent | $15K-30K | IP-based topic surge | No | No | Yes | Weak (3rd-party cookie based) |
| Bombora | $25K+ | Co-op publisher network surge | No | No | No | Weak |
| 6sense | $40K+ | Multi-source dark-funnel | No | No | Yes | Weak |
| Apollo Intent | $99-299/mo (~$1.2K-3.6K/yr) | Topic intent | Limited | No | Yes | Medium |
| Gartner / G2 Buyer Intent | $20K-50K | Profile-visit surge | No | No | No | Medium |
| **Capterra Displacement Leads (this actor)** | **PPE, $0.05/lead = ~$50/1K** | **Public 1-3⭐ review** | **Yes** | **Yes (verbatim quote)** | **Optional ($0.20/lead)** | **Strong (public data, source attribution)** |

The cost-per-actually-reachable-lead delta is the headline: ZoomInfo Intent at $15K/yr surfaces topic surges but no contact, no quote, no role; you still pay $0.10-0.30/contact for the actual lead. We give you contact + quote + role at $0.05/lead with no annual contract.

***

### Sister actors (NexGenData fleet)

- `nexgendata/capterra-review-firehose` — full-firehose mode for ongoing review monitoring (paired weekly schedule).
- `nexgendata/lead-list-enricher` — domain-to-contact enrichment used internally by `enrichToLinkedIn=true`.
- `nexgendata/b2b-leads-finder` — discovery actor for general B2B targeting outside the displacement angle.
- `nexgendata/hiring-signal-detector` — complementary intent signal (open roles for {your stack}).
- `nexgendata/company-enrichment-tool` — firmographic enrichment on the company side (revenue, funding, tech stack).

***

Don't have an Apify account? [Sign up free](https://www.apify.com/sign-up?fpr=2ayu9b) — $5 free credits to test this actor risk-free.

# Actor input Schema

## `competitorCapterraSlugs` (type: `array`):

Capterra product slugs (the path segment after /p/) for the competitors you want to mine for unhappy reviewers. Find these by visiting the competitor's Capterra listing — e.g. capterra.com/p/salesforce-com gives slug 'salesforce-com'.

## `maxRating` (type: `integer`):

Only mine reviewers who left this many stars or fewer (1-5). Default 3 keeps only unhappy reviewers — the high-intent buyer signal.

## `maxLeadsPerCompetitor` (type: `integer`):

Max number of qualifying leads to surface per competitor product slug.

## `requireVerifiedReviewer` (type: `boolean`):

When true, only emits leads from Capterra-verified reviewers (LinkedIn or screenshot verified). Reduces fake-account / vendor-incentive noise.

## `enrichToLinkedIn` (type: `boolean`):

When true, pipes each lead through nexgendata/lead-list-enricher to look up the reviewer's company domain and find verified emails. Extra charge per enriched lead.

## `industryFilter` (type: `array`):

Optional list of Capterra industry names to keep (case-insensitive substring match). E.g. \['Software','Information Technology','Marketing'].

## `companySizeBuckets` (type: `array`):

Optional list of Capterra company-size labels to keep (exact or substring match). E.g. \['50-200 employees','200-500 employees','500-1,000 employees'].

## Actor input object example

```json
{
  "competitorCapterraSlugs": [
    "salesforce-com",
    "hubspot-sales-hub",
    "outreach-io"
  ],
  "maxRating": 3,
  "maxLeadsPerCompetitor": 50,
  "requireVerifiedReviewer": true,
  "enrichToLinkedIn": false,
  "industryFilter": [],
  "companySizeBuckets": []
}
```

# 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 = {
    "competitorCapterraSlugs": [
        "salesforce-com",
        "hubspot-sales-hub",
        "outreach-io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/capterra-displacement-leads").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "competitorCapterraSlugs": [
        "salesforce-com",
        "hubspot-sales-hub",
        "outreach-io",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/capterra-displacement-leads").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "competitorCapterraSlugs": [
    "salesforce-com",
    "hubspot-sales-hub",
    "outreach-io"
  ]
}' |
apify call nexgendata/capterra-displacement-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🎯 Capterra Displacement Leads",
        "description": "Mine 1-3 star reviewers on competitor Capterra listings and turn them into structured SDR leads with role, company, pain quote, intent score, and optional LinkedIn enrichment. Public-data, GDPR-defensible alternative to ZoomInfo Intent / Bombora / 6sense — pay per surfaced lead.",
        "version": "0.0",
        "x-build-id": "yZSd2rGydgGdfCrRM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~capterra-displacement-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-capterra-displacement-leads",
                "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/nexgendata~capterra-displacement-leads/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-capterra-displacement-leads",
                "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/nexgendata~capterra-displacement-leads/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-capterra-displacement-leads",
                "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": [
                    "competitorCapterraSlugs"
                ],
                "properties": {
                    "competitorCapterraSlugs": {
                        "title": "Competitor Capterra Slugs",
                        "type": "array",
                        "description": "Capterra product slugs (the path segment after /p/) for the competitors you want to mine for unhappy reviewers. Find these by visiting the competitor's Capterra listing — e.g. capterra.com/p/salesforce-com gives slug 'salesforce-com'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRating": {
                        "title": "Max Rating Threshold",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only mine reviewers who left this many stars or fewer (1-5). Default 3 keeps only unhappy reviewers — the high-intent buyer signal.",
                        "default": 3
                    },
                    "maxLeadsPerCompetitor": {
                        "title": "Max Leads Per Competitor",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Max number of qualifying leads to surface per competitor product slug.",
                        "default": 50
                    },
                    "requireVerifiedReviewer": {
                        "title": "Verified Reviewers Only",
                        "type": "boolean",
                        "description": "When true, only emits leads from Capterra-verified reviewers (LinkedIn or screenshot verified). Reduces fake-account / vendor-incentive noise.",
                        "default": true
                    },
                    "enrichToLinkedIn": {
                        "title": "Enrich with LinkedIn + Email",
                        "type": "boolean",
                        "description": "When true, pipes each lead through nexgendata/lead-list-enricher to look up the reviewer's company domain and find verified emails. Extra charge per enriched lead.",
                        "default": false
                    },
                    "industryFilter": {
                        "title": "Industry Filter",
                        "type": "array",
                        "description": "Optional list of Capterra industry names to keep (case-insensitive substring match). E.g. ['Software','Information Technology','Marketing'].",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySizeBuckets": {
                        "title": "Company Size Buckets",
                        "type": "array",
                        "description": "Optional list of Capterra company-size labels to keep (exact or substring match). E.g. ['50-200 employees','200-500 employees','500-1,000 employees'].",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
