# B2B Leads Finder — 13 Fields, Live Search, Sourced Emails (`themineworks/b2b-leads-finder`) Actor

Name any company and get its people: LinkedIn profiles, business emails and phones. Searched live at run time, not resold from a shared database, so it finds the small and regional companies Apollo-style lists never indexed. Every email labelled with how it was obtained.

- **URL**: https://apify.com/themineworks/b2b-leads-finder.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Lead generation, Business, MCP servers
- **Stats:** 113 total users, 57 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 b2b leads

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 📧 B2B Leads Finder: Any Company, Searched Live (Not a Database)

Name any company. Get its people: LinkedIn profiles, business emails and phone numbers, searched live at run time rather than pulled from a shared database. No API key, no login, no subscription. You are charged only for leads actually delivered.

✅ Works on companies no database indexes | ✅ No login or API key | ✅ Pay only for leads delivered | ✅ MCP-ready for AI agents

### Most "B2B lead" tools sell you the same list

Search the Store for lead generation and you will find a dozen actors at $1-3 per 1,000 leads. Read their descriptions and you will notice they resell the same 250M-record database. That has three consequences:

1. **Everyone gets identical contacts.** Your prospects are being emailed by every other buyer of every one of those tools. Your reply rates and domain reputation pay for it.
2. **They share one upstream, so they fail together.** Chronic downtime is normal in this category, to the point where several competitors currently advertise outage recovery in their own product titles.
3. **You cannot target a company that isn't indexed.** These tools filter a fixed dataset by industry, headcount and geography. If your target is a 20-person firm in Indore, it is probably not in there, and no filter will conjure it.

### What this actor does instead

You give it **company names or domains**. It searches at run time:

- Public LinkedIn profiles via Google, for the companies you actually named
- The company's own site (`/team`, `/about`, `/contact`, `/people`) for published emails and phone numbers
- Business email patterns, with the domain's MX records checked at request time

There is no fixed dataset, so there is no index gap. If the company has a web presence, it is a valid target. Coverage of small, regional, non-US and newly founded companies is the point, not an edge case.

### We tell you where every address came from

Competitors advertise "verified" emails. Ask what that means and it usually means the domain accepted the address, which a catch-all domain does for *any* address, right up until it bounces.

We do not make that claim. Every record carries `email_confidence` and `email_pattern` so you can judge each address yourself:

| `email_confidence` | meaning |
| --- | --- |
| `found` | published on the company's own website, and it exactly matches this person's name |
| `pattern_matched` | built using the address format we confirmed from other published addresses on that same domain |
| `guessed` | the domain's format could not be determined, so the most common convention was used |

`email_pattern` names the actual format used (`first.last`, `flast`, `firstlast`, and so on), so a `pattern_matched` address tells you *why* we believe it.

**How the format inference works.** While scraping the company's own site we collect any addresses published on its domain, then test those against the people we discovered. If the site publishes `j.smith@acme.com` and we found John Smith, the domain's format is `f.last`, and every other address we build for acme.com uses that format instead of a blind default.

**Set your expectations honestly:** many companies publish no staff addresses at all. Large tech firms in particular publish none. Those rows come back `guessed` and are labelled that way. Filter on `email_confidence` if you only want high-trust rows.

**What this is not.** An MX check confirms the domain accepts mail. It does not confirm the mailbox exists. Confirming a mailbox requires an SMTP probe on outbound port 25, which cloud platforms block and which risks the sender's IP reputation, so no actor running on this infrastructure can honestly promise it whatever its listing says. If you need mailbox-level verification, pipe this output into a dedicated verifier. We would rather tell you that than have you learn it from your bounce rate.

### Phone numbers

Where a number is available it comes from the company's own website and is labelled `phone_source: "company-website"`. It is a published company number, not a direct line for that individual, and we will not pretend otherwise.

Numbers are taken from `tel:` links and from properly formatted numbers in visible page text. Bare unformatted digit runs are rejected outright, because a digit run cannot be distinguished from an ID, a timestamp or a date. Expect fewer phone numbers than competitors quote, and expect the ones you get to be real.

### Freshness

Every record carries `retrieved_live: true` and a `scraped_at` timestamp from the run that produced it. Nothing is served from a cached dump refreshed on someone else's schedule.

### Billing

Charged per lead actually written to the dataset. Blocked runs, empty runs and failed lookups are never charged. There is no hidden actor-start fee.

### How it works

LinkedIn has no public people-search API, and the big B2B databases gate their data behind per-seat subscriptions, credit caps and export limits. B2B Leads Finder works only from public data: it reads public LinkedIn profiles that Google has already indexed, using `site:linkedin.com/in "company" "job title"` search queries. It never authenticates with LinkedIn and never touches LinkedIn's own servers.

For each person found it generates the most common business-email patterns and confirms the domain can receive mail with a DNS MX lookup. It also visits the company's own `/team`, `/about` and `/contact` pages to pull emails and phone numbers that are publicly listed there. No account, no cookies, no credit ceiling, no ban risk.

