# Email to Phone Number Finder | Direct Dials & Mobile Numbers (`aeonkosmos/email-phone-finder`) Actor

Turn email addresses into phone numbers and direct dials. Get the person behind each work email — phones where available, plus name, job title, company and LinkedIn profile. Bulk: 5,000 emails per run. $0.005 per match, plus $0.010 when a phone is found.

- **URL**: https://apify.com/aeonkosmos/email-phone-finder.md
- **Developed by:** [Eugene Volper](https://apify.com/aeonkosmos) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 13 total users, 11 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.40 / 1,000 person matcheds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Email to Phone Number Finder

Turn a list of email addresses into phone numbers and direct dials.

Give the Actor work emails. It resolves each one to the person behind it and returns
their phone numbers where available — plus the name, job title, company, location and
LinkedIn profile of the match, so you can see exactly who you reached.

Free Apify accounts receive 100 starter results shared across all eight Actors. The private links in `SUPPORTER_ACCESS` let a user submit honest feedback for 500 additional results valid for 30 days, or report a reproducible bug for 500 additional results after bug confirmation. No public review or positive feedback is required. Any paid Apify plan is uncapped by this internal result allowance; normal Apify platform and Actor charges still apply.

### What you get

For every email you submit, one record:

| Field | Example |
|---|---|
| `email` | `rhoffman@greylock.com` |
| `status` | `found` / `not_found` / `skipped` / `invalid` / `error` |
| `phones` | `["+14155550123"]` |
| `hasPhone` | `true` |
| `fullName` | `Reid Hoffman` |
| `jobTitle` | `Co-Founder, Board Chair` |
| `company` | `Manas AI` |
| `linkedinUrl` | `https://www.linkedin.com/in/reidhoffman` |
| `country` | `US` |
| `industry` | `Technology, Information and Internet` |
| `workEmails` | other work addresses on file |

That example is a real, verifiable lookup — run it yourself and you get a phone number
back. Phone numbers shown in this documentation are placeholders; the Actor returns the
real numbers it finds.

Set **Include Person Details** to `false` if you only want the phone numbers.

### Input

Either fill the **Email Addresses** list, or paste addresses into **Emails (one per
line)** — one per line, or separated by commas or spaces. Both are combined,
de-duplicated and validated before any lookup runs. Up to **5,000 emails per run**.

```
rhoffman@greylock.com
nobody@example.com
```

The first resolves and returns a phone number; the second matches nobody and costs you
nothing.

### Output

Results land in the default dataset — download as JSON, CSV or Excel, or read them
through the Apify API. A run summary (resolved / not found / with phone / skipped) is
written to the key-value store under `SUMMARY`.

### Pricing

Two events, so you pay for what you actually receive:

| Event | Fires when | Price | per 1,000 |
|---|---|---|---|
| `person-matched` | an email resolves to a person | **$0.005** | $5.00 |
| `phone-found` | that person has a number on file | **$0.010** | $10.00 |

A full hit — person **and** phone — is **$0.015**. A person with no number on file costs
**$0.005**. Emails that match nobody, invalid addresses, and errors are **free**.

**Worked example** — 1,000 emails in, 840 resolve, 320 of those have a phone:

```
840 × $0.005  (matches)      = $4.20
320 × $0.010  (phones)       = $3.20
                               ------
                               $7.40   per 1,000 emails
```

Volume discounts apply automatically by your Apify plan:

| Plan | `person-matched` | `phone-found` | Full hit |
|---|---|---|---|
| Free | $0.0050 | $0.0100 | $0.0150 |
| Bronze | $0.0048 | $0.0096 | $0.0144 |
| Silver | $0.0046 | $0.0092 | $0.0138 |
| Gold | $0.0044 | $0.0088 | $0.0132 |

Plus a one-off `$0.00005` per run start. Platinum and Diamond match Gold. Every input gets
a row — unmatched, skipped and errored emails are never charged. See the **Pricing** tab
for the authoritative figures.

### Good to know

- **About 38% of matched people have a phone number on file.** Sampled across 50
  profiles: 84% resolved to a person at all, and 38% of those returned at least one
  number. A resolved contact with no number is normal — check `hasPhone` before you dial.
- **A person with no number on file costs a third of a full hit.** The lookup itself
  isn't free — the match event bills $0.005 — but you pay the phone price only when a
  number actually comes back. Each row carries `billedMatch` and `billedPhone` so you
  can see precisely what you were charged for.
- **Verify the identity, not just the address.** Matching is by email, and generic
  prefixes can land on the wrong person of the same name. Always check the returned
  `fullName` and `company` before you call — the row tells you exactly who was matched.
- **No personal email addresses or social profiles are returned.** Even when the record
  carries a personal address, a GitHub handle, or a Facebook or Twitter URL, that stays
  out of the output. Only work emails come back, alongside the name, title, company,
  LinkedIn URL and country needed to verify you reached the right person.
- Numbers come back in E.164 format (`+14155550123`) when the source provides it.
- Only addresses belonging to a real person profile resolve. Generic inboxes (`info@`,
  `sales@`, `support@`) usually return `not_found`, and those are free.

### Limits

- **5,000 emails per run.** Emails are resolved in batches of 25 at roughly 1–2 per
  second at the default concurrency, so a full 5,000-email backlog takes about an hour.
  Raising **Concurrency** shortens that; small runs finish in seconds.
- 4 parallel lookup batches maximum (upstream rate limit). The **Concurrency** setting
  controls this; 1 is the most conservative.
- **If you set a maximum spend per run**, the Actor stops the moment it is reached and
  marks the untouched emails `skipped` — you are not charged for them, and every input
  still gets a row so you can re-run precisely what was left over.

### Support

Open an issue on the Actor page and include your run ID.

# Actor input Schema

## `emails` (type: `array`):

The email addresses to look up. Each one is matched to a person profile, and phone numbers are returned when available. Free Apify accounts receive 100 results for that Actor; private feedback adds 500 for 30 days, and a confirmed bug adds 2,500. Paid Apify plans are uncapped by this internal allowance. Normal Apify charges apply.

## `emailsText` (type: `string`):

Paste a list of emails — one per line, or separated by commas/spaces. Combined with the list above.

## `includeIdentity` (type: `boolean`):

Add the matched person's name, job title, company, LinkedIn URL and location to each result. Turn off for a leaner dataset with phone numbers only.

## `concurrency` (type: `integer`):

Parallel lookup batches. Default 2. Maximum 4 (upstream rate limit).

## Actor input object example

```json
{
  "emails": [
    "rhoffman@greylock.com"
  ],
  "includeIdentity": true,
  "concurrency": 2
}
```

# Actor output Schema

## `contacts` (type: `string`):

All emails that resolved to a person profile, including phone numbers where available

# 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 = {
    "emails": [
        "rhoffman@greylock.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("aeonkosmos/email-phone-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 = { "emails": ["rhoffman@greylock.com"] }

# Run the Actor and wait for it to finish
run = client.actor("aeonkosmos/email-phone-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 '{
  "emails": [
    "rhoffman@greylock.com"
  ]
}' |
apify call aeonkosmos/email-phone-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aeonkosmos/email-phone-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/uieSXJfYo7VxrA9jt/builds/9ukSg9cZnl4cfSDbS/openapi.json