# Lead database (`leadspicker/lead-database`) Actor

Describe who you want to reach in one sentence and export the matching people or companies. Searches 271M professional profiles and 47M companies, working out the filters from your brief and matching companies semantically, not by category label.

- **URL**: https://apify.com/leadspicker/lead-database.md
- **Developed by:** [Leadspicker](https://apify.com/leadspicker) (community)
- **Stats:** 1 total users, 0 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 lead results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Leadspicker Lead Database do?

**Describe who you want to reach in one sentence. Get a list of them.**

This Actor searches the **Leadspicker lead database** — roughly **271 million professional profiles** and **47 million companies** — and exports the matching records into an Apify dataset. There is no filter form to learn: you write something like *"heads of product at B2B SaaS companies in Czechia"* and the Actor works out the industry, seniority, size and geography filters itself, then matches companies **semantically** rather than by whatever label the database happens to carry.

That distinction is the whole point. An industry tag like "B2B SaaS" is a guess about how a company was categorised; a description matches what the company actually does. The brief works in any language.

**Note on contact details:** records contain LinkedIn URLs, job titles, companies and locations. They **do not contain email addresses or phone numbers.** See the FAQ.

### Why use Leadspicker Lead Database?

- **No filter archaeology.** One sentence in, a target list out. No guessing which of 400 industry labels your prospects were filed under.
- **Companies first, then people.** The search finds the right companies and then the right roles inside them, because a great person at an irrelevant company is still an irrelevant lead.
- **Every match is scored.** Each row carries a distance value, so you can see how confident the match is instead of trusting a black box.
- **Preview before you pay.** The run reports how many records matched before delivering any, and you are charged only for records actually delivered.
- **Wire it into anything.** Schedule runs, trigger by API, push results to your CRM through Apify integrations.

### How to use Leadspicker Lead Database

1. Write your brief in **Who are you looking for?** — the role, the kind of company, and the region. Up to 400 characters.
2. Choose whether you want **People** or **Companies** back.
3. Set **Maximum results**. You are charged per delivered record, so this is your cost control.
4. Run it. The log shows the filters your brief resolved into and the total number of matches before delivery starts, so you can stop and re-phrase if it looks wrong.

#### Writing a good brief

Be concrete about all three axes — **role, company, place**:

| Instead of | Write |
| --- | --- |
| "software companies" | "B2B SaaS companies selling to marketing teams" |
| "managers in Europe" | "heads of ecommerce at mid-size retailers in DACH" |
| "startups" | "seed-stage fintech startups in the Nordics" |

You can also paste LinkedIn company URLs into **Companies to look like** — the most reliable way to say "more companies like these". That switches the search to run *inside* the matching companies: it ranks look-a-like companies first, then takes the best-matching people from each. The Actor sizes that pool to the number of records you asked for, up to a ceiling of about 20,000 people per run. Ask for more than that and the log says so before delivery starts.

### Input

Only the brief is required. Everything under **Advanced** is optional: leave a field empty and the brief decides it, set it and it overrides the brief for that one field.

```json
{
  "query": "heads of product at B2B SaaS companies in Czechia",
  "searchType": "people",
  "maxResults": 4000
}
```

Filters that aren't exposed as fields — revenue, founded year, company type, has-a-phone-number, similarity tuning — are reachable through **Raw filter overrides** in the API's native shape. Unknown keys there are rejected with an error rather than ignored, because a silently ignored filter means searching the whole index.

**Buying-signal filters** are a separate block: technologies, funding, hiring, e-shop and public-supplier flags, CZ/SK register and financial facts, premises, website traffic. They need extra flags on the Leadspicker account, and the run checks that before charging anything — an unavailable filter is an error up front, not a 403 halfway in.

### Output

Each record becomes one dataset row. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "full_name": "Marko Chytka",
  "current_title": "Head of Product",
  "current_company_name": "Heureka Group",
  "current_seniority": "director",
  "current_company_industry": "Software Development",
  "current_company_size_class": "201-500",
  "current_location": "Prague, Czechia",
  "location_country_code": "CZ",
  "linkedin_url": "https://www.linkedin.com/in/marko-chytka",
  "knn_distance": 0.311
}
```

The run also writes `RUN_SUMMARY` (what was requested, delivered, and how many matched in total) and, for look-a-like searches, `SIMILAR_COMPANIES` to the key-value store.

#### Data table

| Field | Description |
| --- | --- |
| `full_name`, `first_name`, `last_name` | Person name |
| `current_title`, `current_seniority`, `current_function` | Current role |
| `current_company_name`, `current_company_linkedin_url` | Current employer |
| `current_company_industry`, `current_company_size_class`, `current_company_revenue_usd` | Employer firmographics |
| `current_location`, `location_country_code`, `location_sales_region` | Where the person is |
| `linkedin_url`, `social_media` | Profile links and connection counts |
| `experience`, `education` | Career and education history |
| `knn_distance` | Match distance — **lower is a closer match** |
| `updated_at` | When the record was last refreshed |

Company searches return `name`, `industry`, `industries`, `size_class`, `revenue_usd`, `founded_year`, `description`, `websites`, `linkedin_url`, `country_code`, `locations`, and `business_data`.

### Pricing

This Actor is **pay per result** — $0.01 per record delivered, plus a small one-off charge for resolving your brief into filters, and a negligible per-run start fee.

Every filter is validated before a single record is charged, so a search that matches nothing, or a run that fails on a bad filter, costs you the resolution fee and nothing more. Set **Maximum cost per run** in the run options to cap spend; the Actor stops cleanly at the limit and reports how far it got rather than failing.

#### Already a Leadspicker customer?

Paste your own key into **Your Leadspicker API key** and records are billed at a nominal rate here, because the run draws on your existing Leadspicker subscription instead. Get the key from **Leadspicker → User → Integrations → API Keys**.

The nominal rate requires an **active paid plan**. A key on a Leadspicker free trial still works and still returns data, but is charged at the standard per-record rate — the run log and `RUN_SUMMARY` say so explicitly when that happens, so check them before starting a large run.

### Tips and advanced options

- **Run 25 results first.** Look at the `knn_distance` column and the resolved filters in the log, then scale up. Tuning on a full run is expensive.
- **Read the resolved filters.** The log prints exactly what your brief became. If it guessed a filter you did not intend, pin the correct value in the Advanced section — your value always wins.
- **Semantic matching replaces label guessing.** When your brief produces a semantic seed, the Actor drops the guessed industry and keyword labels rather than ANDing them, because requiring both an exact keyword *and* a semantic match is the fastest way to get zero rows. Force them back with **Raw filter overrides** if you really want them.
- **A guessed job title is kept until it costs you the whole run.** The resolver's guess at the job title stays in the search, because it is usually what makes the results precise. If the free preflight count comes back empty, the Actor drops that one guess, counts again, and tells you in the log — so an over-specific guess costs you a broader result set rather than nothing at all. Pin **Job title contains** yourself to make it binding; anything you set by hand is never relaxed.
- **Excluding companies happens here, not in the database.** Put existing customers, competitors or your own company into **Exclude companies** as a name, a domain or a LinkedIn handle. The lead database cannot apply an exclusion on its own — it needs a matching positive filter to attach to — so the Actor drops those rows as they arrive instead. They are never delivered and never charged, but the match count shown before delivery is taken before exclusions, so expect to receive fewer records than it reports.
- **Company descriptions are opt-in, and slower.** A person record carries their company's name, industry, size, website and LinkedIn URL, but not its description — the lead database stores that on the company, not the person. Switch on **Fetch company descriptions** and the Actor looks it up per company. The lookups are free and cached within a run, so a look-a-like search that returns ten people per company costs one lookup for all ten. They are rate-limited to roughly 150 per minute though, so a search spanning many distinct companies takes noticeably longer, and the run stops looking up after 1,000 companies — later rows still deliver, just without that column.
- **Title and keyword exclusions you pin are never quietly dropped.** The index matches an include and its exclude as a single expression, so an exclusion left on its own stops being applied at all. If you pin `title_excludes` or `keywords_exclude` through **Raw filter overrides**, the Actor keeps the matching include rather than relax it — an empty result you can widen by hand, instead of a page of the people you asked to leave out.
- **Similarity coverage is uneven by country.** Where a country is not embedded, a semantic search returns zero rather than fewer results. If you get nothing, try again naming the region more plainly.
- **Results are not relevance-ranked.** People come back most-connected first, companies in index order. `maxResults` is a cut-off, not a top-N — narrow the brief instead of relying on it.
- **Very large runs** may hit a pagination limit around 50,000 records, and a look-a-like run is capped lower still (see **Companies to look like**). Either way the Actor stops gracefully and keeps everything already delivered — the run finishes, it does not fail.

### FAQ, disclaimers, and support

**Does this return email addresses or phone numbers?**
No. Records carry LinkedIn URLs, titles, companies and locations. Email and phone enrichment is a separate, credit-based product inside Leadspicker, run on contacts after they land in a list.

**Why did my search return zero results?**
Usually a brief that is too narrow on several axes at once, or a country that is not embedded for semantic matching. Widen one axis at a time — drop the region, or use a broader role description.

**Why does the count say "132+" instead of a number?**
Semantic counts are a floor, not an exact total; the scoring budget was exhausted before the whole corpus was covered. The real number is at least that.

**Do I need a Leadspicker account?**
No. Without one, the run uses the built-in key and you pay per result here. With one, supply your key and pay the nominal rate instead.

**Data protection.** This Actor returns personal data about individuals in a professional context. You are the controller for whatever you export and are responsible for having a lawful basis for processing it — under GDPR that is normally legitimate interest for B2B outreach — and for honouring access and erasure requests. Do not use the output for purposes those individuals would not reasonably expect.

**Support.** Found a bug or need a filter that is not exposed? Open an issue on the Actor's Issues tab. Custom data and volume arrangements are available through Leadspicker.

# Actor input Schema

## `searchType` (type: `string`):

People returns individual professionals with their current role and company. Companies returns company records only.

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

How many records to deliver. You are charged per delivered record, so this is your main cost control. Start small — 25 records is enough to see whether the brief resolved the way you meant — then scale up.

## `hqCountryCodes` (type: `array`):

Pick one or more countries. The database covers Czechia and Slovakia best; the rest are listed because briefs often name them. For a country not in the list, or a multi-country region like DACH or EMEA, use Raw filter overrides (`hq_country_codes` / `hq_sales_regions`). Overrides whatever region the brief implied.

## `employeeRanges` (type: `array`):

Headcount bands. Overrides any size implied by the brief.

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

People search only. Overrides any seniority implied by the brief.

## `titleIncludes` (type: `array`):

People search only. Any one of these terms matching the current job title is enough, so "Head of Product" and "VP Product" together widen the search rather than narrow it. Leave empty to let the brief decide.

## `referenceCompanyUrls` (type: `array`):

Paste LinkedIn company URLs or handles — "productboard" or "https://linkedin.com/company/productboard" both work. The search then looks for companies like those and the best-matching people inside them, which caps a run at roughly 20,000 people. The most reliable way to say "more companies like these".

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

Companies to leave out of the results — existing customers, competitors, your own company. Give a company name ("Heureka", which also catches "Heureka Group"), a website domain ("heureka.group"), or a LinkedIn handle or URL ("productboard"). Names match as substrings so a group takes its subsidiaries with it; domains and handles match exactly. Excluded rows are never delivered and never charged for, but the match count reported before delivery is taken before exclusions.

## `includeCompanyDetails` (type: `boolean`):

People search only. Adds each person's company description to their row. A person record does not carry one, so the Actor looks it up per company — the lookup is free, but it is rate-limited to roughly 150 per minute, so a run touching many distinct companies takes noticeably longer. Capped at 1,000 companies per run; rows past that still deliver, without the column.

## `query` (type: `string`):

One or two sentences, in any language. Name the role, the kind of company, and the region — for example "heads of product at B2B SaaS companies in Czechia" or "výrobní firmy dělající automatizaci pro automotive". Be specific; a tight brief resolves into far better filters than a vague one.

## `leadspickerApiKey` (type: `string`):

Leave empty to use the built-in key and pay per result here. Supply your own key (Leadspicker → User → Integrations → API Keys) to run against your own Leadspicker subscription at a nominal per-result price. The nominal rate requires an active PAID Leadspicker plan — keys on a free trial still work, but are charged at the standard per-result rate.

## `advanced` (type: `object`):

Raw API fields merged over everything above, for filters not exposed here (revenue, founded year, industries, keywords, has\_phone, similarity tuning). For a people search, nest under "company" and "people": {"company": {"founded\_year\_min": 2015}}. For a company search, put fields at the top level. Unknown keys are rejected rather than ignored.

## `tricorder` (type: `object`):

Company intelligence filters: technologies, funding, hiring signals, e-shop and public-supplier flags, CZ/SK register and financial facts, premises, website traffic. Needs the Tricorder feature on the Leadspicker account — the register, financial, premises and e-shop fields need two further flags on top, which the run checks before charging. Matches only companies where both sides know the website domain.

## Actor input object example

```json
{
  "searchType": "people",
  "maxResults": 100,
  "hqCountryCodes": [],
  "employeeRanges": [],
  "seniority": [],
  "titleIncludes": [],
  "referenceCompanyUrls": [],
  "excludeCompanies": [],
  "includeCompanyDetails": false,
  "advanced": {},
  "tricorder": {}
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `similarCompanies` (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
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadspicker/lead-database").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 }

# Run the Actor and wait for it to finish
run = client.actor("leadspicker/lead-database").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
}' |
apify call leadspicker/lead-database --silent --output-dataset

```

## MCP server setup

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

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/BsUTOfzC1GG0aBTv6/builds/0vTDZEA2HZg0zRMmH/openapi.json