# Email Finder & Verifier — B2B Lookup + MX (`intelscrape/email-finder-verified`) Actor

Find and verify business emails from name+domain or website crawl. Pattern candidates + MX checks. Bulk-ready dataset. No LinkedIn. Website mailto scrape + MX pattern waterfall. Labels: public\_listing vs candidate/mx\_only.

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

## Pricing

from $2.00 / 1,000 dataset items

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

## Email Finder & Verifier — B2B Lookup + MX

![Actor Banner](https://api.apify.com/v2/key-value-stores/PyvJzfQg02FD3RYhd/records/email-finder-verified-banner.png)

**Email finder & verifier for B2B lookup** — find publicly listed contact emails from websites you supply, plus optional MX-checked pattern candidates from name + domain. Bulk-ready dataset. No Hunter key. No breach data. No LinkedIn.

Pay per dataset item (`apify-default-dataset-item`). Misses can be omitted.

### What it does

| Mode | Behavior |
|---|---|
| **Website** | Fetches homepage + common `/contact` paths on **your** domains/URLs and extracts `mailto:` / visible emails |
| **Patterns** | Builds common `name@domain` formats and confirms the domain has **MX** records |
| **Both** | Runs website scrape then pattern candidates |
| **Verify** (`emails[]`, any mode) | Checks a list you already have: syntax → MX → role / free / disposable flags → `confidence` 0-100 and `status` good | risky | bad with a `reason`. Every checked address is returned. `good` = syntax + MX pass (max confidence 65) — never a confirmed mailbox. An address that is both in `emails[]` and found on a crawled page is returned once, as the verify row. Addresses are lowercased and unicode domains punycoded; `inputEmail` keeps what you sent. Rows beyond `maxItems` are not checked (the run status message says how many were). |

### Outdo checklist (vs typical email finder APIs)

- Query-first **Email Finder & Verifier** title for Store/Google
- Name+domain pattern waterfall with **MX validation**
- Website crawl emails (not just patterns)
- Bulk people/domains input → dataset out
- Role-account-aware confidence labels (`candidate` / `mx_only` / `public_listing`)
- No LinkedIn scrape, no breach corpora, no bundled paid enrichment keys

### What it deliberately does *not* do

- No Hunter / Apollo / paid enrichment APIs
- No SMTP RCPT probing (Apify blocks outbound port 25; would require a buyer-supplied external verifier)
- No LinkedIn scraping, no credential stuffing, no breach dumps
- Pattern results are labeled `candidate` / `mx_only` — never claimed deliverable

### Input

```json
{
  "emails": ["info@iana.org", "not-an-email"],
  "mode": "both",
  "domains": ["iana.org"],
  "startUrls": [{ "url": "https://www.iana.org/contact" }],
  "people": [{ "fullName": "Example User", "domain": "iana.org" }],
  "maxItems": 20,
  "onlyReturnFound": true
}
```

### Output fields

`email`, `domain`, `source` (`website` | `pattern_mx` | `verify`), `sourceUrl`, `mxValid`, `mxHost`, `mailProvider`, `pattern`, `confidence`, `status` (`found` | `candidate` | `not_found` | `input_error` for finder rows; `good` | `risky` | `bad` for verify rows), `reason` (verify rows only), `verificationLevel` (`public_listing` | `mx_only`), `isRoleAccount`, `roleScore`, `isFreeProvider`, `isDisposable`, `checks`, `inputEmail` (verify rows), `note`, `foundAt`

### Pricing

PAY\_PER\_EVENT: each `Actor.pushData` item bills `apify-default-dataset-item`. Actor start is a separate small event.

### Related IntelScrape tools

- [Website Contact Scraper — Email & Phone Finder](https://apify.com/intelscrape/contact-info-scraper) — named contacts + emails/phones from company sites
- [Google Maps Email Extractor](https://apify.com/intelscrape/google-maps-email-extractor) — local business emails from Maps leads

### Soft CTA (cross-sell mesh) — SOFTCTA\_LINKS\_EMAIL\_FINDER\_1\_2\_9

Every email/verify row (and the batch summary) includes a `softCta` object pointing to related IntelScrape Actors:

- **Skip Trace PRO** / **TruePeopleSearch** / **Watson** — deepen people intel from a name or email
- **Google Maps Email Extractor** / **Website Leads** / **Contact Info Scraper** — harvest more company emails from domains and sites

SoftCTA is additive metadata only. PPE pricing and billing events are unchanged. Skip Trace PRO code stays frozen (links only).

# Actor input Schema

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

Optional. Verify addresses you already have: syntax, MX record, role / free-provider / disposable flags, 0-100 confidence and good | risky | bad status with a reason. No SMTP probing — "good" means syntax + MX pass, never a confirmed mailbox. Runs in every mode; every checked address is returned (onlyReturnFound does not apply).

## `startUrls` (type: `array`):

Pages or homepages you own permission to scrape. The Actor fetches each page (and optional contact paths) and extracts mailto: / visible email addresses. No paid API.

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

Bare domains. Homepage + common contact paths are fetched. Example: example.org

## `people` (type: `array`):

Optional. Generates common address patterns for name@domain and checks MX only (no SMTP / no paid verifier). Never claims mailbox deliverability.

## `fullName` (type: `string`):

Full name for a single pattern+MX lookup (titles/suffixes stripped).

## `firstName` (type: `string`):

First/given name for a single pattern+MX lookup.

## `lastName` (type: `string`):

Last name/surname for a single pattern+MX lookup.

## `domain` (type: `string`):

Company domain for a single lookup (also used as a website scrape target when mode includes website).

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

website = scrape public emails from pages. patterns = MX-checked pattern candidates only. both = do both.

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

Max pages fetched per domain (homepage + contact paths + optional sitemap/homepage link discovery).

## `patternTier` (type: `string`):

How many name-based address formats to emit as MX-checked candidates.

## `includeRoleCandidates` (type: `boolean`):

Also emit info@ / contact@ / sales@ candidates when MX is valid.

## `excludeRoleAccounts` (type: `boolean`):

When true, skip ROLE local-parts (info@, contact@, sales@, support@, …) on website pushes and do not emit role:\* pattern candidates. Overrides includeRoleCandidates. Role demotion (non-role first, lower confidence, roleScore) still applies when this is false.

## `useSitemapCrawl` (type: `boolean`):

For each domain, fetch /sitemap.xml, /sitemap\_index.xml, and robots.txt Sitemap: lines; collect same-origin URLs whose path matches contact|about|support|team|help|connect and add them to the crawl set (still capped by maxPagesPerDomain). Also discovers those links from the homepage HTML.

## `onlyReturnFound` (type: `boolean`):

Omit miss / input-error rows from website and pattern modes (recommended for PPE). Verify rows from emails\[] are always returned — bad ones are the point.

## `maxItems` (type: `integer`):

Hard cap on dataset items pushed (and therefore billed).

## `proxyConfiguration` (type: `object`):

Optional. Useful if target sites rate-limit datacenter IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.iana.org/contact"
    }
  ],
  "domains": [
    "iana.org"
  ],
  "people": [
    {
      "fullName": "Example User",
      "domain": "iana.org"
    }
  ],
  "mode": "both",
  "maxPagesPerDomain": 6,
  "patternTier": "core-4",
  "includeRoleCandidates": true,
  "excludeRoleAccounts": false,
  "useSitemapCrawl": true,
  "onlyReturnFound": true,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Email rows pushed to the default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.iana.org/contact"
        }
    ],
    "domains": [
        "iana.org"
    ],
    "people": [
        {
            "fullName": "Example User",
            "domain": "iana.org"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("intelscrape/email-finder-verified").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 = {
    "startUrls": [{ "url": "https://www.iana.org/contact" }],
    "domains": ["iana.org"],
    "people": [{
            "fullName": "Example User",
            "domain": "iana.org",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("intelscrape/email-finder-verified").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 '{
  "startUrls": [
    {
      "url": "https://www.iana.org/contact"
    }
  ],
  "domains": [
    "iana.org"
  ],
  "people": [
    {
      "fullName": "Example User",
      "domain": "iana.org"
    }
  ]
}' |
apify call intelscrape/email-finder-verified --silent --output-dataset

```

## MCP server setup

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

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/YBqvtJzADcdXSe1Ae/builds/gDdvHkzyHo06otfZY/openapi.json