# Company Employee & Email Finder: Team Pages to Leads (`earlytern/company-people-email-finder`) Actor

Find the people companies list on their own websites: names, job titles, work emails and LinkedIn profiles from team, about and contact pages. Pay per person.

- **URL**: https://apify.com/earlytern/company-people-email-finder.md
- **Developed by:** [earlytern](https://apify.com/earlytern) (community)
- **Categories:** Lead generation, Business, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 person founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Company Employee & Email Finder: Team Pages to Leads

Turn a list of **company domains** into a list of **people**: the founders, leaders and staff each company publishes on
its **own website** (team, leadership, about, contact and press pages), with **job title**, **work email** when the
website publishes it, and **LinkedIn profile** when the website links it. Optionally, learn the company's **email
pattern** (`first.last@`) from the emails it publishes and fill in a **guessed email** for the other people. One row
per person, ready for your CRM or lead list. You pay only for people found.

### What does Company Employee & Email Finder do?

- **Finds the pages that list people**: reads the home page, follows its links to team, leadership, management, board,
  about, contact and press pages (in English, German, French, Spanish and Dutch), and looks in the website's sitemap
  when the home page links no team page.
- **Reads people, not noise**: names come from organization data (schema.org `Person`), from rows of team cards, from
  name-and-title lists and from email links with a name. A name must look like a person's name and come with a job
  title, an email or a LinkedIn profile. Menus, headings, testimonials and customer quotes are left out.
- **Work emails as published**: an email next to a person, on the company's own domain, goes in `email` with
  `emailSource: "found"`. Team addresses (info@, sales@) and addresses on other domains are never given to a person.
- **Email pattern and guessed emails (optional)**: with **Guess missing emails** on, the Actor learns the pattern from
  at least two published emails that follow the people's names and builds the same kind of address for people
  without one, in `guessedEmail`. Guessed emails are **not checked**.
- **One person once per company**: the same person on several pages is merged into one row.
- **Light and polite**: plain HTTP requests, no browser; always obeys robots.txt and never logs in. LinkedIn and other
  platforms are never visited.

### Who uses it?

- **Sales and SDR teams** finding decision makers (CEO, founders, heads of sales, marketing or engineering) at target
  accounts.
- **Lead generation agencies** turning a domain list into contacts with job titles.
- **Recruiters** mapping the team of a company.
- **Investors and researchers** listing the leadership of many companies.
- **AI agents** that need "who works at example.com?" in structured form.

### How to use it

1. Click **Try for free**.
2. In **Domains**, paste company domains or website addresses, one per line: `example.com`,
   `https://www.example.com/about`.
3. Optional: turn on **Guess missing emails**, or change **Pages per website** (15 by default, up to 50).
4. Click **Start**. Download the results as JSON, CSV or Excel, or use the API. The **People** view shows one row per
   person.

### Use with AI agents (MCP)

AI assistants and AI agents can call this Actor through Apify's MCP server at [mcp.apify.com](https://mcp.apify.com)
or through the Apify API. Send the whole list of domains in one call. Questions it answers well:

- "Who leads example.com?" Read `name` and `jobTitle` of the rows for that domain.
- "Find the head of sales at these 50 companies." Filter `jobTitle`.
- "What is the email of Jane Doe at example.com?" Read `email`; with guessing on, `guessedEmail` (not checked).

Only `domains` is required. Rows with `type` other than `person` are free and say why in `message`.

### Input example

```json
{
  "domains": ["creativecommons.org", "mozilla.org"],
  "maxPagesPerDomain": 15,
  "guessEmails": true
}
```

### Output example

A real row from a test run:

```json
{
  "type": "person",
  "input": "mozilla.org",
  "domain": "mozilla.org",
  "companyName": "Mozilla",
  "name": "Mark Surman",
  "firstName": "Mark",
  "lastName": "Surman",
  "jobTitle": "President, Mozilla",
  "email": null,
  "emailSource": null,
  "guessedEmail": null,
  "emailPattern": null,
  "linkedinUrl": "https://www.linkedin.com/in/msurman",
  "pageUrl": "https://www.mozilla.org/en-US/about/leadership/",
  "message": null,
  "scrapedAt": "2026-11-16T05:52:57.816Z"
}
```

This website publishes no emails for its people. For a company that does, with **Guess missing emails** on, two rows
look like this:

```json
[
  { "name": "Jane Doe", "jobTitle": "Head of Sales", "email": "jane.doe@example.com", "emailSource": "found", "guessedEmail": null, "emailPattern": "first.last@example.com" },
  { "name": "John Roe", "jobTitle": "CTO", "email": null, "emailSource": "guessed", "guessedEmail": "john.roe@example.com", "emailPattern": "first.last@example.com" }
]
```

#### Fields

| Field | What it holds |
|---|---|
| `type` | `person` for a person (charged); other values are free rows, see below |
| `input` | The line as you typed it |
| `domain` | The company's domain, without www |
| `companyName` | The company's name, from its home page |
| `name`, `firstName`, `lastName` | The person's name as the website writes it, without titles such as Dr.; `lastName` is everything after the first name, without middle initials |
| `jobTitle` | Job title as the website writes it |
| `email` | The person's work email, published on the website next to their name |
| `emailSource` | `found` (published) or `guessed` (built from the pattern); empty when there is no email |
| `guessedEmail` | Only with **Guess missing emails**: an address built from the website's email pattern. Not checked |
| `emailPattern` | Only with **Guess missing emails**: the pattern learned from the website's emails, such as `first.last@example.com` |
| `linkedinUrl` | The person's LinkedIn profile, when the website links it next to the person |
| `pageUrl` | The page the person was found on |
| `message` | Why a domain has no people, or why rows were not saved |
| `scrapedAt` | When the row was saved (UTC) |

#### Row types

| `type` | Meaning | Charged |
|---|---|---|
| `person` | One person the company publishes on its website | Yes |
| `no_people` | The website was read, but no person with a name and job title was found | No |
| `not_found` | The domain is parked or for sale, or its home page is not a web page | No |
| `needs_browser` | The home page is built with JavaScript in the browser, so its links could not be read | No |
| `blocked` | The website refused the request or shows a bot check | No |
| `robots_txt` | The website's robots.txt does not allow reading it | No |
| `unreachable` | The domain does not exist, did not answer, or answered with an error | No |
| `not_allowed` | A large platform, an IP address, a local or private network address; never contacted | No |
| `invalid` | The line is not a domain or website address | No |
| `skipped` | Not saved because the run reached your maximum cost per run | No |

### How much does it cost?

You pay only for people found. No start fee, and pages read cost nothing. Prices per 1,000 people, by Apify plan:

| Event | Free | Bronze | Silver | Gold and up |
|---|---|---|---|---|
| Person found | $2.50 | $2.00 | $1.70 | $1.40 |

- **Free**: domains without people, blocked or unreachable websites, websites that need a browser, invalid lines and
  duplicates (the same domain twice is read once).
- Guessed emails cost nothing extra: a person row is charged once, with or without an email.
- Set a **maximum cost per run** and the Actor stops cleanly before going over it. People found but not saved, and
  domains not read, get a free `skipped` row that says so.

Example on the Free plan: 1,000 domains where 300 websites list 15 people each give 4,500 people and cost $11.25.

### FAQ

**Why does a company have no people?** Many websites do not list their team, or show it only as pictures or inside
a script. The Actor returns only people the website itself names in its pages; it does not guess people or look them
up elsewhere. Such domains get a free `no_people` row.

**Are guessed emails verified?** No. A guessed email follows the pattern of the emails the same website publishes, but
it is not checked and may not exist. The Actor never contacts mail servers. Check guessed emails before you send to
them, and keep them apart from `email`, which the website publishes.

**When is an email pattern learned?** Only when the website publishes at least two work emails that follow the
people's names in the same way (for example `jane.doe@` for Jane Doe and `john.roe@` for John Roe). Otherwise
`emailPattern` stays empty and nothing is guessed.

**Does it visit LinkedIn?** No. `linkedinUrl` is a link the company's website puts next to the person. LinkedIn and
other platforms are never opened.

**Why `blocked` or `needs_browser`?** Some websites refuse automated requests or only work in a browser. The Actor does
not try to get past blocking and does not run a browser; such rows are free.

**Can I read more pages?** Raise **Pages per website** (up to 50). Team, leadership and about pages are read first,
then contact and press pages.

### Limits

- Up to 10,000 domains per run; 10 websites are read at the same time.
- Per website: robots.txt, the home page and up to **Pages per website** pages, with a pause between requests; a
  robots.txt Crawl-delay is always obeyed. When it asks for a long pause, only the two best pages are read.
- Pages on the company's own host only; other subdomains (often the same pages in another language) are not read.
- Up to 500 people per website.
- Pages larger than 3 MB are read up to 3 MB.
- The run stops in time to save its results before the run timeout; for very large lists give the run more time.

### Is it legal?

The Actor reads only public pages of company websites, always obeys robots.txt, never logs in and never tries to get
past blocking. It keeps only the fields shown above; no page text is stored.

**Personal data:** every person row is personal data under laws such as the GDPR: names, job titles, work emails and
LinkedIn profiles of people. You need a lawful basis (for example legitimate interest, with a balancing test) to store
and use it, you must tell people where you got their data and let them object, and you must follow the anti-spam rules
for cold email where you send it. Guessed emails are personal data too, and may reach the wrong person.

### Questions and feedback

Open an issue on the **Issues** tab.

# Actor input Schema

## `domains` (type: `array`):

Company domains or website addresses, one per line, for example example.com or https://www.example.com/about. Up to 10,000 per run. The same domain twice is read once.

## `maxPagesPerDomain` (type: `integer`):

Most pages read on each website, the home page included. Team, leadership and about pages are read first, then contact and press pages. Pages read are not charged.

## `guessEmails` (type: `boolean`):

When a website publishes at least two work emails that follow the people's names (for example jane.doe@), build the same kind of address for people without one. Guessed emails are not checked and may not exist; they are kept apart in guessedEmail.

## Actor input object example

```json
{
  "domains": [
    "creativecommons.org",
    "mozilla.org"
  ],
  "maxPagesPerDomain": 15,
  "guessEmails": false
}
```

# Actor output Schema

## `people` (type: `string`):

No description

## `summary` (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 = {
    "domains": [
        "creativecommons.org",
        "mozilla.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("earlytern/company-people-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 = { "domains": [
        "creativecommons.org",
        "mozilla.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("earlytern/company-people-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 '{
  "domains": [
    "creativecommons.org",
    "mozilla.org"
  ]
}' |
apify call earlytern/company-people-email-finder --silent --output-dataset

```

## MCP server setup

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