# LinkedIn Email Finder: Verified Work Emails (`capable_cauldron/verified-work-email-finder`) Actor

Find verified work emails from LinkedIn profile URLs or a full name and company domain. Get verification status, deliverability score, catch-all flag and professional details. Pay only for valid emails found.

- **URL**: https://apify.com/capable_cauldron/verified-work-email-finder.md
- **Developed by:** [Capable Cauldron](https://apify.com/capable_cauldron) (community)
- **Categories:** Lead generation, Social media, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$40.00 / 1,000 valid email founds

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/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

Verified Work Email Finder is a **LinkedIn email finder** that turns **LinkedIn profile URLs**, or a **full name plus company domain**, into **verified work email addresses**. Each address comes with its verification status, a 0 to 100 deliverability score, a catch-all flag, and the person's title, company, location and LinkedIn URL.

It is made for **SDRs, founders, recruiters and agencies** building outbound lists, and for **enriching leads** you already have in a CRM, a spreadsheet or another Actor's dataset. Like every Apify Actor it runs on a schedule, through the API, with webhooks, and connects to Make, Zapier, n8n, Clay, HubSpot and Google Sheets.

Click **Try for free**, paste a few LinkedIn links and press **Start**. You only pay for emails that are verified as valid. The Apify free plan's $5 of monthly credit covers about 125 verified emails.

See a real run in 47 seconds:

[![LinkedIn Email Finder demo video, 47 seconds](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/verified-work-email-finder-demo-poster.jpg)](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/verified-work-email-finder-demo.mp4)

▶️ [Watch the 47-second demo](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/verified-work-email-finder-demo.mp4) (MP4, 20 MB, opens in your browser) · [Transcript](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/verified-work-email-finder-demo-transcript.srt)

### What can Verified Work Email Finder do?

- 🔗 Finds the **work email behind a LinkedIn profile**, including Sales Navigator people links
- 👤 Finds an email from **full name + company domain** when you have no LinkedIn link
- ✅ Returns only **verified** addresses by default, and tells you why the rest were not returned
- 🎯 Adds a **deliverability score** (0 to 100) and a **catch-all** flag so you can decide how risky a send is
- 🧑‍💼 Enriches each row with **name, title, company, website, location and industry**
- 📮 Optionally falls back to a **personal** or **generic** (info@) address when no work email exists
- 💸 Charges **only for valid emails found**: not-found, invalid and timed-out lookups are free
- 🧾 Writes **one row per input**, in any mix of LinkedIn links and names, so results join straight back to your list

| Field | Example |
|---|---|
| `email` | `jane.doe@acme.com` |
| `emailStatus` | `Valid`, `Invalid` or `Not found` |
| `emailScore` | `96` |
| `isCatchAll` | `false` |
| `title`, `company` | `VP Marketing`, `Acme Analytics` |
| `found` | `true` when a valid email was returned |

### How to find emails from LinkedIn profiles

1. Open the Actor and click **Try for free**. Sign up with Google, GitHub or email; no credit card is needed.
2. Paste LinkedIn profile links into **LinkedIn profile URLs**, one per line.
3. For people without a LinkedIn link, add them to **People** as `{"fullName": "Jane Doe", "domain": "acme.com"}` or as `"Jane Doe, acme.com"`.
4. Click **Start**. Most lookups finish in a few seconds; some take up to two minutes before a result is available.
5. Export the results as CSV, Excel or JSON, or push them to your CRM or sequencer with an integration.

### How much does it cost to find emails?

You pay per verified email. Everything else is free.

| Event | Price |
|---|---|
| Valid email found | $0.04 |
| Email not found, invalid, or search timed out | $0 |

Platform compute is included in that price, so the event table is the whole bill.

Worked examples:

- **200 LinkedIn profiles, 140 valid emails found.** You pay for the 140: **$5.60**. The 60 misses cost nothing.
- **The free plan.** $5 of monthly Apify credit covers about 125 verified emails.

To cap spending, set **Maximum cost per run** in the run options. When the cap is reached, the Actor stops starting new lookups and still writes a row for every remaining input, marked as not looked up.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `linkedinUrls` | array | — | LinkedIn profile links (`/in/...` or Sales Navigator people links). One row per link. |
| `people` | array | — | People as `{"fullName", "domain"}` objects or `"Full Name, domain.com"` strings. One row per person. |
| `onlyValidEmails` | boolean | true | Fill the `email` column only for addresses verified as Valid. Rows are kept either way. |
| `includePersonalEmails` | boolean | false | LinkedIn lookups only: fall back to a personal address when there is no work email. |
| `includeGenericEmails` | boolean | false | LinkedIn lookups only: fall back to a generic company address such as info@. |
| `maxConcurrency` | integer | 4 | Lookups in parallel, 1 to 5. |

```json
{
    "linkedinUrls": ["https://www.linkedin.com/in/williamhgates"],
    "people": [{ "fullName": "Satya Nadella", "domain": "microsoft.com" }],
    "onlyValidEmails": true,
    "includePersonalEmails": false,
    "includeGenericEmails": false
}
```

#### What counts as a valid input?

A LinkedIn input must be a person's profile link: company pages and post links are rejected. A person needs a first and last name and a company domain (a website or an email address on that domain also works). Inputs that do not qualify still get a row, with the reason in `error`, and are never charged. Duplicate inputs share one lookup.

### Output

Each input produces one row. This fictional Jane Doe example shows a successful LinkedIn lookup. The input above returns status rows for the supplied people; finding a verified email is not guaranteed.

```json
{
    "input": "https://www.linkedin.com/in/jane-doe-acme",
    "inputType": "linkedin",
    "found": true,
    "email": "jane.doe@acme.com",
    "emailStatus": "Valid",
    "emailType": "Work email",
    "emailScore": 96,
    "isCatchAll": false,
    "fullName": "Jane Doe",
    "firstName": "Jane",
    "lastName": "Doe",
    "title": "VP Marketing",
    "company": "Acme Analytics",
    "website": "https://acme.com",
    "linkedinUrl": "https://www.linkedin.com/in/jane-doe-acme",
    "location": "Austin, Texas, United States",
    "industry": ["Software Development"],
    "error": null,
    "scrapedAt": "2026-11-05T10:00:12.410Z"
}
```

The dataset has an **Emails** view and a **Full detail** view. The `OUTPUT` record in the key-value store holds the run status, counts of found, not-found, invalid and timed-out lookups.

### Use cases

Start with one of these six prefilled examples:

- [Find a work email from a LinkedIn profile](https://apify.com/capable_cauldron/verified-work-email-finder/examples/vwef-find-work-email-from-linkedin-profile)
- [Find a work email by name and company domain](https://apify.com/capable_cauldron/verified-work-email-finder/examples/vwef-find-work-email-by-name-and-company)
- [Enrich a small LinkedIn prospect list with emails](https://apify.com/capable_cauldron/verified-work-email-finder/examples/vwef-enrich-a-small-linkedin-prospect-list)
- [Review email lookup status and person metadata](https://apify.com/capable_cauldron/verified-work-email-finder/examples/vwef-research-email-match-status-and-evidence)
- [Combine LinkedIn and name-domain email searches](https://apify.com/capable_cauldron/verified-work-email-finder/examples/vwef-combine-linkedin-and-name-domain-lookups)
- [Find work emails with one lookup at a time](https://apify.com/capable_cauldron/verified-work-email-finder/examples/vwef-run-single-concurrency-work-email-lookups)

### API and integrations

The Actor ID is `capable_cauldron/verified-work-email-finder`.

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('capable_cauldron/verified-work-email-finder').call({
    linkedinUrls: ['https://www.linkedin.com/in/williamhgates'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.found).map((r) => r.email));
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("capable_cauldron/verified-work-email-finder").call(
    run_input={"people": [{"fullName": "Satya Nadella", "domain": "microsoft.com"}]}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["input"], row["email"], row["emailStatus"], row["emailScore"])
```

CLI:

```bash
apify call capable_cauldron/verified-work-email-finder --input '{"linkedinUrls":["https://www.linkedin.com/in/williamhgates"]}'
```

Chain it after any LinkedIn scraper with a webhook, or connect it to Make, Zapier, n8n, Clay or HubSpot from the **Integrations** tab so new leads get emails automatically.

### FAQ

#### Is it legal to find people's work emails?

Finding a business email address is legal in most places, but how you use it is regulated. Under GDPR you need a lawful basis (often legitimate interest for relevant B2B outreach), you must say where you got the data, and you must honor opt-outs. CAN-SPAM and similar laws require an unsubscribe link and an honest sender. This Actor does not log in to LinkedIn or read anything behind a login. If you are unsure about your use case, ask a lawyer.

#### What does "Valid", "Invalid" and "Not found" mean?

`Valid` addresses passed verification and are safe to send to. `Invalid` means an address was known but failed re-verification, usually because the person left the company; it is hidden unless you turn off `onlyValidEmails`, and is never charged. `Not found` means no address could be found.

#### What is a catch-all address?

Some company mail servers accept every address, which makes ordinary verification impossible. The `isCatchAll` flag marks those domains; `emailScore` helps you assess confidence before sending.

#### Why did a lookup time out?

A few lookups need more than two minutes before a result is available. Those rows say "no email found within the search window (not charged)". Run them again later; they often succeed on a second try.

#### Can I use this Actor from Python?

Yes. Use the Python example in the API section, or call the Apify API from any language. Results are plain JSON.

#### How is this different from other email finders on Apify?

You pay only for verified emails. Every result carries its verification status and score, with one row per input for easy matching to your list.

### Other Actors by capable_cauldron

| Actor | What it does |
|---|---|
| [App Store Reviews Scraper](https://apify.com/capable_cauldron/app-store-reviews-scraper) | Reviews and ratings for iPhone and iPad apps, grouped by app and country |
| [Company Job Postings Scraper](https://apify.com/capable_cauldron/ats-jobs-scraper) | Open roles and hiring summaries from supported company job boards |
| [Bulk Email Validator](https://apify.com/capable_cauldron/email-validator) | Syntax, mail-routing, disposable-domain and role-inbox checks |
| [GTM Account Enrichment](https://apify.com/capable_cauldron/gtm-account-enrichment) | Public company contacts, technologies and hiring signals with an account fit score |
| [Investor Database Search](https://apify.com/capable_cauldron/investor-database-search) | Filter investors by stage, industry and geography and export available partner contacts |
| [LinkedIn Comment Scraper](https://apify.com/capable_cauldron/linkedin-comment-scraper) | LinkedIn comments and replies using your own session cookies |
| [LinkedIn Post Comments Scraper](https://apify.com/capable_cauldron/linkedin-post-comments-scraper) | Comments, replies and reactions on public LinkedIn posts without cookies |
| [LinkedIn Profile Posts & Comments Scraper](https://apify.com/capable_cauldron/linkedin-profile-posts-comments-scraper) | Posts from any LinkedIn profile with up to 50 comments and replies per post, no cookies needed |
| [LinkedIn Profile Posts Scraper](https://apify.com/capable_cauldron/linkedin-profile-posts-scraper) | Public profile posts with 56 enriched fields, including engagement and content metadata |
| [Ad Scraper: Meta, Google, LinkedIn & TikTok](https://apify.com/capable_cauldron/multi-channel-ad-intelligence) | Competitor ads from Meta, Google, LinkedIn and TikTok in one dataset |
| [TikTok Shop USA Scraper](https://apify.com/capable_cauldron/tiktok-shop-usa-scraper) | US product, shop, creator and shoppable-video data from TikTok Shop |
| [Website Contact Scraper](https://apify.com/capable_cauldron/website-contact-scraper) | Public emails, phone numbers and social profile links from company websites |
| [Website Tech Stack Detector](https://apify.com/capable_cauldron/website-tech-stack-detector) | Visible website technologies and the evidence supporting each detection |
| [LinkedIn Post Search Scraper](https://apify.com/capable_cauldron/linkedin-post-search-scraper) | Keyword searches for public LinkedIn posts with text, authors and engagement |

### Support

Found a bug, or a profile where you expected an email? Open an issue on the Actor's **Issues** tab with the input (no API keys, please). Issues are usually answered within 24 hours. Custom work (bulk mode for 50,000+ contacts, direct CRM sync, phone numbers) is available on request.

# Actor input Schema

## `linkedinUrls` (type: `array`):

LinkedIn profile links, one per line, e.g. https://www.linkedin.com/in/williamhgates. Sales Navigator people links also work. Each link becomes one row.

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

People without a LinkedIn link: objects like {"fullName": "Jane Doe", "domain": "acme.com"}, or strings like "Jane Doe, acme.com". Each person becomes one row.

## `onlyValidEmails` (type: `boolean`):

When on, the email column is filled only for addresses verified as Valid. Rows are kept for every input either way, with the status explaining what happened.

## `includePersonalEmails` (type: `boolean`):

LinkedIn lookups only: when no work email exists, return a personal address (e.g. gmail.com) instead.

## `includeGenericEmails` (type: `boolean`):

LinkedIn lookups only: when no work email exists, return a generic company address (e.g. info@company.com) instead.

## `maxConcurrency` (type: `integer`):

How many lookups run at once (1 to 5).

## Actor input object example

```json
{
  "linkedinUrls": [
    "https://www.linkedin.com/in/williamhgates"
  ],
  "people": [
    {
      "fullName": "Satya Nadella",
      "domain": "microsoft.com"
    }
  ],
  "onlyValidEmails": true,
  "includePersonalEmails": false,
  "includeGenericEmails": false,
  "maxConcurrency": 4
}
```

# Actor output Schema

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

One item per input: found flag, email, status, score, catch-all flag, name, title, company, LinkedIn URL.

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

Run status and counts of successful, unsuccessful, invalid and timed-out lookups.

# 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 = {
    "linkedinUrls": [
        "https://www.linkedin.com/in/williamhgates"
    ],
    "people": [
        {
            "fullName": "Satya Nadella",
            "domain": "microsoft.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("capable_cauldron/verified-work-email-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 = {
    "linkedinUrls": ["https://www.linkedin.com/in/williamhgates"],
    "people": [{
            "fullName": "Satya Nadella",
            "domain": "microsoft.com",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("capable_cauldron/verified-work-email-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 '{
  "linkedinUrls": [
    "https://www.linkedin.com/in/williamhgates"
  ],
  "people": [
    {
      "fullName": "Satya Nadella",
      "domain": "microsoft.com"
    }
  ]
}' |
apify call capable_cauldron/verified-work-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,capable_cauldron/verified-work-email-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/O0yfsg8LvW9sOeFEV/builds/jGDggd1JjfPNj96fG/openapi.json
