# Contact Enrichment ✅ Bulk Email & Phone Finder ✅ Any Field (`lead_king/contact-enrichment`) Actor

🔥 Enrich any list by matching on the fields you ALREADY have — name + company, email, phone, address or LinkedIn. Get verified ☎️ mobile numbers ✅ work & personal emails. Pay only for contacts found. Apollo, ZoomInfo, Lusha, Clay & Seamless alternative.

- **URL**: https://apify.com/lead\_king/contact-enrichment.md
- **Developed by:** [Lead King](https://apify.com/lead_king) (community)
- **Categories:** Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 contact matches

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

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

## What's an Apify Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Contact Enrichment ✅ Bulk Email & Phone Finder — Match on ANY Field 🎯

**Enrich the list you already have.** Names and companies but no emails? A
column of phone numbers with no names? A half-finished CRM export? Send it in
and get back **verified ☎️ mobile numbers, ✅ work & personal emails**, job
titles, and company data — matched against a database of **hundreds of
millions of profiles**.

A pay-as-you-go alternative to **Apollo, ZoomInfo, Lusha, Clay, Seamless,
Hunter, Dropcontact and Clearbit** — no subscription, no seats, no export
credits, no API key. **You pay only for contacts actually found.**

### 🧑‍💼 What does this Contact Enrichment Actor do?

Most enrichment tools demand one specific identifier — usually an email or a
LinkedIn URL. Real lists are messier than that.

This Actor lets you match on **any combination of 13 identity fields**, so you
can enrich the list you actually have instead of the one you wish you had.
Give it a name and a company, or just a phone number, or an address — whatever
you've got. More fields simply mean a more precise match.

Export to **CSV, Excel, or JSON**, or push straight into your CRM.

### ⚖️ Why use this instead of Apollo, ZoomInfo, or Clay?

| | This Actor | Apollo / ZoomInfo / Clay |
| --- | --- | --- |
| **Pricing** | Pay per contact found | Monthly subscription + credits |
| **Minimum spend** | Cents | $50–$15,000+/year |
| **Match fields** | Any of 13, in any combination | Usually email or domain only |
| **Failed matches** | **Free** — you're never charged | Often burns a credit anyway |
| **Setup** | Click Start | Sales calls, seats, contracts |
| **Export limits** | None — it's your dataset | Credit-capped exports |

### 🔑 What can I match on?

Any combination of these — mix and match freely:

| Field | Example |
| --- | --- |
| `first_name` | `Jane` |
| `last_name` | `Doe` |
| `email` | `jane@acme.com` |
| `email_domain` | `acme.com` |
| `sha256_email` | `4d1a...` |
| `phone` | `+15555550123` |
| `personal_address` | `123 Main St` |
| `personal_city` | `Austin` |
| `personal_state` | `TX` |
| `personal_zip` | `78701` |
| `company_name` | `Acme Corp` |
| `company_domain` | `acme.com` |
| `linkedin_url` | `https://linkedin.com/in/janedoe` |

✨ **Your existing column names usually just work.** `Full Name`, `Company`,
`Work Email`, `Mobile`, `LinkedIn`, `Zip Code` and dozens more are recognized
automatically. Anything unusual can be pointed at the right field with the
**Field mapping** input. Extra columns are ignored — paste a whole CRM export
without cleaning it up first.

### 📥 Example input

```json
{
  "records": [
    { "first_name": "Jane", "last_name": "Doe", "company_domain": "acme.com" },
    { "linkedin_url": "https://linkedin.com/in/johnsmith" },
    { "phone": "+15555550123" },
    { "Full Name": "Maria Garcia", "Company": "Globex" }
  ],
  "requireEmail": true
}
````

### 🕵️ What data do I get for each contact?

- 👤 **Full name** (first & last)
- 📧 **Personal email(s)** — all known, not just one
- 💼 **Business email(s)**
- 📞 **Phone numbers** — personal and business
- 🎯 **Job title**
- 🏢 **Company**, company domain, industry
- 📍 **City, state, ZIP, address**
- 🔗 **LinkedIn URL**

Output sample:

```json
{
  "matched": true,
  "fullName": "Jane Doe",
  "email": "jane.doe@example.com",
  "businessEmail": "jdoe@acmecorp.com",
  "phone": "+15550101234",
  "jobTitle": "VP of Marketing",
  "company": "Acme Corp",
  "companyDomain": "acmecorp.com",
  "linkedinUrl": "https://linkedin.com/in/janedoe",
  "city": "Austin",
  "state": "TX",
  "input": { "first_name": "Jane", "last_name": "Doe", "company_domain": "acme.com" }
}
```

Every row carries the `input` filter that produced it, so you can join results
straight back onto your source list. Records that match nothing stay in the
dataset with `matched: false` — you can see exactly what didn't resolve.

### 🎚️ Matching modes

- **ALL fields (default)** — a contact must match *every* field you supply.
  Precise, with few false positives. Best when your data is clean.
- **ANY field** (`matchAny: true`) — a contact matches if *any single* field
  matches. Great for recovering data from partial or slightly inaccurate
  records, but it can return unrelated people, so review before use.

### 💰 Pricing — you only pay for what you find

Pay-per-event: you're charged **only for contacts actually returned**.

- ❌ Input records that match nothing → **free**
- ✅ Set `requireEmail: true` → never pay for phone-only records
- ✅ Set `requirePhone: true` → never pay for email-only records
- 🎛️ `maxResultsPerRecord` caps how many alternates you'll accept per row

To protect your budget, a single overly broad filter (like `company_domain`
alone, which can match hundreds of thousands of people) is refused with a
clear message instead of billing you for ten random strangers. Add a name, or
use a strong identifier such as email, phone, or LinkedIn URL.

### 💡 Tips for the best match rate

- **More fields = better matching.** A name alone is rarely enough; name +
  company or name + city works well.
- **Strong identifiers match best** — email, phone, LinkedIn URL, or postal
  address will pin down one specific person.
- **LinkedIn URLs are canonicalized automatically**, so `www.` and
  trailing-slash variants both match.
- **Try ANY mode** on records that fail in ALL mode — often one field in the
  source data is stale or misspelled.

### ❓ FAQ

**Do I need an API key?** No. Just Apify credits — everything else is handled
for you.

**What if a record doesn't match?** It's returned with `matched: false` and an
explanation, and you are not charged for it.

**Can I run a whole CSV through this?** Yes. Upload it as the `records` input;
unrecognized columns are ignored, so most exports work as-is.

**Is this GDPR/CCPA compliant to use?** You are responsible for having a lawful
basis for processing and contacting the people you enrich. Use it for
legitimate B2B outreach and honor opt-outs.

# Actor input Schema

## `records` (type: `array`):

One object per person to look up. Use any combination of these fields: first\_name, last\_name, email, email\_domain, sha256\_email, phone, personal\_zip, personal\_address, personal\_state, personal\_city, company\_name, company\_domain, linkedin\_url. Common column names (Full Name, Company, Mobile, LinkedIn…) are recognized automatically; anything else can be mapped with Field mapping below. Unrecognized columns are ignored.

## `fieldMapping` (type: `object`):

Map your own column names onto database match fields, e.g. {"Work Email": "email", "Acct": "company\_name"}. Only needed when a column isn't recognized automatically.

## `matchAny` (type: `boolean`):

Off (default): a record must match on EVERY field you supply — precise, fewer false positives. On: a record matches if ANY single field matches — useful for recovering data from partial or slightly inaccurate records, but can return unrelated people.

## `maxResultsPerRecord` (type: `integer`):

How many matched contacts to return for each input record. Broad filters (e.g. a common name at a big company) can match several people. You are charged per contact returned, so raise this only if you want alternates. Maximum 10.

## `requireEmail` (type: `boolean`):

Skip (and don't charge for) matched contacts that have no email address.

## `requirePhone` (type: `boolean`):

Skip (and don't charge for) matched contacts that have no phone number.

## Actor input object example

```json
{
  "records": [
    {
      "first_name": "Bill",
      "last_name": "Gates",
      "company_domain": "microsoft.com"
    },
    {
      "linkedin_url": "https://linkedin.com/in/williamhgates"
    },
    {
      "email": "someone@example.com"
    }
  ],
  "fieldMapping": {},
  "matchAny": false,
  "maxResultsPerRecord": 1,
  "requireEmail": false,
  "requirePhone": false
}
```

# Actor output Schema

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

Open the dataset of matched contacts.

## `resultsConsole` (type: `string`):

Browse the matched contacts in the Apify Console.

# 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 = {
    "records": [
        {
            "first_name": "Bill",
            "last_name": "Gates",
            "company_domain": "microsoft.com"
        },
        {
            "linkedin_url": "https://linkedin.com/in/williamhgates"
        },
        {
            "email": "someone@example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lead_king/contact-enrichment").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 = { "records": [
        {
            "first_name": "Bill",
            "last_name": "Gates",
            "company_domain": "microsoft.com",
        },
        { "linkedin_url": "https://linkedin.com/in/williamhgates" },
        { "email": "someone@example.com" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lead_king/contact-enrichment").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 '{
  "records": [
    {
      "first_name": "Bill",
      "last_name": "Gates",
      "company_domain": "microsoft.com"
    },
    {
      "linkedin_url": "https://linkedin.com/in/williamhgates"
    },
    {
      "email": "someone@example.com"
    }
  ]
}' |
apify call lead_king/contact-enrichment --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Contact Enrichment ✅ Bulk Email & Phone Finder ✅ Any Field",
        "description": "🔥 Enrich any list by matching on the fields you ALREADY have — name + company, email, phone, address or LinkedIn. Get verified ☎️ mobile numbers ✅ work & personal emails. Pay only for contacts found. Apollo, ZoomInfo, Lusha, Clay & Seamless alternative.",
        "version": "0.0",
        "x-build-id": "wYX8pV7pJAW4aRv0O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lead_king~contact-enrichment/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lead_king-contact-enrichment",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lead_king~contact-enrichment/runs": {
            "post": {
                "operationId": "runs-sync-lead_king-contact-enrichment",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lead_king~contact-enrichment/run-sync": {
            "post": {
                "operationId": "run-sync-lead_king-contact-enrichment",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "records"
                ],
                "properties": {
                    "records": {
                        "title": "Records to match",
                        "type": "array",
                        "description": "One object per person to look up. Use any combination of these fields: first_name, last_name, email, email_domain, sha256_email, phone, personal_zip, personal_address, personal_state, personal_city, company_name, company_domain, linkedin_url. Common column names (Full Name, Company, Mobile, LinkedIn…) are recognized automatically; anything else can be mapped with Field mapping below. Unrecognized columns are ignored."
                    },
                    "fieldMapping": {
                        "title": "Field mapping (optional)",
                        "type": "object",
                        "description": "Map your own column names onto database match fields, e.g. {\"Work Email\": \"email\", \"Acct\": \"company_name\"}. Only needed when a column isn't recognized automatically.",
                        "default": {}
                    },
                    "matchAny": {
                        "title": "Match ANY field instead of ALL",
                        "type": "boolean",
                        "description": "Off (default): a record must match on EVERY field you supply — precise, fewer false positives. On: a record matches if ANY single field matches — useful for recovering data from partial or slightly inaccurate records, but can return unrelated people.",
                        "default": false
                    },
                    "maxResultsPerRecord": {
                        "title": "Max contacts per input record",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many matched contacts to return for each input record. Broad filters (e.g. a common name at a big company) can match several people. You are charged per contact returned, so raise this only if you want alternates. Maximum 10.",
                        "default": 1
                    },
                    "requireEmail": {
                        "title": "Only return contacts with an email",
                        "type": "boolean",
                        "description": "Skip (and don't charge for) matched contacts that have no email address.",
                        "default": false
                    },
                    "requirePhone": {
                        "title": "Only return contacts with a phone",
                        "type": "boolean",
                        "description": "Skip (and don't charge for) matched contacts that have no phone number.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```