# Lead Generation: B2B Leads, Verified Emails & Buying Signals (`openclawai/b2b-leads-finder`) Actor

Sales leads, B2B leads finder and email finder: describe your buyer in one sentence, get decision makers with verified work emails, phones and buying signals. Live data from 30+ sources, each lead scored by AI against your ideal customer. Pay per result.

- **URL**: https://apify.com/openclawai/b2b-leads-finder.md
- **Developed by:** [Pika Choo](https://apify.com/openclawai) (community)
- **Categories:** Lead generation, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $16.00 / 1,000 verified work emails

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

## Lead Generation: B2B Leads with Verified Emails & Buying Signals

**A B2B lead generation tool, sales leads finder and email finder that starts from one sentence.** This B2B leads finder turns "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees" into sales leads: decision makers at the right companies, each with a work email verified during your run at the company they work for now, an AI fit score, a buying role and buying signals. It is also an email finder, a waterfall enrichment tool and a lookalike company search, with live data from 30+ sources instead of a static database. You pay per result.

Use it as a **sales leads** generator, an **email finder** for verified work emails, a phone number finder, and for target account lists (account-based marketing), similar companies to your best customers, finding and verifying work emails for your own list (a Clay alternative), and local business leads from maps and directories. AI agents need one field: `prompt`.

### Why this leads finder

- ✅ **Verified at the right company, or not sold.** Every email is verified during your run and must belong to the company the person works for now. Former-employer addresses and unresolved catch-all guesses are dropped and never charged.
- ✍️ **One sentence in.** Write your buyer the way you would brief a sales researcher. The run turns it into a search plan (titles, industries, size, country, tools, hiring) and shows that plan in its summary.
- 🎯 **AI fit score and buying role.** Each lead gets a 0-100 fit score against your ideal customer, a label (ideal, good, weak, not a fit), the reason, and a buying role: decision maker, champion, technical evaluator or end user. Leads below your minimum score are dropped before any contact lookup, so you never pay for them.
- 🔥 **Buying signals and intent data, with a date and a source link.** A free scan of each company's careers feed and newsroom: open roles with their posting dates (and which match the roles you sell to), funding, new executives, acquisitions and launches, plus tech stack and ad tracking. The intent score (hot, warm, cold) counts only events from the last 90 days, and a "why now" line quotes the strongest one.
- 👥 **A buying committee per company.** Up to 5 people per account, each labeled with a buying role.
- 🔁 **Watch mode.** Schedule it weekly and get only the people earlier runs did not deliver.
- 📤 **Delivered where you work.** Straight into **HubSpot** (contacts created or updated by email), a webhook for any other CRM, Zapier, Make or n8n, a Slack summary, CSV, Excel or JSON export, the Apify API and MCP.
- 💸 **Pay per result.** No subscription and no platform usage fee. Leads that miss your fit score or fail verification cost nothing. The free Apify plan gets a preview of up to 3 leads per day.

### Measured, not promised

From our test runs in November 2026. The samples are small; these are the numbers we measured, not targets.

- One sentence, "Heads of RevOps at US B2B SaaS companies with 50-500 employees": **10 of 10** delivered leads had a verified work email and were on target.
- A second data source re-checked 9 leads delivered by two Describe runs: **9 of 9** people still worked at the stated company, and **9 of 9** emails were at that company's domain.
- Every run saves its funnel (see [Run summary](#run-summary)), so you can see what was dropped and why.

### What you get

One row per lead. These example rows use made-up people and companies:

| Name | Job title | Buying role | Company | Employees | Email | Email status | Fit | Intent | Why now |
|---|---|---|---|---|---|---|---|---|---|
| Jordan Example | Head of Revenue Operations | Champion | Brightloop | 180 | jordan.example@brightloop.example | valid | 96 | hot | Hiring 2 SDR roles (newest Nov 10) |
| Priya Sample | VP Sales | Decision maker | Cobalt Ledger | 420 | priya.sample@cobaltledger.example | valid | 88 | hot | Raised funding (Oct 28): "Cobalt Ledger raises $30M Series B" |
| Sam Demo | Director of Revenue Operations | Champion | Harbor Metrics | 95 | sam@harbormetrics.example | valid | 71 | warm | Hiring a leader: VP, Marketing (posted Nov 3) |

Every row has the same columns, ready for a CRM or a spreadsheet (`signals` and `company_tech` are lists). A full example row:

```json
{
  "full_name": "Jordan Example",
  "first_name": "Jordan",
  "last_name": "Example",
  "job_title": "Head of Revenue Operations",
  "buying_role": "Champion",
  "linkedin_url": "https://www.linkedin.com/in/jordan-example-0000",
  "location": "Austin, Texas, United States",
  "email": "jordan.example@brightloop.example",
  "email_status": "valid",
  "email_type": "person",
  "email_source": null,
  "phone": null,
  "phone_status": null,
  "company_name": "Brightloop",
  "company_domain": "brightloop.example",
  "company_linkedin_url": "https://www.linkedin.com/company/brightloop-example",
  "company_industry": "Software Development",
  "company_size": 180,
  "company_description": "Billing software for subscription businesses.",
  "company_location": "Austin, Texas, United States",
  "company_phone": null,
  "company_tech": ["HubSpot", "Google Tag Manager", "Google Analytics"],
  "fit_score": 96,
  "fit_label": "ideal",
  "fit_reason": "Role, seniority, company type, size and place all match the ideal customer",
  "fit_confidence": 0.91,
  "intent_score": "hot",
  "why_now": "Hiring 2 SDR roles (newest Nov 10): Sales Development Representative; SDR, EMEA",
  "signals": [
    {"type": "hiring_target_role", "detail": "Hiring 2 SDR roles (newest Nov 10): Sales Development Representative; SDR, EMEA", "date": "2026-11-10", "url": "https://brightloop.example/careers/sdr-emea"},
    {"type": "uses_technology", "detail": "Uses HubSpot (seen on its website)", "date": null, "url": "https://brightloop.example"}
  ],
  "ai_opener": null,
  "found_via": "people search",
  "mode": "describe",
  "search_input": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
  "scraped_at": "2026-11-18T10:42:07+00:00"
}
```

When a run cannot deliver what you asked for, it adds a free notice row (`type` and `error_message`) that says why and what to change, instead of leaving you with an empty table.

#### Run summary

Each run also saves a summary record named `OUTPUT` in its key-value store. This one comes from a real 5-lead test run of the default sentence (November 2026). 53 candidates were found, 10 fit the brief, 8 had a verified work email, and 1 address belonged to a former employer and was dropped:

```json
{
  "mode": "describe",
  "search_input": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
  "search_plan": {
    "titles": ["Head of Revenue Operations", "Chief Revenue Officer", "VP Sales", "Director of Revenue Operations"],
    "people_query": "Heads of Revenue Operations in B2B SaaS companies with 50-500 employees in the United States",
    "industries": ["Software Development", "Information Technology & Services"],
    "country": "US",
    "employees_min": 50,
    "employees_max": 500
  },
  "funnel": {
    "people_found": 54,
    "companies_found": 0,
    "candidates": 53,
    "qualified_by_ai": 10,
    "below_fit_score": 0,
    "emails_found": 9,
    "emails_valid": 8,
    "emails_risky": 1,
    "emails_invalid": 0,
    "phones_found": 0,
    "skipped_already_delivered": 0,
    "suppressed": 0,
    "emails_at_other_company": 1,
    "no_verified_email": 2,
    "over_people_per_company": 0,
    "delivered": 5
  },
  "billed_usd": 0.05,
  "seconds": 92
}
```

### How to use it

Pick a mode in the input form, or send JSON through the API. Every mode runs the same pipeline: company data, buying signals, AI fit score, email waterfall, verification, then the optional phone and first line.

#### 1. Describe your buyer in one sentence (default)

```json
{
  "prompt": "VP Sales at US fintech companies with 50-500 employees using HubSpot, hiring SDRs",
  "maxLeads": 50
}
```

`mode` defaults to `describe`. Name the role, company type, size, country, tools and the roles they are hiring for. Anything you leave out is simply not used as a filter.

#### 2. Filters

```json
{
  "mode": "icp_search",
  "titles": ["Head of Marketing", "VP Marketing"],
  "industries": ["Computer Software"],
  "technologies": ["HubSpot"],
  "companySizeMin": 50,
  "companySizeMax": 1000,
  "country": "US",
  "maxLeads": 100
}
```

#### 3. Target companies (account-based marketing)

```json
{
  "mode": "companies",
  "companies": ["stripe.com", "notion.so", "https://www.linkedin.com/company/figma"],
  "titles": ["Head of Revenue Operations", "VP Sales"],
  "leadsPerCompany": 3
}
```

Websites or LinkedIn company URLs work best; a bare name can match the wrong company. Without `titles`, the actor looks for decision makers (founders, C-level, VPs, heads and directors).

#### 4. Lookalikes of your best customers

```json
{
  "mode": "lookalike",
  "seedCompanies": ["your-best-customer-1.com", "your-best-customer-2.com", "your-best-customer-3.com"],
  "prompt": "Heads of Sales at companies like our best customers",
  "maxLeads": 50
}
```

Lookalike companies are scored by AI for how alike they are to your seeds before any contact lookup.

#### 5. Your own list: email finder and waterfall enrichment

```json
{
  "mode": "enrich_list",
  "people": [
    {"full_name": "Jane Doe", "company_domain": "example.com"},
    {"first_name": "John", "last_name": "Roe", "company_domain": "example.org", "linkedin_url": "https://www.linkedin.com/in/john-roe-0000"}
  ],
  "findPhones": true
}
```

Find the email address of each person on your list: give a name and their company website, and add a LinkedIn URL when you have one. Each row also gets company enrichment (industry, size, location, LinkedIn page, tech stack). You can also pass `datasetId` to enrich the people in another Apify run's dataset. Add a `prompt` describing your ideal customer if you want AI fit scores too.

You can paste companies too (a website, a name or a LinkedIn company URL). Every row comes back, with a `match_status`: `matched`, `changed_company` (the profile shows a new employer: the row follows the person there and finds the email at the new company), `left_company` (no current job: never looked up at the old company), `partial`, `not_found` (not charged) or `suppressed` (your exclusion lists; not charged). Your own fields, such as a CRM id, come back in `input_row`.

#### Pick your columns and add AI columns

```json
{
  "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
  "maxLeads": 25,
  "columns": ["career", "company_deep", "socials", "signals"],
  "aiColumns": [
    {"name": "Sells to developers", "question": "Does the company sell to software developers?", "type": "yes_no"},
    {"name": "Segment", "question": "Which customer segment does the company mainly serve?", "type": "choice", "choices": "SMB, Mid-market, Enterprise"}
  ]
}
```

The column groups are free and come from data each lead already has: career (seniority, department, in role since, previous companies, education), company details (employee range, founded, revenue range, funding), company social profiles and signal columns (new in role, signals in the last 90 days). A value is empty when it is unknown, never guessed. AI columns answer your own questions (yes/no, a score, one of your choices, or a short text) from each lead's facts only; a text answer the facts do not support is left empty, and empty answers are not charged.

#### 6. Local businesses

```json
{
  "mode": "local_business",
  "localQueries": ["dentist"],
  "localLocations": ["Austin, TX"],
  "localSources": ["google_maps", "yelp"],
  "maxLeads": 25
}
```

Each business is a lead: its listing data plus the email it publishes on its own website, verified.

#### Weekly feed of new leads

```json
{
  "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
  "maxLeads": 50,
  "watch": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
}
```

Save this as a task, add a weekly schedule in Apify Console, and each run returns only people that earlier runs with the same settings did not deliver. Add `webhookUrl` to send every batch of leads to your CRM, Zapier, Make or n8n.

#### API and AI agents

```bash
curl -X POST "https://api.apify.com/v2/acts/openclawai~b2b-leads-finder/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees", "maxLeads": 10}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("openclawai/b2b-leads-finder").call(run_input={
    "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
    "maxLeads": 10,
})
for lead in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(lead.get("full_name"), lead.get("email"), lead.get("fit_score"), lead.get("why_now"))
```

The synchronous endpoint waits up to 5 minutes; for bigger runs, start the run and read the dataset when it finishes. AI agents (Claude, ChatGPT, Cursor and other MCP clients) can find and run this actor through the Apify MCP server at `https://mcp.apify.com`: the agent only needs `prompt`, plus `maxLeads` and a maximum cost per run.

### Pricing

Pay per event. You pay only for what is delivered:

| Event | Price | You pay when |
|---|---|---|
| Lead with company data and AI fit score | $0.005 | a lead passes your minimum fit score and is delivered |
| Verified work email | $0.020 | the email passed verification during the run (never for catch-all guesses or former-employer addresses) |
| Phone number | $0.03 | you turned phones on and a number was found |
| AI-written first line | $0.01 | you turned first lines on and one was written |
| Deep buying signal | $0.04 | you turned deep signals on and the news check found a new event from the last 90 days (once per company) |
| AI column answer | $0.002 | you added AI columns and a question was answered for a delivered lead (per answer; empty answers are free) |
| Local business | $0.004 | local businesses mode: a business passes your brief and is delivered |
| Verified business email | $0.006 | local businesses mode: the business's own email passed verification |

- 100 leads with verified work emails: 100 × ($0.005 + $0.020) = **$2.50**. 1,000 leads: **$25**.
- 100 local businesses with a verified email: 100 × ($0.004 + $0.006) = **$1.00**.
- Higher Apify plans pay less per event (tiered prices: up to about 30% off on the top plans).
- Phones, first lines, deep signals and AI column answers cost something only when they are found or written.
- No start fee, no subscription and no platform usage charges. Notice rows are free.
- Set a **maximum cost per run** (at least $0.05) and the actor sizes its search to fit it.
- **Free Apify plan:** the run returns 3 labeled example rows that show every column. Live leads need a paid Apify plan (any paid plan; you pay only per result).

### How it compares

| | Static lead databases | Clay | This actor |
|---|---|---|---|
| Where the data comes from | A stored copy, refreshed from time to time | The providers you connect and the steps you build | Looked up live during your run: 30+ sources in one waterfall |
| When emails are checked | When the record was collected or exported | Depends on the verification step you add | During your run; the address must belong to the person's current company |
| Former-employer emails | Can slip through after job changes | Depends on your setup | Dropped and never charged |
| Who fits your buyer | Filters | AI columns you write | AI fit score, label, reason and buying role on each lead |
| Buying signals | Rarely included | Through enrichments you add | Dated hiring, funding and news, tech and ads, with a hot, warm or cold intent score |
| Setup | Pick filters | Build a table and a waterfall | One sentence or one API call |
| Pricing | Per row or credits | Subscription plus credits | Per result, no subscription |

Choose a static database when you need very large lists at the lowest price per row and can live with some bounces. Choose Clay when you want a spreadsheet to build your own multi-step workflows. Choose this actor when every email has to be right and you want the leads ranked for you.

### FAQ

#### How fresh is the data?

Every lead is looked up during your run: the person, the company data, the email and the signals. Nothing is served from a stored copy of old results, and every row carries `scraped_at`.

#### How are emails verified? What does "catch-all" mean?

Each work email is found through a waterfall of sources and then checked by a separate verification step. Some mail servers accept every address ("catch-all"), so a basic check cannot tell a real mailbox from a guess. Those addresses get a dedicated catch-all check, and only addresses confirmed valid count. `email_status` is `valid`, `risky` (an unresolved catch-all), `invalid` (the address is removed) or `unverified`. With "Only leads with a verified work email" on (the default), you only get `valid` emails.

#### What about people who changed jobs?

The email must belong to the company the lead works for now. An address at a former employer is dropped, and the run summary counts it as `emails_at_other_company`. Shared inboxes such as info@ or sales@ never count as a person's email.

#### Which countries and companies work best?

Any country. Coverage is best for companies with a real web presence; very small or offline businesses have fewer reachable contacts, so use the Local businesses mode for them. Country guides the search and the AI fit score but is not a hard filter on every source: for stricter matches, raise the minimum fit score, for example to 75.

#### Can I use it in the EU and UK? Is it GDPR compliant?

You decide how the leads are used, so you are the controller of that data. B2B outreach in the EU and UK usually relies on legitimate interest (GDPR Art. 6(1)(f)): document a legitimate-interest assessment, tell people where you got their data at the latest in your first message (Art. 14), honor objections and opt-outs at once, and follow the email-marketing rules where you send (ePrivacy rules in the EU, which differ by country; PECR in the UK, which treats sole traders like consumers; CAN-SPAM in the US). The actor helps: by default it returns work contacts only (a work email at the person's company, or the address a business publishes on its own website) and no phone numbers until you turn them on, and it has suppression lists (`excludeDomains`, `excludeEmails`). This is not legal advice.

#### How do I exclude customers and do-not-contact people?

Put customer, competitor and partner domains in `excludeDomains`, and opt-outs or bounced addresses in `excludeEmails`. They are never returned. Watch mode keeps earlier leads out of new runs.

#### Does it log in to LinkedIn or use cookies?

No. There are no logins, no cookies and nothing to connect. The data comes from 30+ live data sources and from companies' own public websites. LinkedIn URLs are accepted as input and returned as identifiers.

#### What does the AI fit score mean?

It is a 0-100 match between the lead and your ideal customer: role, seniority, company type, size and place. A clear "good" fit scores about 67, an "ideal" fit 100 and a "weak" one about 33. `fit_reason` explains the score. It comes from an AI scoring model; if the model is unavailable, a rule-based estimate is used and the reason starts with "Estimated". The default minimum score is 60, which keeps good and ideal fits.

#### Why did I get fewer leads than I asked for?

Leads that miss your fit score, have no verified work email at their current company, or were delivered by an earlier watch run are dropped and cost nothing. The run summary shows the funnel, and a notice row says what to change: a lower minimum fit score, broader titles, a bigger size range, or "Only leads with a verified work email" turned off. A run also stops early, with a notice, when the leads it finds cost more to look up than they earn; the leads already found are still delivered.

#### How long does a run take?

Each lead is looked up live, so runs take minutes, not seconds. In our tests, Describe runs of up to 6 leads took about 1 to 3.5 minutes, and runs on a short company list were faster. A run that reaches its time limit stops cleanly and keeps the leads it already delivered.

#### Can I send leads to my CRM?

Yes: paste a HubSpot private app token (`hubspotToken`) and every lead with a verified email is created or updated in your HubSpot contacts. Or export CSV, Excel or JSON, POST each batch to a webhook (`webhookUrl`) for any other CRM, Zapier, Make or n8n, get a Slack summary, or read the dataset through the API. The columns are flat and named for CRM import.

### Limits, honestly

- **Fewer leads than a database export.** Strict verification drops people without a verified email at their current company (common at companies whose mail servers accept every address), and leads below your fit score.
- **Country and keywords are guides, not hard filters on every source.** Company size is enforced whenever the size is known.
- **Company headquarters city** comes from public profiles and is sometimes out of date; treat it as a hint.
- **Phone numbers** are found for some leads only, and charged only when found.
- **Buying signals depend on what companies publish.** Some careers sites show no posting dates, so those companies get no hiring signal rather than a wrong one.
- **Local businesses** need a website with a published email. With "Only leads with a verified work email" on, businesses without a website are skipped before any paid lookup, and the email can be a general business address rather than a named person.
- **AI scoring is a model** and can be wrong, so every lead carries its reason.
- **Live lookups take time.** Give very large runs a longer timeout.
- **The free plan** shows 3 labeled example rows; live leads need a paid Apify plan.

### Support

A question, or a lead that looks wrong? Open an issue on the Issues tab with the run ID. We read every issue.

# Actor input Schema

## `mode` (type: `string`):

Describe (default) = one sentence in the next field: the easiest way, and the only field an AI agent needs. Filters = job titles, industries, technologies. Target companies = your account list (websites, names or LinkedIn company URLs). Lookalikes = companies like your best customers. Your own list = paste people or companies (or a dataset ID), pick columns and AI columns, get every row back filled. Local businesses = businesses from maps and directories.

## `prompt` (type: `string`):

Brief it like a sales researcher: role, company type, size, country, tools they use, roles they are hiring for. Example: 'VP Sales at US fintech companies with 50-500 employees using HubSpot, hiring SDRs'. The run summary shows the search plan built from it. In the other modes this sentence is optional and tells the AI fit score who your ideal customer is.

## `maxLeads` (type: `integer`):

Leads to deliver. You pay only for delivered leads; the run stops at this number or at the run's maximum cost, whichever comes first. Every lead is looked up live, so expect a few minutes for small runs.

## `onlyWithEmail` (type: `boolean`):

On (recommended): every delivered lead has a work email that passed verification during this run and belongs to the lead's current company. Former-employer addresses and unresolved catch-all guesses are dropped, never sold. Off: leads without a verified email are delivered too, at the lead price only (email empty, or marked risky or unverified). In the 'Your own list' mode every row still comes back (see match_status); this setting then keeps unverified addresses out of the email column.

## `findPhones` (type: `boolean`):

Adds a mobile or direct number when one is found; charged only when found. Off by default: work emails only. Phone numbers are personal data, so use them where you have a lawful basis to call.

## `scanWebsites` (type: `boolean`):

Scan each company's website, careers feed and newsroom: open roles with their posting dates (and which match your roles), funding, new executives, acquisitions, launches and deals with their dates and source links, plus tech stack and ad tracking. Adds an intent score (hot / warm / cold) from events of the last 90 days and a dated 'why now' line. Free.

## `hiringFor` (type: `array`):

Flag companies with open jobs for these roles, e.g. SDR, Account Executive, Data Engineer. Read from public careers pages with each role's posting date: roles posted in the last 90 days count toward intent. When this is empty, Describe mode uses the roles in your sentence ('hiring SDRs').

## `deepSignals` (type: `boolean`):

For each company you get leads from, also check recent news coverage (funding, new executives, acquisitions, expansion) and, when you list roles above and the company has no public careers feed, a jobs index. Every signal has a date and a source link. Charged once per company, only when it finds a new event from the last 90 days.

## `aiOpener` (type: `boolean`):

A personal opening line for a cold email, written from the lead's own facts and buying signals. Charged only when written.

## `offer` (type: `string`):

One or two sentences about your product. Added to your ideal customer for the AI fit score, and used to write first lines.

## `leadsPerCompany` (type: `integer`):

1 = the single best match per company. Up to 5 = a buying committee: decision maker, champion, technical evaluator and end users, each labeled with a buying role. Applies in every mode.

## `companies` (type: `array`):

One per line: stripe.com · Stripe · https://www.linkedin.com/company/stripe. Websites work best; a name alone can match the wrong company. In the 'Your own list' mode these are enriched as company rows.

## `seedCompanies` (type: `array`):

3-50 websites of customers you want more of, one per line.

## `people` (type: `array`):

A list of rows. People: any of full_name (or first_name + last_name), job_title, linkedin_url, email, company, company_domain. Companies: company_domain (website), company name or company_linkedin_url. We find and verify the work email, check that the person still works there (people who moved are followed to their new company), and add company data, the columns you pick and your AI columns. Your own fields (e.g. a CRM id) come back in input_row. Describe your ideal customer above to get AI fit scores too.

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

Enrich the rows of a dataset from another Apify Actor run: people or companies (fields like name, company, website, linkedin_url and email are read automatically).

## `localQueries` (type: `array`):

As you would type into Google Maps: dentist, roofing contractor, yoga studio.

## `localLocations` (type: `array`):

City + state or country, one per line: Austin, TX · Manchester, UK.

## `localSources` (type: `array`):

Pick several to catch businesses one directory misses; duplicates are merged.

## `localGuessEmails` (type: `boolean`):

When a business's website publishes no email, check whether its standard address (info@, office@, contact@ or hello@) exists at its own domain. Only an address the business's mail server confirms is kept, marked email_source = mail_server. Not used for chain or franchise locations, whose standard address belongs to the head office.

## `titles` (type: `array`):

One per line, as written on profiles: Head of Revenue Operations, VP Sales, CTO, Founder.

## `industries` (type: `array`):

Company industries, e.g. Computer Software, Financial Services.

## `technologies` (type: `array`):

Tools the companies use, e.g. HubSpot, Salesforce, Shopify. Also flagged as a buying signal when found on their website.

## `companySizeMin` (type: `integer`):

Leave empty for any size. Leads at companies known to be smaller are dropped (with a small tolerance).

## `companySizeMax` (type: `integer`):

Leave empty for any size. Leads at companies known to be bigger are dropped (with a small tolerance).

## `country` (type: `string`):

ISO code, e.g. US, GB (not UK), DE, FR. Leave empty for worldwide. Overrides the country in your Describe sentence. Location guides the search and the AI fit score; it is not a hard filter on every source.

## `locations` (type: `array`):

Spelled out, e.g. 'Greater London, United Kingdom', 'Austin, Texas'.

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

Skills or topics to narrow the people search, e.g. 'outbound', 'Salesforce admin'. Best effort: not every source supports keyword filters.

## `columns` (type: `array`):

Free column groups, all on by default. Phones and AI first lines stay separate options.

## `aiColumns` (type: `array`):

Up to 5 questions, answered for every delivered lead from that lead's own facts only (profile, company data, website signals). Each becomes a column ai\_<name> plus ai\_<name>\_confidence (0-1). Types: yes_no (yes or no), score (0-100), choice (one of your choices), text (a short answer, checked against the facts and left empty when they do not support it). Charged per answer given. Example: name 'Sells to developers', question 'Does the company sell to software developers?', type yes_no.

## `minFitScore` (type: `integer`):

Each lead is scored against your ideal customer (role, seniority, company type, size, place): a clear 'good' fit scores about 67, an 'ideal' fit 100, a 'weak' one about 33. Leads below this score are dropped before any contact lookup, so you never pay for them. 60 keeps good and ideal fits; raise it to 75 or more for near-ideal only; 0 keeps everyone.

## `aiQualification` (type: `boolean`):

Score each lead and label its buying role (decision maker, champion, technical evaluator, end user). In the 'Your own list' mode it runs only when you describe your ideal customer above.

## `qualityTier` (type: `string`):

How far down our list of 30+ sources each lookup may go. The price per verified email is the same; deeper finds more.

## `excludeDomains` (type: `array`):

Customers, competitors, partners: never return people from these domains (your suppression list).

## `excludeEmails` (type: `array`):

Never return these addresses: opt-outs, bounces, existing contacts.

## `watch` (type: `boolean`):

Remember who earlier runs with the same settings delivered and return only new people. Schedule the run weekly for a fresh feed of new leads. Not available on the free plan.

## `webhookUrl` (type: `string`):

Each batch of leads is POSTed here as JSON ({"leads": \[...], "run_id": "..."}) for your CRM, Zapier, Make or n8n.

## `slackWebhookUrl` (type: `string`):

Posts a short summary with the top 5 leads when the run ends.

## `hubspotToken` (type: `string`):

Push every lead with a verified email into your HubSpot contacts (created or updated by email, so re-runs never duplicate). Create a private app in HubSpot with the crm.objects.contacts.write scope and paste its access token here.

## `simulateFree` (type: `boolean`):

Developer-only switch.

## Actor input object example

```json
{
  "mode": "describe",
  "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
  "maxLeads": 3,
  "onlyWithEmail": true,
  "findPhones": false,
  "scanWebsites": true,
  "deepSignals": false,
  "aiOpener": false,
  "leadsPerCompany": 2,
  "people": [
    {
      "full_name": "Jane Doe",
      "company_domain": "example.com"
    }
  ],
  "localSources": [
    "google_maps"
  ],
  "localGuessEmails": true,
  "columns": [
    "career",
    "company_deep",
    "socials",
    "signals"
  ],
  "minFitScore": 60,
  "aiQualification": true,
  "qualityTier": "standard",
  "watch": false,
  "simulateFree": false
}
```

# Actor output Schema

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

No description

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

No description

# 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 = {
    "mode": "describe",
    "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
    "maxLeads": 3,
    "people": [
        {
            "full_name": "Jane Doe",
            "company_domain": "example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("openclawai/b2b-leads-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 = {
    "mode": "describe",
    "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
    "maxLeads": 3,
    "people": [{
            "full_name": "Jane Doe",
            "company_domain": "example.com",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("openclawai/b2b-leads-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 '{
  "mode": "describe",
  "prompt": "Heads of Revenue Operations at US B2B SaaS companies with 50-500 employees",
  "maxLeads": 3,
  "people": [
    {
      "full_name": "Jane Doe",
      "company_domain": "example.com"
    }
  ]
}' |
apify call openclawai/b2b-leads-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,openclawai/b2b-leads-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/qDlu1ov3tphMfq4GP/builds/Gsb8JUzAcYlmKinJ4/openapi.json
