# Smart Email Finder & Verifier - No API Key (`ninhothedev/email-finder-scraper`) Actor

$1/1K 🔥 Fast email finder & verifier! Discover & guess company emails from any domain, DNS-MX verified — no key. JSON, CSV, Excel or API in seconds. Drop domains or names & pull thousands of leads for cold outreach & recruiting ⚡

- **URL**: https://apify.com/ninhothedev/email-finder-scraper.md
- **Developed by:** [ninhothedev](https://apify.com/ninhothedev) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## Smart Email Finder & Verifier 🔎✉️ (No API Key)

**Find and verify business email addresses from a company domain — or a person's name — and confirm deliverability with DNS-MX checks. No API key, no monthly seat, no fragile third-party portal.**

This Actor combines the two techniques every email-finding tool relies on, and does both in one cheap run:

1. **Discover** — it fetches a company's homepage and common contact pages (`/`, `/contact`, `/about`, `/impressum`, `/team`, `/kontakt`) and extracts every real email address it can find — including `mailto:` links, plain-text addresses, and obfuscated ones like `name [at] domain [dot] com` or `hello@company.com`. It also grabs `tel:` phone numbers.
2. **Guess** — for a given person (first + last name), it generates the common corporate email patterns (`john.doe@`, `jdoe@`, `johndoe@`, `john@`, …) at that company's domain.

Every candidate email is then **verified for deliverability without SMTP**: the Actor confirms the domain publishes valid **MX records** via Google DNS-over-HTTPS and validates the address syntax, then flags **disposable** providers. See *How verification works* below for why this is the honest, reliable signal.

***

### 💡 Use cases

- **B2B lead generation** — turn a list of company domains into a list of verified contact emails.
- **Cold outreach & sales prospecting** — find the decision-maker's likely address and confirm the domain accepts mail before you send.
- **Recruiting & talent sourcing** — reach candidates when only a name + employer is known.
- **List building & CRM enrichment** — append emails + phone numbers to accounts you already have.
- **Deliverability hygiene** — screen an existing list for dead domains (`no_mx`) and disposable addresses before a campaign.

***

### 🚀 Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `discover` (scrape pages for emails + phones) or `guess` (person → corporate patterns). Default `discover`. |
| `domains` | array | Company domains, e.g. `["stripe.com", "apify.com"]`. Scheme/path stripped automatically. Used in both modes. |
| `firstName` | string | Person's first name (guess mode). |
| `lastName` | string | Person's last name (guess mode). |
| `pages` | array | Page paths to scrape per domain (discover mode). Default `["/","/contact","/about","/impressum","/team"]`. |
| `maxItems` | integer | Max output rows (1–1000). Default `100`. |

#### Example — discover

```json
{ "mode": "discover", "domains": ["apify.com", "stripe.com"] }
```

#### Example — guess

```json
{ "mode": "guess", "domains": ["stripe.com"], "firstName": "John", "lastName": "Doe" }
```

### 📤 Output

Each row is one email (or phone). Example:

```json
{
  "type": "email",
  "email": "hello@apify.com",
  "source": "discovered",
  "pattern": null,
  "domain": "apify.com",
  "mx_found": true,
  "mx_host": "aspmx.l.google.com",
  "syntax_valid": true,
  "disposable": false,
  "status": "mx_ok",
  "found_on_url": "https://apify.com/contact",
  "person": null,
  "scraped_at": "2026-07-19T18:40:00+00:00"
}
```

Guessed rows include `pattern` (e.g. `{first}.{last}`) and `person`; discovered phone rows use `type: "phone"` with a `phone` field. Status is one of `mx_ok`, `no_mx`, `invalid_syntax`.

***

### 🔬 How verification works (and why no SMTP)

Most "verifiers" claim to do an SMTP `RCPT TO` handshake against the mail server. From cloud/datacenter IPs — where scrapers run — that handshake is **routinely blocked, greylisted, or returns catch-all lies**, so the "valid" flag is often meaningless. Instead, this Actor uses the honest, reproducible signals:

- **MX records** via Google DNS-over-HTTPS (`https://dns.google/resolve`) — proves the domain is configured to *receive* mail. No MX ⇒ the address cannot be delivered (`no_mx`).
- **Strict syntax validation** — RFC-ish local-part + alphabetic TLD.
- **Disposable-domain detection** — flags Mailinator, Guerrilla Mail, 10MinuteMail and friends as risky.

This never probes the target mail server, never leaks your intent, and never gets your IP blocked. `mx_ok` means *"valid syntax on a domain that accepts mail"* — the strongest signal you can get cleanly.

***

### 💰 Pricing

Priced to **undercut Hunter.io, Snov.io and Apollo** — roughly **$1 per 1,000 emails** processed, pay-as-you-go, no monthly seat and no credit expiry. Run it on a handful of domains or ten thousand; you only pay for what you use.

| | This Actor | Hunter.io / Snov.io |
|---|---|---|
| API key required | ❌ No | ✅ Yes |
| Monthly seat / subscription | ❌ No | ✅ Yes |
| DNS-MX verified | ✅ Yes | ✅ Yes |
| Discover + Guess in one run | ✅ Yes | Separate credits |
| Phone numbers | ✅ Yes (tel:) | Limited |

***

### 🔗 Related Actors by this author

- [Email Verifier](https://apify.com/ninhothedev/email-verifier)
- [Website Contact Extractor](https://apify.com/ninhothedev/website-contact-extractor)
- [OSM Local Business Scraper](https://apify.com/ninhothedev/osm-local-business-scraper)
- [Website Tech Stack Detector](https://apify.com/ninhothedev/website-tech-stack-detector)

***

### ⚖️ Legal & GDPR

Scrape and process only publicly available business contact data, and use it in line with GDPR/CAN-SPAM and applicable local law. You are the data controller for how you use the output. This tool does not send email.

**Keywords:** email finder, email verifier, email checker, MX record lookup, lead generation, B2B leads, cold outreach, email pattern, contact scraper, no API key.

# Actor input Schema

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

How to obtain candidate emails. 'discover' scrapes each domain's homepage + contact pages for real emails and phone numbers. 'guess' generates common corporate email patterns for a given person. Both modes verify every email via DNS MX.

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

Company domains to process, e.g. "stripe.com". Scheme/path are stripped automatically. Used in both modes.

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

Person's first name. Required in 'guess' mode (with or without last name) to generate email patterns. Ignored in 'discover' mode.

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

Person's last name. Used together with first name in 'guess' mode to build patterns like john.doe@domain. Ignored in 'discover' mode.

## `pages` (type: `array`):

Relative page paths fetched per domain when discovering emails. Common contact/team/imprint pages are best. Only used in 'discover' mode.

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

Maximum number of output rows (emails + phones) to produce across all domains. Keeps runs cheap and predictable.

## Actor input object example

```json
{
  "mode": "discover",
  "domains": [
    "stripe.com",
    "apify.com"
  ],
  "firstName": "John",
  "lastName": "Doe",
  "pages": [
    "/",
    "/contact",
    "/about",
    "/impressum",
    "/team",
    "/kontakt"
  ],
  "maxItems": 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",
        "apify.com"
    ],
    "pages": [
        "/",
        "/contact",
        "/about",
        "/impressum",
        "/team",
        "/kontakt"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ninhothedev/email-finder-scraper").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",
        "apify.com",
    ],
    "pages": [
        "/",
        "/contact",
        "/about",
        "/impressum",
        "/team",
        "/kontakt",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("ninhothedev/email-finder-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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.com"
  ],
  "pages": [
    "/",
    "/contact",
    "/about",
    "/impressum",
    "/team",
    "/kontakt"
  ]
}' |
apify call ninhothedev/email-finder-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ninhothedev/email-finder-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/irltFuen5dnvmeq8T/builds/YsRXOMIYoxQJEnvBG/openapi.json