# Email Finder and Verifier API - Domain Search, Enrichment (`nabeelbaghoor/email-finder-verifier-api`) Actor

Find business email addresses at any company domain, filtered by department, seniority, job title and decision maker, find a specific person's address by name, verify deliverability with SMTP and MX checks, and enrich a company or a person. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/email-finder-verifier-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Business, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Email Finder and Verifier API - Domain Search, Enrichment

Find business email addresses at any company domain, filtered by department, seniority, job title and decision maker status; find one specific person's address from their name and their employer; verify deliverability with regex, MX, SMTP and catch-all checks; and pull the full company or person profile behind a domain or an address. One flat row per email, person or company.

### What this actor does

- **Finds every email at a company, not just the first page.** Domain search pages through a domain until the provider runs out, so a company with 400 known addresses returns 400 rather than a truncated 100.
- **Filters before you pay, not after.** Department, seniority, job title, decision maker, personal against generic, verification status and required fields are all sent to the provider, so a search for senior sales contacts with a full name and a job title costs you those rows and not the whole company.
- **Finds a named person's address.** Give the finder a list of names and a list of domains and it pairs them up, returning the address with a confidence score, the job title, the phone number where known, and the pages the address was seen on.
- **Verifies deliverability properly.** The verifier returns the verdict, the deliverability score, and the underlying checks separately: regex validity, gibberish detection, disposable and webmail flags, MX records, the SMTP server, the SMTP check, the catch-all flag and whether the domain blocks verification.
- **Enriches companies and people.** Company enrichment returns the legal name, the description, the founding year, sector, industry, SIC and NAICS codes, employee count, revenue and funding metrics, the full geography and the technology stack. Person enrichment returns the name, job title, seniority, role, employer and location behind an address.
- **Keeps the key out of the URL.** The provider documents an api\_key query parameter; this actor sends the key as a header instead, so it never lands in a log line or a redirect.
- **Never charges for a miss.** Only rows carrying a resolved result are billed.

### Input

| Field | What it does |
| --- | --- |
| `mode` | Domain search, email finder, verifier, company enrichment or person enrichment. |
| `domains` | Company domains. Used by search, finder and company enrichment. |
| `fullNames` | Names to find addresses for. Paired with each domain. |
| `emails` | Addresses to verify or to enrich a person from. |
| `department` | Only return emails from these departments. |
| `seniority` | Only return emails at these seniority levels. |
| `jobTitles` | Only return emails whose job title matches. |
| `decisionMakersOnly` | Only return flagged decision makers. |
| `emailType` | Personal addresses, generic role addresses, or both. |
| `verificationStatus` | Only return emails with these verification verdicts. |
| `requiredFields` | Only return emails carrying a full name, job title or phone number. |
| `emailsPerDomain` | Emails per request, up to the provider's maximum of 100. |
| `maxDurationSeconds` | How long the finder may spend on one lookup. |
| `requestsPerMinute` | Pace the run under the provider's documented ceilings. |
| `skipNotFound` | Leave unresolved inputs out of the dataset. |
| `maxResults` | Hard cap on rows, and therefore on spend and run time. |
| `apiKey` | Your own API key. Stored as a secret. |

### Example output

```json
{
  "found": true,
  "mode": "domainSearch",
  "query": "example.com",
  "email": "jane.doe@example.com",
  "emailType": "personal",
  "confidence": 97,
  "firstName": "Jane",
  "lastName": "Doe",
  "fullName": "Jane Doe",
  "position": "VP of Sales",
  "seniority": "executive",
  "department": "sales",
  "decisionMaker": true,
  "phoneNumber": null,
  "linkedin": "https://linkedin.com/in/janedoe",
  "twitter": null,
  "verificationStatus": "valid",
  "verificationDate": "2026-08-02",
  "domain": "example.com",
  "organization": "Example Labs",
  "emailPattern": "{first}.{last}",
  "acceptAll": false,
  "disposable": false,
  "webmail": false,
  "sources": [
    { "domain": "example.com", "uri": "https://example.com/team", "extracted_on": "2026-05-11", "still_on_page": true }
  ],
  "raw": { }
}
```

