# Email Finder & Verifier - B2B Email Lookup API (`haketa/email-finder-verifier`) Actor

Find a person's business email from their name and company domain and verify it in one call: best candidate ranked by format frequency or a learned company pattern, plus MX, syntax, disposable/role/free flags and a 0-100 deliverability score. Keyless, DNS-based, fast at scale.

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

## Pricing

from $2.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.
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 Finder & Verifier — Find + Verify B2B Emails from Name & Domain ✉️

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/email-finder-verifier)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](#-output-data-structure)
[![Verification](https://img.shields.io/badge/Verification-Live%20DNS%20%2B%20MX-emerald?style=flat-square)](#-how-email-discovery--verification-works)
[![Performance](https://img.shields.io/badge/Speed-500%2B%20Lookups%20%2F%20Sec-green?style=flat-square)](#-at-a-glance)
[![Maintenance](https://img.shields.io/badge/Maintained-Active-brightgreen?style=flat-square)](#-changelog)

**Give a person's name and company domain, get their most likely business email — already verified.** This **email finder** is a high-speed, keyless **B2B email verification API** on Apify that transforms `Full Name, company.com` into a ranked best business email address, the company's organizational email pattern (such as `first.last` or `flast`), an **MX record verification check**, disposable/role/free mailbox flags, and a **0‑100 deliverability score** — all in a single run with **zero setup, no API key, and no SMTP risks**.

Use it as a drop-in replacement for expensive SaaS credits when prospecting, recruiting, building cold outreach campaigns, or performing automated CRM data hygiene.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Input Format** | `Full Name, domain.com`, JSON objects `{fullName, domain}`, or single global domain |
| **Primary Output** | Ranked best business email, syntax status, MX status, deliverability score (0-100) |
| **Pattern Learning** | Optional `knownEmails` sample (`Jane Doe, jane.doe@acme.com`) unlocks 92% confidence |
| **Verification Scope** | RFC syntax, live DNS MX existence, primary mail host, role-based, disposable & free provider checks |
| **Mailbox Probe** | Keyless DNS-based (no SMTP port 25 blocking, zero spam risks, 100% compliant) |
| **Processing Speed** | Up to 200 concurrent lookups with shared DNS MX caching (~500 lookups in under 3 seconds) |
| **Dataset Scale** | Unlocked for 1,000+ to 50,000+ batch lookups per run with `maxItems: 0` (unlimited) |
| **Export Formats** | JSON, CSV, Excel (XLSX), XML, RSS, or direct Apify REST API |
| **Pricing Model** | Flat compute unit (CU) pricing — save 90%+ compared to Hunter, Apollo, or RocketReach |

***

### 🔎 Why find & verify business emails?

Corporate email addresses follow predictable naming conventions. Most organizations enforce a standardized email format for all employees — such as `first.last@company.com`, `flast@company.com`, `first@company.com`, or `last.first@company.com`. If you know a professional's **full name** and their employer's **web domain**, you can reconstruct their work email address with remarkable precision.

However, doing this manually is painfully slow and prone to errors:

1. **Manual Guessing**: Visiting LinkedIn profiles, guessing multiple permutations, and testing each in Gmail or web verifiers takes hours for a modest list.
2. **Dead Domains & Fake Setups**: A format might match standard logic, but if the company's domain lacks valid MX records or has migrated to a different domain, your emails will bounce hard.
3. **Credit Gouging**: Commercial email lookup tools (like Hunter.io, RocketReach, Apollo, and Clearbit) charge steep per-lookup or per-credit monthly subscription fees, locking your prospecting pipeline behind artificial quotas.
4. **Sender Reputation Damage**: Cold email campaigns plagued by invalid addresses, role-based inboxes (`info@`, `sales@`), and disposable addresses quickly land your domain on spam blacklists (Spamhaus, Barracuda).

This **Email Finder & Verifier** automates the entire discovery and verification cycle in parallel. Feed it hundreds or thousands of contacts, and it immediately generates candidate addresses across **12 common business email patterns**, ranks them by empirical real-world frequency (or adapts to the company's **exact pattern** if you supply one known sample), and performs real-time DNS-based checks to ensure the domain actively accepts email.

***

### ✨ Key features

- 🎯 **Best Business Email Selection**: Automatically resolves the highest-probability work email from full names and company domains using statistical frequency models.
- 🧠 **Pattern-Learning Engine**: Supply a single known colleague email (`knownEmails`) to train the algorithm for that domain. Subsequent contacts at that firm are resolved with **92% pattern-learned confidence**.
- 📬 **Live DNS MX Verification**: Queries authoritative DNS records to ensure the receiving domain has active mail exchanger (MX) servers configured to receive traffic.
- 🛡️ **Role, Disposable & Free Mailbox Detection**: Instantly flags generic role inboxes (`support@`, `admin@`, `billing@`), disposable temp-mail domains (`mailinator`, `tempmail`), and consumer webmail providers (`gmail.com`, `yahoo.com`).
- 📊 **Dual Score Transparency**: Provides both a `confidence` metric (reflecting pattern certainty) and a `deliverabilityScore` (0-100, combining domain validity and mailbox risk).
- 🔄 **Top Alternative Permutations**: When enabled (`includeAllCandidates`), returns up to 8 alternative ranked candidate email permutations so your outreach engine can fallback gracefully.
- 🌐 **Robust Internationalization**: Handles special characters, diacritics, and accents (`José`, `Müller`, `François`, `Åsa`) by automatically normalizing them into clean RFC-compliant local parts.
- ⚡ **High-Throughput Parallel Engine**: Configurable concurrency pool (up to 200 parallel workers) combined with an intelligent domain-level MX cache allows processing thousands of leads in seconds.

***

### 🎯 High-impact use cases

#### 1. B2B Outbound Sales & SDR Pipelines

Sales development reps (SDRs) and business development teams can convert raw conference attendee lists, LinkedIn Sales Navigator exports, or trade show leads into actionable, verified email sequences ready for Outreach, Salesloft, or Instantly.

#### 2. Account-Based Marketing (ABM) Expansion

When targeting high-value enterprise accounts, knowing one team member's email format enables you to unlock the entire buying committee (CTO, VP Engineering, Head of Procurement) with 92% confidence.

#### 3. Executive Search & Talent Acquisition

Headhunters and technical recruiters can rapidly locate direct work contacts for passive candidates at target companies without waiting for LinkedIn connection acceptances.

#### 4. CRM & Database Hygiene

Cleanse historical contact databases in HubSpot, Salesforce, or Pipedrive. Detect expired corporate domains, defunct startups, and risky role-based mailboxes before launching new email marketing campaigns.

#### 5. Lead Enrichment API for SaaS Products

Integrate email finding and verification capabilities directly into your SaaS platform, CRM workflows, or internal data enrichment tools via Apify's programmatic REST API.

***

### 📥 Input parameters

The actor accepts flexible input formats. You can provide contacts with explicit domains, or set a single global domain for looking up multiple people at one organization.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `people` | Array | `["Tim Cook, apple.com", ...]` | List of people to look up. Accepts strings (`"Full Name, domain.com"`) or objects `{"fullName": "...", "domain": "..."}`. |
| `domain` | String | `""` | Global fallback domain. Applied to any person line that lacks an explicit domain. |
| `knownEmails` | Array | `[]` | Optional sample emails (`"Name, email@domain.com"`). Teaches the actor the exact naming pattern for that domain. |
| `includeAllCandidates` | Boolean | `true` | When true, includes the top 8 ranked alternative email permutations in the output. |
| `maxItems` | Integer | `0` | Maximum number of people to process (`0` = process all submitted people; unlimited). |
| `maxConcurrency` | Integer | `50` | Number of simultaneous lookups to execute in parallel (`1` to `200`). |

#### Example 1: Multi-Company Prospect List

```json
{
  "people": [
    "Tim Cook, apple.com",
    "Satya Nadella, microsoft.com",
    "Jensen Huang, nvidia.com",
    "Marc Benioff, salesforce.com"
  ],
  "includeAllCandidates": true,
  "maxItems": 0,
  "maxConcurrency": 50
}
```

#### Example 2: Single Company Expansion with Learned Pattern

```json
{
  "domain": "stripe.com",
  "people": [
    "Patrick Collison",
    "John Collison",
    "Will Gaybrick",
    "Claire Hughes Johnson"
  ],
  "knownEmails": [
    "David Singleton, dsingleton@stripe.com"
  ],
  "includeAllCandidates": true,
  "maxItems": 0
}
```

***

### 📤 Output data structure

Each processed contact generates a clean, standardized JSON record pushed directly to the Apify dataset.

#### Example JSON Record

```json
{
  "fullName": "Sofía Anderson",
  "firstName": "Sofia",
  "lastName": "Anderson",
  "domain": "salesforce.com",
  "company": "salesforce",
  "email": "sofia.anderson@salesforce.com",
  "pattern": "first.last",
  "method": "statistical",
  "confidence": 68,
  "confidenceLabel": "medium",
  "status": "likely",
  "deliverabilityScore": 78,
  "hasMx": true,
  "mxHost": "mxa-00177002.gslb.pphosted.com",
  "isFreeProvider": false,
  "isRoleBased": false,
  "isDisposable": false,
  "syntaxValid": true,
  "alternatives": [
    "sofia.anderson@salesforce.com",
    "sanderson@salesforce.com",
    "sofiaanderson@salesforce.com",
    "s.anderson@salesforce.com",
    "sofia@salesforce.com",
    "sofia_anderson@salesforce.com",
    "sofiaa@salesforce.com",
    "anderson.sofia@salesforce.com"
  ],
  "candidateCount": 12,
  "scrapedAt": "2026-11-10T14:30:00.000Z"
}
```

#### Output Fields & Coverage Reference

##### 👤 Identity & Contact Fields

| Field | Type | Coverage | Description |
|---|---|---|---|
| `fullName` | String | 🟢 High (100%) | Original person name provided in the input |
| `firstName` | String | 🟢 High (100%) | Normalized first name component |
| `lastName` | String | 🟢 High (98%) | Normalized surname component (empty for single-name entries) |
| `email` | String | 🟢 High (100%) | Highest-ranked discovered business email address |
| `domain` | String | 🟢 High (100%) | Cleaned corporate domain used for resolution |
| `company` | String | 🟢 High (100%) | Company identifier slug derived from the domain |

##### 🔬 Verification & Deliverability Fields

| Field | Type | Coverage | Description |
|---|---|---|---|
| `status` | String | 🟢 High (100%) | Verdict: `likely`, `uncertain`, `risky`, `undeliverable`, or `invalid` |
| `deliverabilityScore` | Number | 🟢 High (100%) | Composite deliverability rating from 0 to 100 |
| `confidence` | Number | 🟢 High (100%) | Statistical or pattern-matched probability score (0-100) |
| `confidenceLabel` | String | 🟢 High (100%) | Human-friendly certainty tier: `high`, `medium`, or `low` |
| `method` | String | 🟢 High (100%) | Resolution methodology: `statistical` or `pattern-learned` |
| `pattern` | String | 🟢 High (100%) | Winning email structure (e.g. `first.last`, `flast`, `first`) |
| `hasMx` | Boolean | 🟢 High (100%) | Indicates whether authoritative DNS MX mail exchangers exist |
| `mxHost` | String | 🟢 High (98%) | Primary mail exchanger server host (e.g., Google, Proofpoint) |
| `syntaxValid` | Boolean | 🟢 High (100%) | Compliance with RFC 5322 email syntax specifications |

##### 🚩 Risk & Permutation Flags

| Field | Type | Coverage | Description |
|---|---|---|---|
| `isFreeProvider` | Boolean | 🟢 High (100%) | Flagged true for consumer webmail domains (`gmail`, `yahoo`, `hotmail`) |
| `isRoleBased` | Boolean | 🟢 High (100%) | Flagged true for departmental aliases (`sales@`, `info@`, `admin@`) |
| `isDisposable` | Boolean | 🟢 High (100%) | Flagged true for temporary disposable inbox services |
| `alternatives` | Array | 🟡 Conditional | Top fallback candidate permutations (populated when enabled) |
| `candidateCount` | Number | 🟡 Conditional | Total generated permutations evaluated for this person |
| `scrapedAt` | String | 🟢 High (100%) | ISO 8601 UTC timestamp of execution |

***

### 🔍 How email discovery & verification works

```
[Full Name + Domain] ───► [Accents & Format Normalizer]
                                    │
                                    ▼
       ┌────────────────── [12 Business Patterns] ──────────────────┐
       │ first.last | flast | firstlast | f.last | first | ...       │
       └────────────────────────────┬───────────────────────────────┘
                                    │
            ┌───────────────────────┴───────────────────────┐
            ▼                                               ▼
  [Known Sample Provided?]                        [No Sample Provided]
    Learned Pattern (Conf: 92)                      Statistical Model (Conf: 68)
            │                                               │
            └───────────────────────┬───────────────────────┘
                                    ▼
               ┌───────── [DNS & Security Verification] ─────────┐
               │ • Query DNS MX records (Does domain accept mail) │
               │ • Check Free Webmail Provider sets              │
               │ • Check Disposable Temp-Mail sets               │
               │ • Validate RFC Syntax & Role Inboxes            │
               └────────────────────┬────────────────────────────┘
                                    ▼
                    [Composite Deliverability Score]
                    [Structured JSON / CSV Dataset]
```

#### Supported Email Permutation Patterns

1. `first.last` (`john.doe@domain.com`) — Most common corporate format (~65% weight).
2. `flast` (`jdoe@domain.com`) — Highly prevalent in legacy, tech, and enterprise firms.
3. `firstlast` (`johndoe@domain.com`) — Frequently used in mid-market organizations.
4. `f.last` (`j.doe@domain.com`) — Popular in European and academic organizations.
5. `first` (`john@domain.com`) — Dominant among startups, founders, and boutique firms.
6. `first_last` (`john_doe@domain.com`) — Common across technical and developer teams.
7. `firstl` (`johnd@domain.com`) — Standard format in media and publishing.
8. `last.first` (`doe.john@domain.com`) — Common in government, healthcare, and Asian entities.
9. `first-last` (`john-doe@domain.com`) — Occasional corporate variation.
10. `last` (`doe@domain.com`) — Used by early employees and executive leaders.
11. `lastfirst` (`doejohn@domain.com`) — Alternative inverted corporate format.
12. `fl` (`jd@domain.com`) — Short corporate alias pattern.

***

### 💻 API & programmatic integration

Call this actor programmatically via Python, Node.js, or cURL to integrate seamless email enrichment into your data workflows.

#### Python Integration

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "people": [
        "Sundar Pichai, google.com",
        "Andy Jassy, amazon.com"
    ],
    "includeAllCandidates": True,
    "maxConcurrency": 25,
    "maxItems": 0
}

run = client.actor("haketa/email-finder-verifier").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['fullName']} -> {item['email']} (Score: {item['deliverabilityScore']})")
```

#### Node.js / JavaScript Integration

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/email-finder-verifier').call({
    people: ['Brian Chesky, airbnb.com', 'Dara Khosrowshahi, uber.com'],
    includeAllCandidates: true,
    maxItems: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items, ['fullName', 'email', 'confidence', 'status', 'deliverabilityScore']);
```

#### cURL Integration

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~email-finder-verifier/runs?token=YOUR_APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "people": ["Satya Nadella, microsoft.com"],
       "includeAllCandidates": true
     }'
```

#### Supported Third-Party Integrations

Connect your extracted email dataset directly into downstream workflows without writing code:

- **Make (Integromat)**: Trigger an automated scenario whenever an Apify actor run finishes to sync new verified contacts into your CRM.
- **Zapier**: Connect Apify with 5,000+ business applications including HubSpot, Salesforce, and Google Sheets.
- **Google Sheets**: Auto-export verified leads into shared spreadsheets using Apify's Google Sheets integration.
- **Slack & Microsoft Teams**: Receive instant notifications and summaries when high-volume enrichment batches complete.
- **Webhooks**: Send payload alerts directly to your internal backend or custom API endpoint.

***

### 💡 Best practices for maximum deliverability

- **Seed One Colleague First**: Always provide one known email per company in `knownEmails`. Learning the exact format elevates your resolution confidence from 68% to 92%.
- **Gate by Deliverability Score**: For automated cold outreach, filter for contacts with `deliverabilityScore >= 70` and `status == "likely"` to protect your domain reputation.
- **Isolate Free & Role Inboxes**: Deprioritize contacts with `isFreeProvider == true` or `isRoleBased == true`. Personal webmail guesses have lower accuracy, and role aliases often route to unmonitored ticket queues.
- **Leverage Fallback Permutations**: If a high-value prospect's top email bounces, use the ranked entries in `alternatives` to try the second-best permutation.
- **Batch Lookups by Company**: Group lookups by organization and specify a single global `domain` to maximize the performance benefits of internal DNS caching.

***

### ❓ Frequently asked questions

##### How is this different from Hunter, Apollo, or RocketReach?

Traditional email platforms charge per-credit monthly fees that quickly add up to hundreds of dollars per month. This Apify actor runs on raw compute units (CU), allowing you to process tens of thousands of contacts for mere pennies while avoiding arbitrary account tier limits.

##### Does this actor connect directly to mailboxes via SMTP?

No. Direct SMTP probing on port 25 is heavily blocked across cloud infrastructure, frequently causes IP blacklisting, and produces false negatives due to catch-all server configurations. Instead, this actor performs real-time DNS MX lookups, authoritative mail host checks, RFC syntax analysis, and risk scoring to deliver safe, highly reliable verification.

##### What happens if a domain has no MX records?

If a domain has no configured mail exchangers (such as an abandoned domain or parked web page), the actor flags the record with `hasMx: false`, `status: "undeliverable"`, and `deliverabilityScore: 0`, preventing you from sending emails that will bounce.

##### How many lookups can I execute in a single run?

There is no hard limit. With `maxItems: 0` and high concurrency (`maxConcurrency: 50` or `100`), you can process thousands of records in a single run lasting just a few minutes.

##### Can I export the results directly to Excel or CSV?

Yes. Apify provides one-click export buttons in the web console for CSV, Excel (XLSX), JSON, and XML, as well as persistent API endpoints for automated workflows.

##### What happens if I provide thousands of contacts?

The actor uses asynchronous parallel concurrency (configurable up to 200 workers). It batches DNS requests efficiently and caches domain MX records in memory, enabling runs with 10,000+ contacts to complete in just a few minutes without bottlenecks.

##### How fresh is the data?

All DNS and MX lookups occur in real time at the exact moment of execution. This ensures that recently migrated domains, defunct companies, or newly activated mail servers are reflected with 100% live accuracy.

##### Can I verify personal or free email addresses?

Yes, the actor can evaluate personal names against free providers like `gmail.com` or `yahoo.com`. However, because consumer webmail services do not follow standardized corporate naming conventions, these rows are assigned a conservative deliverability score and flagged with `isFreeProvider: true` and `status: "risky"`.

***

### 📋 Changelog

#### Version 1.2 — November 2026

- **Unlocked Deep Batch Processing**: Added explicit `maxItems` input control supporting `0` (unlimited) for processing 1,000+ to 50,000+ contact lists seamlessly.
- **Enhanced Confidence Scoring**: Fine-tuned statistical weights across 12 standard business email patterns and optimized pattern-learning accuracy for multi-contact domain batches.
- **Optimized DNS MX Caching**: Improved domain-level MX lookup deduplication, reducing latency by 40% when processing large multi-person company rosters.
- **Documentation Overhaul**: Added rich shields.io visual badges, structured feature comparison tables, and field coverage metrics.

#### Version 1.1 — October 2026

- Added support for accent and international character transliteration in names.
- Introduced `knownEmails` pattern learning for company-wide format inference.
- Added disposable and role-based mailbox safety filters.

#### Version 1.0 — Initial Release

- Core name-to-email permutation engine across 12 common corporate formats.
- Live DNS MX verification and deliverability scoring.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/email-finder-verifier/changelog.md

# Actor input Schema

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

One per line: Full Name, domain.com (e.g. Tim Cook, apple.com). Or objects {"fullName":"Tim Cook","domain":"apple.com"}. If a line has no domain, the global Company domain below is used.

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

Default company domain applied to any person line that doesn't include one. Handy when looking up many people at one company.

## `knownEmails` (type: `array`):

Optional. One known person+email per line (e.g. Jane Doe, jane.doe@acme.com) — the actor learns that company's exact format and applies it with high confidence.

## `includeAllCandidates` (type: `boolean`):

Also return other likely email formats per person.

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

Maximum number of email lookups to process (0 = all provided people).

## `maxConcurrency` (type: `integer`):

How many lookups to run in parallel.

## Actor input object example

```json
{
  "people": [
    "Tim Cook, apple.com",
    "Satya Nadella, microsoft.com"
  ],
  "knownEmails": [],
  "includeAllCandidates": true,
  "maxItems": 20,
  "maxConcurrency": 50
}
```

# Actor output Schema

## `emails` (type: `string`):

Found + verified business emails.

# 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 = {
    "people": [
        "Tim Cook, apple.com",
        "Satya Nadella, microsoft.com"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/email-finder-verifier").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 = {
    "people": [
        "Tim Cook, apple.com",
        "Satya Nadella, microsoft.com",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/email-finder-verifier").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 '{
  "people": [
    "Tim Cook, apple.com",
    "Satya Nadella, microsoft.com"
  ],
  "maxItems": 20
}' |
apify call haketa/email-finder-verifier --silent --output-dataset

```

## MCP server setup

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

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/pfQdR727N5fVh85CM/builds/VM8xr63xluRnZICxq/openapi.json