# Email Verifier for Leads (Google Maps ready) - $0.50/1k (`xarso/email-verifier-for-leads`) Actor

Clean emails from Google Maps and lead scrapes. Get valid / invalid / disposable / typo verdicts plus a lead-quality rating: does the email match the business website, who hosts its mail, is the site still online. Business name, website and phone kept next to each email. Unknown results are free.

- **URL**: https://apify.com/xarso/email-verifier-for-leads.md
- **Developed by:** [xarso](https://apify.com/xarso) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 email verifieds

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 Verifier for Leads (Google Maps ready)

Clean the emails from your **Google Maps Scraper** results, or any lead list, in one step. Paste the dataset ID from your scrape and get back a ready-to-use lead list: every email with a **valid domain / invalid / disposable / typo** verdict, a **lead quality rating (high / medium / low)**, and the **business name, website, phone and city** right next to it.

**You only pay for decisive results.** If a domain's DNS can't be checked, the email is marked `unknown` and you are not charged for it.

### Why use this email verifier?

- **Built for scraped leads.** Point it at a Google Maps Scraper dataset and it finds emails in `email`, `emails` and `leadsEnrichment` automatically. No CSV exports, no copy-paste.
- **Scores the lead, not just the address.** Tells you whether the email belongs to the business's own domain, who hosts its mail (Google Workspace, Microsoft 365...) and whether the business website is still online. A dead website usually means a closed business.
- **Keeps the context.** Each verified email stays attached to the business it came from, so the output is a lead list you can import straight into your outreach tool.
- **Fast and cheap.** Thousands of emails in minutes, with mail-server lookups shared across every address on the same domain.
- **Fair billing.** Unknown results are free.
- **Protects your sender reputation.** Remove invalid and disposable addresses before a cold email campaign and keep your bounce rate low.

### What it checks

| Check | What it means |
|---|---|
| Syntax | The address is well-formed |
| Typo suggestion | `john@gmial.com` → suggests `gmail.com` |
| Disposable | Temporary inbox providers (10,000+ domains) |
| Role address | Shared inboxes like `info@`, `sales@`, `support@` |
| Free provider | Gmail, Yahoo, Outlook and similar |
| Mail server (MX) | The domain can receive email |
| Matches business website | The email uses the same domain as the business's website (e.g. `info@joespizza.com` for joespizza.com) |
| Mail provider | Google Workspace, Microsoft 365, Zoho, GoDaddy, self-hosted... |
| Website online | The business website (or the email's domain) still answers |

> **Coming soon:** mailbox-level (SMTP) verification and catch-all detection.

### How to verify emails from Google Maps

1. Run [Google Maps Scraper](https://apify.com/compass/crawler-google-places) with contact details enabled.
2. Copy the **dataset ID** from the run's Storage tab.
3. Paste it into **Dataset ID** here and click **Start**.
4. Download the verified list as CSV, Excel or JSON, or send it on with Make, Zapier or n8n.

You can also paste a plain list of emails into **Emails**.

### Input

```json
{
    "datasetId": "YOUR_DATASET_ID",
    "emails": ["info@example.com"],
    "checkWebsite": true,
    "maxEmails": 0,
    "concurrency": 10
}
```

### Output

One row per unique email:

```json
{
    "email": "info@joespizza.com",
    "status": "valid_domain",
    "quality": "high",
    "score": 80,
    "reason": "Domain receives email; mailbox not checked; matches the business's website",
    "sourceName": "Joe's Pizza",
    "sourceWebsite": "https://joespizza.com",
    "sourcePhone": "+1 212 555 0100",
    "sourceCity": "New York",
    "matchesBusinessWebsite": true,
    "mailProvider": "Google Workspace",
    "websiteAlive": true,
    "isRoleBased": true,
    "isFreeProvider": false,
    "isDisposable": false,
    "didYouMean": null,
    "mxHost": "mx.joespizza.com"
}
```

#### Status values

- `valid_domain` — well-formed, not disposable, and the domain receives email. Score is lower for shared inboxes like `info@`.
- `invalid` — bad syntax, a typo of a big provider (`gmial.com`), or a domain with no mail server. Remove it.
- `disposable` — a temporary inbox. Remove it.
- `unknown` — the domain's DNS couldn't be checked. **Not charged.**

#### Lead quality

- `high` — deliverable domain plus strong signals (e.g. matches the business website, managed mail provider). Send first.
- `medium` — deliverable, fewer signals (e.g. shared `info@` inbox, unknown provider).
- `low` — deliverable domain but warning signs (e.g. business website is down). Send last or skip.
- `bad` — invalid or disposable. Remove.

Filter on `quality` to send to your best leads first.

A run summary with counts per status is saved as `SUMMARY` in the key-value store.

### Pricing

Pay per event: you are charged once per email with a decisive result (`valid_domain`, `invalid`, `disposable`). `unknown` results are free.

### Works well with

- [Business Opportunity Scorer for Agencies](https://apify.com/xarso/data-tools): score the same Google Maps businesses for sales opportunities (no website, unclaimed listing, low rating...) and get a ready opening line for each one.

### FAQ

**Does it send emails?** No. It only checks the address format and the domain's mail records.

**Does it confirm the mailbox exists?** Not yet. Mailbox-level (SMTP) checks are coming in the next version.

**Can I use it from my own code or an AI agent?** Yes, through the Apify API, the official clients, or the Apify MCP server.

**Is it legal?** Verifying that an address can receive mail is standard practice for email hygiene. You are responsible for how you use the contacts and for complying with anti-spam and data protection laws (such as CAN-SPAM and GDPR) in your outreach.

### Feedback

Found a wrong verdict or need a field added? Open an issue on the Actor's Issues tab and it will be looked at quickly.

# Actor input Schema

## `datasetId` (type: `string`):

ID of a dataset with your leads, e.g. the output of Google Maps Scraper with contact details enabled. Emails are read from the 'email', 'emails' and 'leadsEnrichment' fields automatically, and the business name and website are kept next to each email.

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

A list of email addresses to verify. Can be combined with a dataset ID. Duplicates are removed.

## `emailField` (type: `string`):

Optional. Field in your dataset that holds the email (dot notation allowed, e.g. 'contact.email'). Leave empty for automatic detection.

## `checkWebsite` (type: `boolean`):

Checks whether the business website (or the email's domain) is online. A dead website usually means a closed business and a dead inbox. Adds a few seconds per new domain.

## `maxEmails` (type: `integer`):

Stop after this many unique emails. 0 = no limit.

## `concurrency` (type: `integer`):

How many emails to verify in parallel.

## Actor input object example

```json
{
  "emails": [
    "info@apify.com",
    "someone@gmial.com"
  ],
  "checkWebsite": true,
  "maxEmails": 0,
  "concurrency": 10
}
```

# Actor output Schema

## `verifiedLeads` (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 = {
    "emails": [
        "info@apify.com",
        "someone@gmial.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xarso/email-verifier-for-leads").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 = { "emails": [
        "info@apify.com",
        "someone@gmial.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xarso/email-verifier-for-leads").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 '{
  "emails": [
    "info@apify.com",
    "someone@gmial.com"
  ]
}' |
apify call xarso/email-verifier-for-leads --silent --output-dataset

```

## MCP server setup

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

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/JcB1bNeD98GciqJ5g/builds/g46j5QkPJ8GQP60y2/openapi.json