### Frequently asked questions

#### What data does the Email Finder API return?

A domain search returns each email with its type, confidence score, first and last name, job title, seniority, department, decision maker flag, phone number, social profiles, verification verdict and date, and the pages the address was found on, alongside the organisation name and the company's email pattern. The finder returns one address with the same person fields plus its sources. The verifier returns the verdict, the score, and the regex, gibberish, disposable, webmail, MX, SMTP, catch-all and block checks separately. Company enrichment returns the legal name, description, founding year, sector, industry, SIC and NAICS codes, employee count, revenue, funding, geography and technology stack. Person enrichment returns the name, job title, seniority, role, employer and location.

#### Do I need my own API key?

Yes. This actor does not include data access. You use your own API key from Hunter, which is the provider whose email data API this actor calls, created on their dashboard. Your own plan, request allowance and terms apply. Paste the key into the `apiKey` field, where it is stored as an Apify secret and sent in a request header rather than the documented URL parameter, so it never appears in a log line or a redirect.

#### How do I build a list of just the decision makers at a company?

Run domain search, set `department` to the departments you sell into, set `seniority` to executive, and turn on `decisionMakersOnly`. Add `requiredFields` of full name and job title to drop the role addresses and half-known records. All of those filter on the provider's side, so you are charged for the people you asked for rather than for the whole company.

#### How do I get only addresses that are safe to send to?

Set `verificationStatus` to valid. The provider then returns only addresses it has verified as deliverable and leaves out the catch-all and unknown ones, which is what you want when the list is going straight into a sending tool. Keep accept all in the list as well if you would rather have catch-all domains and decide about them yourself.

#### What is the difference between a personal and a generic email?

A personal address belongs to a named person, such as jane.doe at a company. A generic address is a role mailbox such as contact, sales or support. Both are returned by default. Personal addresses are the ones worth targeting for outreach; generic ones are more useful for support routing and for reaching companies that publish no individual addresses.

#### How does the email finder work?

It takes a person and a company and returns the most likely address for that pairing, with a confidence score and the evidence behind it. Supply a list of names and a list of domains and every name is tried against every domain, so ten names at one company is ten lookups. Raise `maxDurationSeconds` when you want the provider to work harder on an address it cannot find quickly.

#### What do the verification fields actually mean?

`verificationStatus` is the verdict: valid, invalid, accept all, webmail, disposable or unknown. `confidence` is the deliverability score. The rest are the checks that produced the verdict, exposed separately so you can apply your own policy: `regexpValid` for format, `gibberish` for random-looking local parts, `disposable` for throwaway providers, `webmail` for consumer mailboxes, `mxRecords` for whether the domain accepts mail at all, `smtpCheck` for the mailbox probe, `acceptAll` for catch-all domains and `blocked` for domains that refuse verification.

#### How does this handle rate limits?

The provider documents different ceilings per route: 500 requests per minute on search and enrichment, 300 on verification, with per-second limits alongside. The actor spaces requests evenly to stay under whichever ceiling you set in `requestsPerMinute`, and treats the per-second limit response as something to wait out while treating the monthly allowance response as a reason to stop, because waiting will not fix the latter.

#### What happens when a domain or address returns nothing?

The row is written with `found: false` and an `error` giving the provider's own reason, and the run continues to the next input. Misses are not charged for. Set `skipNotFound` to true to leave them out of the dataset entirely.

#### How much does a run cost?

Pricing is pay per result: you are charged for each email, person or company returned to the dataset, and never for misses or duplicates. Apify platform usage is included in the per-result price. Your own API provider's request allowance is separate and billed by them.

### Keyword map

email finder API, email verification API, domain search API, find email by name, company email lookup, bulk email verifier, email deliverability check, SMTP verification API, catch-all domain detection, disposable email detection, B2B contact data API, decision maker emails, department filter email search, job title email search, person enrichment API, company enrichment API, email pattern detection, lead list building, sales prospecting data, CRM contact enrichment