### 🧾 Input configuration

```json
{
  "companies": ["stripe.com", "notion.so"],
  "jobTitles": ["CEO", "Head of Marketing"],
  "maxLeadsPerCompany": 10,
  "scrapeWebsite": true,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["GOOGLE_SERP"] }
}
```

### 📤 Output format

```json
{
  "company": "Notion",
  "domain": "notion.so",
  "name": "Camille Ricketts",
  "job_title": "Head of Marketing at Notion",
  "linkedin_url": "https://www.linkedin.com/in/camille-ricketts-72a1a03",
  "email": "camille.ricketts@notion.so",
  "email_confidence": "guessed",
  "email_pattern": "first.last",
  "phone": null,
  "source": "linkedin-serp",
  "retrieved_live": true,
  "scraped_at": "2026-07-19T09:42:11.204Z"
}
```

Every lead record contains these fields:

| Field | Description |
| --- | --- |
| 🏢 `company` | Company name |
| 🌐 `domain` | Company domain (e.g. stripe.com) |
| 🙋 `name` | Full name of the person |
| 💼 `job_title` | Job title or LinkedIn headline |
| 🔗 `linkedin_url` | Public LinkedIn profile URL |
| 📧 `email` | Business email |
| 🎯 `email_confidence` | `found`, `pattern_matched` or `guessed` — how the address was obtained |
| 🔤 `email_pattern` | The address format used (`first.last`, `flast`, …) |
| 📞 `phone` | Phone number published on the company website |
| 📍 `phone_source` | `company-website` — a company number, not a direct line |
| 🧭 `source` | `linkedin-serp` or `website-scrape` |
| 🕒 `retrieved_live` | Always `true` — retrieved during this run, not from a cache |
| 🕒 `scraped_at` | ISO timestamp of when the record was captured |

**One more row at the end of every run:** every run also ends with a final `_type: "info"` record — informational only, never billed — with a two-line nudge: how to put this actor on an automatic schedule (see "Run on a schedule" below), and a link to leave a Store review if it saved you time.

### 💼 Common use cases

**Sales & outbound prospecting**
Build a list of decision-makers at your target accounts and load it straight into your sequencer.
Reach the small and regional accounts that database tools do not index.

**Account-based marketing**
Enrich a named account list with the people and titles behind each domain.
Map who holds which role across a set of competitors or partners.

**Recruiting & talent sourcing**
Find the right department heads at companies you want to hire from.
Build a direct-contact pipeline for passive candidates.

**CRM enrichment**
Pass domains you already own and append fresh names, titles and emails.
Keep contact records current without a subscription database.

### 🚀 Getting started

1. Open the actor and add your target companies. Bare domains (`stripe.com`) work best for email building; plain names work best for LinkedIn discovery.
2. Add job titles to target (e.g. `CEO`, `Head of Marketing`), or leave empty to return every role found.
3. Set max leads per company (default 10) to control volume and cost.
4. Leave "scrape company website for emails" on to catch publicly listed addresses, and keep the recommended `GOOGLE_SERP` proxy group.
5. Click Start, then download the dataset as JSON, CSV or Excel, or pull it via API/MCP.

### 🔁 Run on a schedule

Turn this from a one-off pull into a standing feed with Apify's built-in Schedules — no code, no cron server of your own.

1. Run the actor once with the input you want repeated, then click **Save as a task** (top of the run form) — this keeps your exact input attached for every future run.
2. In the Apify Console, go to **Schedules** (left sidebar) → **Create new**.
3. Name it, set your timezone, and pick a frequency — a preset (hourly / daily / weekly) or a custom cron expression (e.g. `0 6 * * *` for daily at 6am).
4. Under **Actors or tasks to run**, add the task you saved in step 1.
5. Save. From then on it runs unattended on your schedule, billed the same pay-per-lead way as a manual run — nothing is charged just for the schedule existing.

Prefer to automate the setup itself? Same thing via the API:

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "b2b-leads-finder-daily",
    "cronExpression": "0 6 * * *",
    "isEnabled": true,
    "actions": [{ "type": "RUN_ACTOR", "actorId": "themineworks/b2b-leads-finder" }]
  }'
