# Leads Finder - B2B List Building (`scalelist/leads-finder`) Actor

Build a targeted B2B lead list with filters for job title, seniority, company size, industry, keyword and location. Full profiles with company details and LinkedIn URL.

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

## Pricing

from $50.00 / 1,000 leads founds

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

## Leads Finder by Scalelist

Find targeted B2B lead profiles matching job titles, departments, career levels, locations, industries, and company criteria — powered by Scalelist without leaving your Apify workflow.

Search over millions of B2B profiles and export clean, verified firmographic and professional profile data directly to the Apify Dataset.

***

### How it works

1. Set **Number of leads to extract** — how many leads you want back.
2. Narrow your audience using any combination of the 14 filter fields, grouped on the input form into **Job Title & Role**, **Company**, **Company Size**, **Industry**, **Keywords** and **Person Location**.

The Actor fetches matching profiles progressively and writes them straight to your Apify dataset.

You are charged per lead delivered, via Apify Pay-Per-Event (PPE). If fewer leads match than you asked for, you are only charged for the leads actually delivered — asking for 10,000 when only 100 match costs you 100.

***

### Input

| Field | Form label | Section | Type | Description |
| --- | --- | --- | --- | --- |
| `maxResults` | Number of leads to extract | — | `integer` | How many leads to return (default: `100`, max: `10,000`) |
| `jobTitles` | Job Titles | Job Title & Role | `string[]` | Job titles to match (OR logic), e.g. `["VP Sales", "Chief Technology Officer"]` |
| `excludeJobTitles` | Exclude Job Titles | Job Title & Role | `string[]` | Job titles to exclude from results |
| `jobFunctions` | Job Functions | Job Title & Role | `string[]` | Functional departments, e.g. `["Sales", "Engineering", "Marketing"]` |
| `seniority` | Seniority Levels | Job Title & Role | `string[]` | Career levels, e.g. `["CXO", "VP", "Director", "Manager"]` |
| `companies` | Company Name | Company | `string[]` | Names of companies to include (OR logic), e.g. `["Google", "Stripe"]` |
| `excludeCompanies` | Exclude Company Name | Company | `string[]` | Names of companies to exclude from results |
| `companyDomains` | Company Domains | Company | `string[]` | Company website domains to include, e.g. `["stripe.com"]` |
| `companySizeMin` | Company Size Min | Company Size | `integer` | Minimum employee count (optional) |
| `companySizeMax` | Company Size Max | Company Size | `integer` | Maximum employee count (optional) |
| `industries` | Industries | Industry | `string[]` | Industries to match, e.g. `["Computer Software", "Financial Services"]` |
| `keyword` | Keyword | Keywords | `string` | Free-text keyword matched across the profile |
| `countries` | Countries | Person Location | `string[]` | Countries to match, e.g. `["United States", "United Kingdom"]` |
| `states` | States / Regions | Person Location | `string[]` | States / provinces to match, e.g. `["California", "Ontario"]` |
| `cities` | Cities | Person Location | `string[]` | Cities to match, e.g. `["San Francisco", "London", "Singapore"]` |

`companies` matches on the company's **name**; use `companyDomains` to match on its website instead.

#### Example input: Search for Software Engineering VPs & Directors

```json
{
  "maxResults": 100,
  "jobTitles": ["VP Engineering", "Director of Engineering"],
  "jobFunctions": ["Engineering"],
  "seniority": ["VP", "Director"],
  "industries": ["Computer Software", "Internet"],
  "companySizeMin": 50,
  "companySizeMax": 500,
  "countries": ["United States"]
}
```

#### Example input: Target named accounts

```json
{
  "maxResults": 500,
  "companies": ["Stripe", "Ramp", "Brex"],
  "seniority": ["CXO", "VP"],
  "countries": ["United States"]
}
```

***

### Output

Every delivered lead is written to the Apify Dataset with the following fields:

| Field | Type | Description |
| --- | --- | --- |
| `full_name` | `string` | Lead's full name |
| `first_name` | `string` | First name |
| `last_name` | `string` | Last name |
| `job_title` | `string` | Current job title |
| `seniority` | `string` | Seniority level (`CXO`, `VP`, `Director`, `Manager`, etc.) |
| `job_function` | `string` | Functional department |
| `company_name` | `string` | Current employer |
| `company_domain` | `string` | Company website domain |
| `company_size` | `string` | Company employee count range |
| `industry` | `string` | Industry category |
| `city` | `string` | City |
| `state` | `string` | State or region |
| `country` | `string` | Country |
| `linkedin_url` | `string` | Public LinkedIn profile URL |
| `company_linkedin_url` | `string` | Company LinkedIn page URL |
| `profile_picture_url` | `string` | Profile image URL (if available) |

#### Example output row

```json
{
  "full_name": "Jane Doe",
  "first_name": "Jane",
  "last_name": "Doe",
  "job_title": "VP of Engineering",
  "seniority": "VP",
  "job_function": "Engineering",
  "company_name": "Acme Cloud Inc.",
  "company_domain": "acmecloud.com",
  "company_linkedin_url": "https://www.linkedin.com/company/acme-cloud",
  "company_size": "51-200",
  "industry": "Computer Software",
  "city": "San Francisco",
  "state": "California",
  "country": "United States",
  "linkedin_url": "https://www.linkedin.com/in/janedoe",
  "profile_picture_url": "https://media.licdn.com/dms/image/..."
}
```

