# LinkedIn Email Finder — Emails from Profile URLs 📧 $8/1k (`sputnikapi/linkedin-email-finder`) Actor

Paste LinkedIn profile URLs, get the email addresses on record — work and personal, real recorded addresses from a 1B+ profile database, not pattern guesses. $8 per 1,000 profiles that carry one; the shelf charges more and bills every attempt. A matched profile with no address is a free row.

- **URL**: https://apify.com/sputnikapi/linkedin-email-finder.md
- **Developed by:** [Sputnik API](https://apify.com/sputnikapi) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 emails 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

## LinkedIn Email Finder — the addresses on record, not pattern guesses

> **$8 per 1,000 profiles that carry an address — 20% under the shelf's email
> mode, and there you pay per attempt whether an address turns up or not.** A
> matched profile with no recorded address is a free row that still names the
> person.

Paste LinkedIn profile URLs and get back the **email addresses actually on
record** for each person — work and personal — from a database of **1B+
professional profiles**. Optional SMTP verification stamps a deliverability
verdict on the best address.

**This is a database lookup, not a live scrape and not a pattern generator.**
Most "email finder" tools guess `first.last@company.com` and let you find out
the hard way. This actor returns only addresses that exist in the profile
record — and when there are none, it says so **for free**.

### Why this one

1. **Recorded addresses, not guesses.** Every address in the row comes from
   the person's data record. Rows carry the address type (work / personal)
   and the full list — often several addresses per person.
2. **You pay only for delivered emails.** A matched profile with no recorded
   address is a **free `no_email` row** that still names the person, the
   title and the employer — so you know the match worked and can route the
   lead to a name+domain finder. Unmatched URLs are free `not_found` rows.
3. **Verification is its own event.** `verifyTopCandidate: true` SMTP-checks
   the best address; you are billed for a verification only when the
   verifier actually answered.

### Who is this for

- **Outbound teams** turning prospect lists of profile links into send-ready
  addresses.
- **Recruiters** contacting sourced candidates outside the platform inbox.
- **RevOps** enriching CRM contacts that carry a profile URL but no email.

### Input

```json
{
  "profileUrls": ["satyanadella"],
  "verifyTopCandidate": false
}
```

Links, bare handles, and mobile URLs all work; different spellings of the
same profile are folded together and looked up once.

### Output — a real found row

```json
{
  "_status": "found",
  "_input": { "profile": "satyanadella" },
  "_freshness": "fresh_90d",
  "_fullData": "https://sputnik.io/from-apify?utm_source=apify…",
  "fullName": "Satya Nadella",
  "jobTitle": "Chairman and CEO",
  "companyName": "Microsoft",
  "email": "snadella@microsoft.com",
  "emailType": "work",
  "employerMatch": true,
  "workEmails": ["snadella@microsoft.com", "satya@microsoft.com", "satya.nadella@starbucks.com"],
  "personalEmails": ["satyan@microsoft.com"],
  "emailCount": 4,
  "linkedinUrl": "https://www.linkedin.com/in/satyanadella"
}
```

`employerMatch` tells you whether the best address belongs to the domain of
the person's **current** employer. Records often carry addresses from board
seats, alumni accounts and past jobs — those sort to the back of the list,
and when nothing matches the current employer the flag says `false` instead
of letting a stale address pass as a work address.

A profile that matched but has no recorded address:

```json
{
  "_status": "no_email",
  "_input": { "profile": "some-handle" },
  "fullName": "Jane Smith",
  "jobTitle": "VP Engineering",
  "companyName": "Acme"
}
```

That row is **free** — and it hands you exactly what the name+domain route
needs: feed it to our **Work Email Finder** actor to hunt the address by
pattern + verification instead.

### Pricing

| Event | Price | When |
|---|---|---|
| Emails found | $0.008 | a profile with ≥1 recorded work or personal address, full list included |
| SMTP verification | $0.006 | `verifyTopCandidate: true` and the verifier answered |
| Matched, no address on record | **$0** | free row with name / title / employer |
| Not found / removed / invalid | **$0** | always free |

Your free $5 Apify credit ≈ **625 found email rows** (each often carrying
several addresses).

### FAQ

**Where do the addresses come from?** From the contact block of the person's
database record — publicly available professional data. Nothing is generated
or brute-forced.

**What does `no_email` mean?** The profile matched, the record has no
recorded address. It is free, and the row names the person so you can
continue with the Work Email Finder (name + company domain → ranked
candidates with deliverability evidence).

**How fresh is the data?** Every row carries a `_freshness` bucket
(`fresh_90d`, `updated_1y`, `older`) from the record's last re-confirmation.

**Is there a rate limit?** The actor paces itself; a 1,000-URL run finishes
in minutes. For 10,000+ rows use our Bulk LinkedIn & Email Enrichment (CSV)
actor.

**Is this compliant?** The database holds public professional profile data.
We honor removal requests — contact us via the Issues tab.

### The family

Same engine, other doors: **Work Email Finder** (name + domain → ranked
candidates), **Reverse Email Lookup** (email → person), **LinkedIn Profile
Scraper (Database)** (URL → full profile), **LinkedIn Company Employees**
(domain → the whole roster), **LinkedIn People Search** (filters → lists),
**Bulk LinkedIn & Email Enrichment** (CSV, 50k rows). One data core, one
billing promise: misses are free.

### Disclaimer

This Actor is an independent product and is not affiliated with, endorsed
by, or sponsored by LinkedIn Corporation. It does not access, crawl, or
scrape LinkedIn at run time — answers come from our own database of
publicly available professional data; "LinkedIn" is used only to describe
the kind of public profile data the database covers. Removal requests are
honored via the Issues tab.

# Actor input Schema

## `profileUrls` (type: `array`):

One LinkedIn profile URL or bare handle per line. Profiles without a recorded email come back as free "no\_email" rows; unmatched URLs as free "not\_found" rows.

## `verifyTopCandidate` (type: `boolean`):

Run an SMTP deliverability check on the best address of each found row and stamp the verdict on the row. Billed as its own event only when the verifier actually answered.

## Actor input object example

```json
{
  "profileUrls": [
    "satyanadella"
  ],
  "verifyTopCandidate": false
}
```

# 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 = {
    "profileUrls": [
        "satyanadella"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sputnikapi/linkedin-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 = { "profileUrls": ["satyanadella"] }

# Run the Actor and wait for it to finish
run = client.actor("sputnikapi/linkedin-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 '{
  "profileUrls": [
    "satyanadella"
  ]
}' |
apify call sputnikapi/linkedin-email-finder --silent --output-dataset

```

## MCP server setup

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