# Work Email Finder by Name & Domain — Verified 📧 $25/1k (`sputnikapi/work-email-finder`) Actor

Find work email candidates from a name + company site domain: ranked candidates with per-candidate deliverability evidence and optional SMTP verification. Works straight from a CSV. $25 per 1,000 names that produce candidates — a quarter of the old price. Nothing found = nothing charged.

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

## Pricing

from $25.00 / 1,000 email candidates 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

## Work Email Finder — find & verify work emails by name and domain

> **$25 per 1,000 names that produce candidates — a quarter of what this
> listing charged before, and roughly half the going rate for name+domain
> email discovery.** A dry lookup is a free row with an explanation.

Turn a person's **name + company site domain** into ranked **work email
candidates** — with the deliverability evidence spelled out, not hidden.
Optional SMTP verification of the best candidate, billed as its own event
only when the verifier actually answered.

### Why this one

1. **You pay for found people, not attempts.** A charge fires only when a
   lookup produced candidates — after the row is already in your dataset.
   Shelf alternatives bill per pattern *tested* or per row *pushed*; here a
   dry lookup is a free row with an explanation.
2. **Honest by design.** Every candidate carries its own validity flag —
   `valid` only when actually confirmed, `unknown` when not. We never dress
   a pattern guess up as a verified address. The receiving mail gateway is
   on the row, so you can judge catch-all domains yourself.
3. **Verification is a choice, not a bundle.** `verifyTopCandidate: true`
   SMTP-checks the best candidate per found person and stamps `valid` /
   `invalid` / catch-all — billed separately, only on answer.

### Who is this for

- **Outbound teams** turning "name + company" lead lists into send-ready
  addresses with known risk.
- **CRM hygiene**: re-find addresses for contacts who changed employers.
- **Verification-first flows** that refuse to burn sender reputation on
  guesses.

### Input

Structured:

```json
{
  "lookups": [
    { "domain": "microsoft.com", "full_name": "Satya Nadella" },
    { "domain": "acme.com", "first_name": "Jane", "last_name": "Smith" }
  ],
  "verifyTopCandidate": false
}
```

…or a CSV (paste rows or link a file) with a `domain` column
(`domain` / `company_domain` / `website`) and a name column (`full_name`,
or `first_name` + `last_name`). Up to 1,000 lookups per run — for bigger
lists use our Bulk People Enrichment (CSV) actor as the front door.

### What you get — evidence, not just an address

| Group | Fields |
|---|---|
| Best candidate | `email` — the top-ranked address, `email_validity` — its deliverability verdict |
| Every candidate | the full ranked `candidates` list — each with its own `validity` flag and the receiving mail `gateway`, so you can judge catch-all domains yourself |
| Count | `candidate_count` — how many candidates the evidence supports |
| Verification (opt-in) | `verification.status` (SMTP verdict), `verification.domain_catchall`, `verification.gateway` |
| Honesty meta | `_status`, `_input` echo, `_error` explanations on refused rows |

### Output

One row per person:

```json
{
  "_status": "found",
  "_input": { "domain": "microsoft.com", "name": "Satya Nadella" },
  "email": "s•••@microsoft.com",
  "email_validity": "valid",
  "candidate_count": 4,
  "candidates": [
    { "email": "s•••@microsoft.com", "validity": "valid", "gateway": "outlook-com.olc.protection.outlook.com" },
    { "email": "satya.n•••@microsoft.com", "validity": "unknown", "gateway": "outlook-com.olc.protection.outlook.com" }
  ],
  "verification": { "status": "valid", "domain_catchall": false, "gateway": "outlook-com.olc.protection.outlook.com" }
}
```

*(addresses masked here, not in the answer; the `verification` block appears
when `verifyTopCandidate: true` and the verifier answered)*

The **Output tab** shows two views: *Overview* (one line per person) and
*All candidates* (the full ranked evidence).

### Pricing

| Event | Price | When |
|---|---|---|
| Email candidates found | $0.10 | ranked candidates delivered |
| Top candidate verified | $0.006 | SMTP check answered |
| Nothing found / invalid row | **$0** | always free |

Your free $5 Apify credit ≈ **200 found emails**.

### FAQ

**Why per found person and not per verified email?** Because verification
is a separate risk decision. You get the evidence either way; you pay for
the SMTP check only when you asked for it and it answered.

**What about catch-all domains?** The verdict says so explicitly — a
catch-all `valid` is marked as such, not sold as a confirmed inbox.

**A name wasn't found — do I pay?** No. Your bill equals your found count.

**Is this compliant?** Candidates are derived from public professional and
domain data. We honor removal requests — contact us via the Issues tab.

### The family

Same engine, other doors: **Reverse Email Lookup** (email → person),
**Profile Lookup** (URL → profile), **Company Employees Finder** (domain →
roster), **People/Company Database Search**, **Name-to-Profile** (name + company → profile), **Social Handle Lookup** (dev/social handle → person), **Bulk People 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

## `lookups` (type: `array`):

One object per person: { "domain": "acme.com", "full\_name": "Jane Smith" } — or first\_name + last\_name instead of full\_name.

## `csv` (type: `string`):

Paste CSV rows or a link to a CSV file. Needs a domain column (domain / company\_domain / website) and a name column (full\_name, or first\_name + last\_name). At most 1000 rows per run.

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

SMTP-check the best candidate of each found person and stamp the verdict (valid / invalid / catch-all) on the row. Billed separately per verification.

## Actor input object example

```json
{
  "lookups": [
    {
      "domain": "microsoft.com",
      "full_name": "Satya Nadella"
    }
  ],
  "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 = {
    "lookups": [
        {
            "domain": "microsoft.com",
            "full_name": "Satya Nadella"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sputnikapi/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 = { "lookups": [{
            "domain": "microsoft.com",
            "full_name": "Satya Nadella",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("sputnikapi/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 '{
  "lookups": [
    {
      "domain": "microsoft.com",
      "full_name": "Satya Nadella"
    }
  ]
}' |
apify call sputnikapi/work-email-finder --silent --output-dataset

```

## MCP server setup

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