# Actor input Schema

## `mode` (type: `string`):

Domain search returns every email the provider knows at a company domain. Email finder returns one specific person's address from their name and their company. Email verifier checks deliverability for addresses you already have. Company and person enrichment return the profile behind a domain or an address.

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

Company domains, one per line. Used by domain search, email finder and company enrichment. A pasted URL is reduced to the bare hostname and an address is reduced to the part after the at sign, so a messy list still works.

## `fullNames` (type: `array`):

Full names to find addresses for, one per line. Used by the email finder, where each name is paired with each domain above: ten names and one domain is ten lookups.

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

Email addresses, one per line. Used by the verifier and by person enrichment. An address pasted inside a longer string, such as a mail header, is extracted before the request.

## `department` (type: `array`):

Only return emails from these departments. This filters on the provider's side, so a search for the sales and marketing departments costs credits only for those people rather than for the whole company. Domain search only.

## `seniority` (type: `array`):

Only return emails at these seniority levels. Domain search only.

## `jobTitles` (type: `array`):

Only return emails whose job title matches one of these, one per line. Use it when the department and seniority filters are too coarse for the role you are actually after. Domain search only.

## `decisionMakersOnly` (type: `boolean`):

Only return people the provider has flagged as decision makers for their department. Domain search only.

## `emailType` (type: `string`):

Personal returns addresses belonging to a named person. Generic returns role addresses such as contact or support. Leave on both unless you have a reason not to: role addresses are usually the wrong target for outreach but the right one for support routing. Domain search only.

## `verificationStatus` (type: `array`):

Only return emails with these verification verdicts. Restricting to valid is the way to build a list you can send to without a separate verification pass. Domain search only.

## `requiredFields` (type: `array`):

Only return emails that carry all of these fields. Requiring a full name and a position is the quickest way to drop the role addresses and the half-known records from a list. Domain search only.

## `emailsPerDomain` (type: `integer`):

How many emails to ask for in one domain search request. The provider allows up to 100, which is the default. The actor pages through a domain until it runs out, so this changes the request count rather than the total returned.

## `maxDurationSeconds` (type: `integer`):

How long the email finder may spend on one lookup, between 3 and 20 seconds. Longer means it will keep looking for a harder address rather than giving up. Email finder only.

## `requestsPerMinute` (type: `integer`):

Pace the run under the provider's documented ceilings, which are 500 per minute on search and enrichment and 300 per minute on verification. The default of 300 is safe on every route; raise it for a search-only run to finish sooner.

## `skipNotFound` (type: `boolean`):

Leave inputs the provider had nothing for out of the dataset. Off by default, because keeping the misses is what lets you see which domains resolved and which did not. Misses are never charged for either way.

## `maxResults` (type: `integer`):

Stop after this many rows. This is the cap on both spend and run time.

## `apiKey` (type: `string`):

Your own API key for the email data API, sent in the request header rather than the documented URL parameter, so it never appears in a log line or a redirect. Required for every lookup. Stored as a secret.

## Actor input object example

```json
{
  "mode": "domainSearch",
  "domains": [
    "stripe.com"
  ],
  "department": [],
  "seniority": [],
  "decisionMakersOnly": false,
  "emailType": "both",
  "verificationStatus": [],
  "requiredFields": [],
  "emailsPerDomain": 100,
  "requestsPerMinute": 300,
  "skipNotFound": false,
  "maxResults": 100
}
```

# 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": [
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/email-finder-verifier-api").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": ["stripe.com"] }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/email-finder-verifier-api").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": [
    "stripe.com"
  ]
}' |
apify call nabeelbaghoor/email-finder-verifier-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/email-finder-verifier-api"
        }
    }
}

```

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/oOAnEo9QVAK9edbSj/builds/1nqWDXZ9NggvLW6vc/openapi.json