```

Full options — time zones, run notifications, pausing a schedule — are in Apify's [Schedules documentation](https://docs.apify.com/platform/schedules).

### FAQ

**How does it find emails without an API?**
It derives the address format the company actually uses from addresses published on its own site, then applies that format to the people it finds. Where no published address is available it falls back to the most common convention and labels the row `guessed`. Every row tells you which case applies via `email_confidence` and `email_pattern`.

**Are the emails verified?**
The domain is verified to accept mail via a DNS MX lookup. The individual mailbox is not, and we will not claim otherwise — see the section above for why that is not possible on this infrastructure. Use `email_confidence` to decide what to trust, and a dedicated verifier if you need mailbox-level certainty.

**Does it log in to or scrape LinkedIn directly?**
No. It only reads public LinkedIn profiles that Google has already indexed, using standard `site:linkedin.com/in` search queries through the `GOOGLE_SERP` proxy. It never authenticates, never uses cookies and never touches LinkedIn's own servers.

**How is this different from Apollo or ZoomInfo?**
Those are subscription databases with per-seat pricing and export caps, and the Store actors that undercut them are mostly reselling the same database. This actor holds no dataset at all: it searches for the specific companies you name, at the moment you run it, which is why it can return people at companies those databases have never indexed.

**Why would I pay more than the $1-3 actors?**
Because you are buying a different thing. They sell bulk slices of a shared list. This searches named targets live, including companies not in any list, and tells you the provenance of every address instead of stamping them all "verified". For a typical run of 20 companies at 10 leads each the difference is a couple of dollars.

**Can I use it inside an AI agent?**
Yes. It is exposed as an MCP tool. See below.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/b2b-leads-finder
```

Or call it programmatically with the Apify client:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/b2b-leads-finder').call({
  companies: ['stripe.com', 'notion.so'],
  jobTitles: ['CEO', 'Head of Marketing'],
  maxLeadsPerCompany: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Related LinkedIn actors

B2B Leads Finder's core lead source is Google-SERP-indexed LinkedIn profiles, so it belongs alongside the rest of the LinkedIn wedge:

- **[LinkedIn Profile Scraper](https://apify.com/themineworks/linkedin-profile-scraper)**: full profile detail (experience, education, skills) from a `linkedin.com/in/` URL.
- **[LinkedIn Company Scraper](https://apify.com/themineworks/linkedin-company-details)**: firmographics (industry, size, HQ, founded, website) from a company page URL.
- **[LinkedIn Employees Scraper](https://apify.com/themineworks/linkedin-employees)**: every public employee profile at a target company, by role.
- **[LinkedIn Jobs Scraper](https://apify.com/themineworks/linkedin-jobs-scraper)**: public job listings by keyword and location, useful for flagging accounts that are hiring.
- **[LinkedIn Post Scraper](https://apify.com/themineworks/linkedin-post-search)**: public LinkedIn posts and their authors by keyword, for social listening and lead discovery.
- **[LinkedIn Candidate Finder](https://apify.com/themineworks/linkedin-candidate-finder)**: a matched candidate shortlist from role, skills, and location.

Typical flow: linkedin-employees or linkedin-candidate-finder finds the people at a target account, b2b-leads-finder adds business emails and phone numbers, linkedin-profile-scraper pulls full work history before outreach.

### 🛠️ Complete your outbound pipeline

Found the leads. Now enrich and verify them with the rest of the suite:

- **[Google Maps Leads Scraper](https://apify.com/themineworks/maps-leads)**: pull businesses and emails from Google Maps by search query.
- **[Website Contact Scraper](https://apify.com/themineworks/website-contact-finder)**: take any domain list and extract emails, phones, and social profiles.
- **[Email Verifier & Validator](https://apify.com/themineworks/email-verifier-validator)**: verify every email before you send.

Typical flow: maps-leads finds the businesses, website-contact-finder and B2B Leads Finder add the people, email-verifier-validator checks deliverability before you send.

Questions or need a custom field set? Reach out through the Apify profile.

# Actor input Schema

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

List of company names or domains to find leads for (e.g. 'stripe.com', 'notion.so', 'Stripe'). Domains give better email guessing; names give better LinkedIn SERP results.

## `jobTitles` (type: `array`):

Filter leads by job title keyword (e.g. 'CEO', 'Head of Marketing', 'VP Sales'). Leave empty to return all roles.

## `maxLeadsPerCompany` (type: `integer`):

Maximum number of leads to find per company across all job title filters.

## `scrapeWebsite` (type: `boolean`):

Visit the company's /team, /about, and /contact pages to find directly-listed emails and names. Slower but finds emails that are publicly listed on the site.

## `proxy` (type: `object`):

The GOOGLE\_SERP proxy group is strongly recommended for LinkedIn profile discovery via Google. Company website scraping uses RESIDENTIAL automatically if available.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "notion.so"
  ],
  "jobTitles": [
    "CEO",
    "Head of Marketing"
  ],
  "maxLeadsPerCompany": 10,
  "scrapeWebsite": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "companies": [
        "stripe.com",
        "notion.so"
    ],
    "jobTitles": [
        "CEO",
        "Head of Marketing"
    ],
    "maxLeadsPerCompany": 10,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/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 = {
    "companies": [
        "stripe.com",
        "notion.so",
    ],
    "jobTitles": [
        "CEO",
        "Head of Marketing",
    ],
    "maxLeadsPerCompany": 10,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/b2b-leads-finder").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "companies": [
    "stripe.com",
    "notion.so"
  ],
  "jobTitles": [
    "CEO",
    "Head of Marketing"
  ],
  "maxLeadsPerCompany": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call themineworks/b2b-leads-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/MFZAYRfxMqYUaHBXm/builds/TVS05DO4m0u5JTlHa/openapi.json