***

### Enriching your leads

This Actor finds and extracts lead profiles. It does not return emails or phone numbers — run the results through the enrichment Actors for those:

- **Email Finder** — verified business emails
- **Phone Finder** — mobile numbers
- **Domain Finder** — all emails at a company, from its domain

Output is `snake_case` (`first_name`, `company_domain`, `linkedin_url`) so it maps directly onto what those Actors expect.

### Error handling

| Situation | Behaviour |
| --- | --- |
| Rate limit (429) | Exponential backoff, up to 5 automatic retries |
| Fewer matches than requested | Search ends when results are exhausted; you are charged only for leads delivered |
| Spend cap reached | Only the leads that could be charged are delivered, then the Actor stops cleanly and flushes all saved dataset rows |
| Duplicate profiles | Deduplicated within the run by LinkedIn URL; duplicates are never charged |

***

### Other Scalelist Actors

- [Email Finder](https://apify.com/scalelist/email-finder) — find your leads' verified email
- [Phone Finder](https://apify.com/scalelist/phone-finder) — find your leads' mobile number
- [Domain Finder](https://apify.com/scalelist/domain-email-finder) — find leads and their emails from a company domain

***

### Support

- [Scalelist Website](https://scalelist.com)
- Scalelist Support: hello@scalelist.com

# Actor input Schema

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

How many leads to return (1 to 10,000). You are charged per lead delivered to the dataset.

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

Job titles to match (OR logic), e.g. 'CEO', 'Head of Sales'.

## `excludeJobTitles` (type: `array`):

Job titles to exclude. Applied after the filters above.

## `jobFunctions` (type: `array`):

Functional departments to match (OR logic).

## `seniority` (type: `array`):

Seniority / career levels to match (OR logic).

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

Names of companies to include (OR logic), e.g. 'Google', 'Stripe'. Match on the company's name, not its website — use Company Domains for that.

## `excludeCompanies` (type: `array`):

Names of companies to exclude from results.

## `companyDomains` (type: `array`):

Company website domains to include, e.g. 'google.com', 'stripe.com'.

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

Minimum employee count (inclusive).

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

Maximum employee count (inclusive).

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

Industries to match, e.g. 'Computer Software', 'Financial Services'.

## `keyword` (type: `string`):

Free-text keyword matched anywhere across the profile.

## `countries` (type: `array`):

Countries to match, e.g. 'United States', 'United Kingdom', 'France'.

## `states` (type: `array`):

States or provinces to match, e.g. 'California', 'Texas', 'Ontario'.

## `cities` (type: `array`):

Cities to match, e.g. 'San Francisco', 'London', 'Singapore'.

## Actor input object example

```json
{
  "maxResults": 100,
  "jobTitles": [
    "Chief Executive Officer",
    "VP of Sales",
    "Head of Growth"
  ],
  "jobFunctions": [
    "Sales",
    "Marketing",
    "Leadership"
  ],
  "seniority": [
    "CXO",
    "VP",
    "Head"
  ],
  "companySizeMin": 10,
  "companySizeMax": 500,
  "industries": [
    "Computer Software",
    "Information Technology & Services"
  ],
  "countries": [
    "United States"
  ]
}
```

# Actor output Schema

## `overview` (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 = {
    "maxResults": 100,
    "jobTitles": [
        "Chief Executive Officer",
        "VP of Sales",
        "Head of Growth"
    ],
    "jobFunctions": [
        "Sales",
        "Marketing",
        "Leadership"
    ],
    "seniority": [
        "CXO",
        "VP",
        "Head"
    ],
    "companySizeMin": 10,
    "companySizeMax": 500,
    "industries": [
        "Computer Software",
        "Information Technology & Services"
    ],
    "countries": [
        "United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scalelist/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 = {
    "maxResults": 100,
    "jobTitles": [
        "Chief Executive Officer",
        "VP of Sales",
        "Head of Growth",
    ],
    "jobFunctions": [
        "Sales",
        "Marketing",
        "Leadership",
    ],
    "seniority": [
        "CXO",
        "VP",
        "Head",
    ],
    "companySizeMin": 10,
    "companySizeMax": 500,
    "industries": [
        "Computer Software",
        "Information Technology & Services",
    ],
    "countries": ["United States"],
}

# Run the Actor and wait for it to finish
run = client.actor("scalelist/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 '{
  "maxResults": 100,
  "jobTitles": [
    "Chief Executive Officer",
    "VP of Sales",
    "Head of Growth"
  ],
  "jobFunctions": [
    "Sales",
    "Marketing",
    "Leadership"
  ],
  "seniority": [
    "CXO",
    "VP",
    "Head"
  ],
  "companySizeMin": 10,
  "companySizeMax": 500,
  "industries": [
    "Computer Software",
    "Information Technology & Services"
  ],
  "countries": [
    "United States"
  ]
}' |
apify call scalelist/leads-finder --silent --output-dataset

```

## MCP server setup

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