# Email Checker / Verifier (`scrapers-hub/email-checker-verifier`) Actor

Email Checker / Verifier validates addresses with syntax, MX, SMTP and Gravatar checks and returns a reachability verdict for each one. ✅ Cuts bounce rates and protects sender reputation before cold outreach or newsletter sends.

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

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Checker / Verifier – SMTP Validation, MX Lookup & Deliverability Scoring

The **Email Checker / Verifier** is an email verification actor that runs a full SMTP-level validation on any email address and returns a structured deliverability verdict instead of a simple yes/no guess. It checks syntax against RFC rules, resolves the domain's MX records, opens a real SMTP conversation with the receiving mail server, and reports whether the mailbox is reachable — plus useful signals such as whether the address is disposable, a role account, or a B2C consumer mailbox.

This email verification tool is built for people who care about sender reputation: cold outreach teams cleaning a prospect list, SaaS products validating sign-ups, CRM administrators purging stale contacts, and anyone who has watched a bounce rate creep toward the threshold where an ESP starts throttling delivery. Single addresses and batches are both supported, and every SMTP parameter that matters — HELO name, MAIL FROM identity, port, timeout, retries — is configurable so you can tune the handshake to match how your production mail server actually behaves.

***

### 📊 What Data Can You Extract with This Email Verification Scraper?

Each verified address produces one dataset item containing the following grouped signals.

| Category | Fields | What you get |
|---|---|---|
| 🔤 Syntax validation | `syntax` | Object with the parsed `address`, `domain`, `username` and an `is_valid_syntax` flag |
| 📬 Deliverability verdict | `is_reachable` | The headline result for the address — the field most integrations key off |
| 🌐 Domain & mail routing | `mx` | Whether the domain `accepts_mail` plus the full list of resolved MX `records` |
| 🔌 SMTP conversation | `smtp` | The outcome of the live SMTP handshake, including any structured error object returned |
| 🕵️ Risk & profile signals | `misc` | Disposable-address detection, role-account detection, B2C classification, Gravatar URL and breach-related hints |
| 🧪 Run diagnostics | `debug`, `input`, `error` | Backend name, start/end timestamps, the original input address, and an error message when a check fails |

The single most useful field for most workflows is `is_reachable`, because it collapses the syntax check, the MX lookup and the SMTP probe into one verdict you can branch on. But do not throw away `mx` and `smtp` — when `is_reachable` comes back as `unknown`, those two objects tell you *why*, which is the difference between "this mailbox does not exist" and "this provider refused the probe".

***

### 🌟 Key Features of the Email Checker / Verifier

| Feature | Description |
|---|---|
| 🔍 Real SMTP probing | Connects to the recipient's mail server and walks the SMTP conversation rather than guessing from the domain alone |
| 📦 Batch verification | Pass an `emails` array to validate a whole list in a single run; `email` handles the one-off case |
| 🧾 RFC syntax parsing | Splits every address into username and domain and flags malformed input before any network call is made |
| 🌐 MX record resolution | Resolves and returns the domain's mail exchangers, so you can see exactly which infrastructure handles the mailbox |
| 🗑️ Disposable detection | The `misc` object flags throwaway and temporary-mailbox providers commonly used to bypass sign-up gates |
| 👥 Role-account flagging | Identifies shared addresses such as info@, support@ and sales@ that skew engagement metrics in cold outreach |
| 🖼️ Optional Gravatar lookup | Enable `check_gravatar` to see whether the address has a registered Gravatar image and profile URL |
| ⚙️ Tunable SMTP handshake | `from_email`, `hello_name`, `smtp_port`, `smtp_timeout` and `retries` let you mirror your production sender identity |
| 🔄 Automatic proxy rotation | Outbound requests are routed through rotating proxies managed by the actor, with no proxy setup required from you |

***

### 🚀 Why Choose This Email Verification Scraper?

**Transparent verdicts, not black-box scores.** Many verification services return a single opaque grade. This actor returns the raw evidence alongside the verdict: the MX records it resolved, the SMTP error object it received, the syntax breakdown it parsed. When you need to justify why an address was dropped from a campaign, the evidence is in the dataset.

**Built for list hygiene at scale.** The `emails` array accepts an entire batch in one run, and each address becomes its own dataset item with its own `input` value, so results map cleanly back to source rows in a CRM export or a spreadsheet column.

**Honest about uncertainty.** A large share of mail providers deliberately accept every recipient during the SMTP handshake, or block probes outright. Instead of pretending otherwise, the actor reports `is_reachable` as `unknown` and puts the underlying SMTP error in the `smtp` object so you can decide how to treat that segment.

**Configurable to match your sending identity.** Deliverability behaviour changes with the HELO name and MAIL FROM address you present. Because both are inputs, you can run verification using the same domain identity your production mail server uses, which produces results far closer to what a real send would experience.

***

### 📥 Input

```json
{
  "email": "xyz.mikolabs@gmail.com",
  "from_email": "reacher.email@gmail.com",
  "hello_name": "gmail.com",
  "smtp_timeout": 15,
  "smtp_port": 25,
  "retries": 1,
  "check_gravatar": false
}
```

#### 🔧 Email Verifier Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `email` | string | Yes | `xyz.mikolabs@gmail.com` | The single email address to verify. Use `emails` (array) instead to check a batch. |
| `emails` | array | No | — | Optional list of email addresses to verify in one run. If provided, `email` is ignored. |
| `from_email` | string | No | `reacher.email@gmail.com` | Email address used in the SMTP MAIL FROM command during verification. |
| `hello_name` | string | No | `gmail.com` | Domain name announced in the SMTP HELO/EHLO greeting. |
| `smtp_timeout` | integer | No | `15` | How long to wait for each SMTP step before giving up, in seconds. |
| `smtp_port` | integer | No | `25` | TCP port used to connect to the target mail server. |
| `retries` | integer | No | `1` | Number of retry attempts on transient SMTP/network failures. |
| `check_gravatar` | boolean | No | `false` | If true, looks up whether the email has a registered Gravatar image. |

#### 💡 Input Examples

Verify a single address with default settings:

```json
{
  "email": "jane.doe@example.com"
}
```

Verify a batch and enrich each result with a Gravatar lookup:

```json
{
  "emails": [
    "sales@acme.io",
    "jane.doe@example.com",
    "throwaway@mailinator.com"
  ],
  "check_gravatar": true
}
```

Use a stricter timeout and your own sender identity for a large list:

```json
{
  "emails": ["contact@startup.dev", "hello@agency.co"],
  "from_email": "verify@yourdomain.com",
  "hello_name": "yourdomain.com",
  "smtp_timeout": 8,
  "retries": 2
}
```

***

### 📤 Output

```json
{
  "input": "xyz.mikolabs@gmail.com",
  "is_reachable": "unknown",
  "syntax": {
    "address": "xyz.mikolabs@gmail.com",
    "domain": "gmail.com",
    "username": "xyz.mikolabs",
    "is_valid_syntax": true
  },
  "mx": {
    "accepts_mail": true,
    "records": [
      "gmail-smtp-in.l.google.com.",
      "alt1.gmail-smtp-in.l.google.com."
    ]
  },
  "smtp": {
    "error": {
      "type": "SmtpError",
      "message": "Proxy CONNECT to gmail-smtp-in.l.google.com:25 failed"
    }
  },
  "misc": {
    "is_disposable": false,
    "is_role_account": false,
    "is_b2c": true,
    "gravatar_url": null
  },
  "debug": {
    "backend_name": "reacher-cli",
    "start_time": "2026-08-08T15:44:32.259525Z",
    "end_time": "2026-08-08T15:44:47.183000Z"
  }
}
```

#### 🧾 Email Verification Output Fields

| Field | Type | Description |
|---|---|---|
| `input` | string | null | The email address that was submitted for verification. |
| `is_reachable` | string | null | The deliverability verdict for the address. |
| `syntax` | object | null | Parsed address components and the RFC syntax validity flag. |
| `mx` | object | null | Whether the domain accepts mail and the MX records resolved for it. |
| `smtp` | object | null | Result of the SMTP handshake, including a structured error object when the probe fails. |
| `misc` | object | null | Risk and profile signals such as disposable, role-account, B2C and Gravatar data. |
| `debug` | object | null | Backend name and start/end timestamps for the individual check. |
| `error` | string | null | Error message, if the item failed to process. |

***

### 💻 How to Use the Email Checker / Verifier (Step by Step)

#### Step 1: Open the actor and choose single or batch mode

Start on the actor's Input tab. If you only need to check one address — validating a form submission, confirming a contact before a manual send — put it in the `email` field and leave everything else alone. If you have a list, put it in the `emails` array instead. When `emails` is populated it takes priority and `email` is ignored entirely, so you never need to clear one to use the other.

#### Step 2: Set the SMTP identity you want to present

The `hello_name` and `from_email` values are what the receiving mail server sees during the handshake. Defaults are provided so the actor works out of the box, but results are more representative when these match the domain you actually send from. If your production mail flows from `yourdomain.com`, set `hello_name` to `yourdomain.com` and `from_email` to a real, monitored address on that domain.

#### Step 3: Tune timeouts, port and retries for your list size

`smtp_timeout` controls how long each SMTP step waits before giving up, and `smtp_port` selects the TCP port used for the connection — port 25 is the standard mail-transfer port and the default here. For a big batch, a shorter timeout keeps the run moving; for a small, high-value list, a longer timeout and `retries` of 2 or 3 will squeeze out more definitive answers from slow servers.

#### Step 4: Decide whether to enable the Gravatar lookup

Setting `check_gravatar` to true adds an extra lookup per address against the Gravatar service and populates the `gravatar_url` value inside `misc`. It is genuinely useful for enrichment — a registered Gravatar is weak evidence that the address belongs to an active human — but it does add work per address, so leave it off for pure deliverability runs.

#### Step 5: Run the actor and watch the log

Click Start. The log narrates each address as it moves through syntax parsing, MX resolution and the SMTP probe. Watch for repeated connection failures against a single provider early on; that usually signals a network-level block rather than genuinely dead mailboxes, and it is cheaper to adjust settings after ten addresses than after ten thousand.

#### Step 6: Read the results in the dataset

Each verified address becomes one dataset item. Open the Dataset tab and use the table view to scan `is_reachable` across the batch, then drill into individual rows to see the `smtp` and `mx` objects behind each verdict. The `input` field carries the original address, so you can join results back to the row they came from.

#### Step 7: Export or push the verified list downstream

Export the dataset as JSON, CSV or Excel from the Apify console, or pull it through the API into your own pipeline. A typical pattern is to write `is_reachable` and the `misc.is_role_account` flag back onto the contact record in your CRM, then use those two fields as suppression rules for future campaigns.

***

### 🔌 API Access & Integrations

Run the email verification actor synchronously and get the dataset items back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~email-checker-verifier/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "emails": ["jane.doe@example.com", "sales@acme.io"],
    "check_gravatar": true,
    "smtp_timeout": 15
  }'
```

The same run from Python using the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/email-checker-verifier").call(
    run_input={
        "emails": ["jane.doe@example.com", "sales@acme.io"],
        "smtp_timeout": 15,
        "retries": 2,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["input"], "->", item["is_reachable"])
```

Because the results land in a standard Apify dataset, you can wire them into Zapier, Make, Google Sheets or Slack, or fire a webhook on run completion to push verified addresses straight into your CRM or ESP.

***

### 💡 Best Use Cases for Email Verification Data

#### 🧹 Cold outreach list cleaning

Before a sequence goes out, run the whole prospect list through the verifier and drop everything where `is_reachable` indicates the mailbox will not accept mail. Combining that with `misc.is_role_account` lets you also strip generic inboxes that inflate your send volume without ever producing a reply.

#### 📝 Sign-up and lead-form validation

Point the actor at addresses captured by a form and use `syntax.is_valid_syntax` as a fast first filter, then `mx.accepts_mail` to confirm the domain can receive mail at all. Flagging `misc.is_disposable` at this stage stops throwaway addresses from claiming free trials and polluting your activation metrics.

#### 🛡️ Sender reputation protection

High bounce rates are the fastest route to throttling and blocklisting. Verifying ahead of each send and suppressing anything where the `smtp` object shows a hard rejection keeps your bounce ratio low, which protects inbox placement for the addresses that *do* matter.

#### 🗃️ CRM data hygiene and re-permissioning

Databases decay as people change jobs. Periodically re-verifying stored contacts and writing `is_reachable` plus the `debug.end_time` timestamp back onto each record gives you a defensible freshness signal, and makes it easy to route stale contacts into a re-permission campaign rather than a normal send.

#### 🔎 Lead enrichment and scoring

The `misc` object distinguishes consumer mailboxes from business ones through its `is_b2c` flag, and the optional `gravatar_url` adds a small identity signal. For a B2B pipeline, scoring business-domain addresses above free consumer addresses is a cheap improvement to lead quality.

#### 🚨 Fraud and abuse screening

Disposable-address detection is a practical anti-abuse control for anything with a free tier. Rejecting sign-ups where `misc.is_disposable` is true blocks a meaningful share of throwaway account creation, and the `mx.records` list lets you spot bulk registrations pointing at a single obscure mail host.

#### 📊 Deliverability diagnostics

When a campaign underperforms, verifying the affected segment and inspecting the `smtp.error` objects often shows a single provider rejecting your handshake. That is a configuration problem, not a list problem, and the raw SMTP evidence is what you need to fix it.

***

### ⚙️ Tips for Better Email Verification Results

- **Use the batch input for anything over a handful of addresses.** One run with a populated `emails` array is far more efficient than many single-address runs, and it keeps all results in one dataset for export.
- **Match `hello_name` and `from_email` to a real domain you control.** Receiving servers treat mismatched or obviously synthetic HELO identities more suspiciously, which pushes more results into the `unknown` bucket.
- **Raise `retries` rather than `smtp_timeout` for flaky domains.** Transient failures are common on port 25; a second attempt often succeeds where a longer single wait would not.
- **Treat `is_reachable` values of `unknown` as a separate segment, not as invalid.** Several major providers accept all recipients during the handshake. Sending a small, careful test batch to that segment is usually smarter than deleting it.
- **Always keep the `mx` object.** If `accepts_mail` is false, no amount of SMTP retrying will help, and you can suppress that domain wholesale.
- **Re-verify on a schedule.** Contact data ages quickly; a quarterly re-run against your active list catches departures and domain changes before they turn into bounces.

***

### 🛠️ Troubleshooting

**Why is `is_reachable` returning `unknown` for so many addresses?**
This is expected behaviour with large consumer providers and with any network path where outbound port 25 is filtered. Check the `smtp.error` object: an `SmtpError` describing a failed connection means the probe never completed, whereas a server-level rejection means the mailbox itself responded negatively. Only the second is evidence about the address.

**The SMTP step keeps timing out.**
Increase `smtp_timeout` and set `retries` to 2 or 3. Some mail servers deliberately delay responses to slow down automated probing, and a 15-second default is not always enough for them.

**Nothing happens when I fill in both `email` and `emails`.**
That is by design — when `emails` contains any values, the single `email` field is ignored. Clear the `emails` array if you want to verify just one address.

**The `misc` object shows no Gravatar data.**
The Gravatar lookup only runs when `check_gravatar` is set to true. If it is enabled and `gravatar_url` is still null, the address simply has no registered Gravatar image.

**An item came back with only an `error` value.**
The `error` field carries the message for addresses that failed to process at all — typically malformed input or a domain that would not resolve. Check the `syntax` object first; if `is_valid_syntax` is false, the address never reached the network stage.

***

### ❓ Frequently Asked Questions About Email Verification

**How does this email verification actor check if an email address is real?**
It runs three layers: an RFC syntax parse, a DNS lookup of the domain's MX records, and a live SMTP conversation with the receiving mail server. The combined result is reported in `is_reachable`, with the underlying evidence in `syntax`, `mx` and `smtp`.

**Can I verify a list of email addresses in bulk?**
Yes. Put the whole list in the `emails` array and each address becomes its own dataset item. The single `email` field is ignored whenever `emails` is populated.

**Does the email checker send an actual email to the address?**
No. The SMTP conversation stops before any message body is transmitted, so the mailbox owner receives nothing.

**What does an `is_reachable` value of `unknown` actually mean?**
It means the SMTP probe could not produce a definitive answer — usually because the provider accepts all recipients, blocks probing, or the connection failed. The `smtp` object explains which case applies.

**Can this email verifier detect disposable or temporary email addresses?**
Yes. The `misc` object includes an `is_disposable` flag that identifies throwaway mailbox providers.

**How do I identify role accounts like info@ or support@?**
The `is_role_account` flag inside the `misc` object marks shared and departmental addresses, which are usually worth suppressing in one-to-one outreach.

**Which SMTP port does the email verification tool use?**
Port 25 by default, configurable through `smtp_port`. Port 25 is the standard server-to-server mail transfer port and the one that produces the most representative results.

**Why do I need to set a HELO name and MAIL FROM address?**
Receiving servers evaluate the identity you present during the handshake. Setting `hello_name` and `from_email` to values on a domain you actually control makes the verification closer to a real delivery attempt.

**Does the actor tell me which mail provider a domain uses?**
Indirectly, yes — the `mx.records` array lists the resolved mail exchangers, which reveals whether a domain is on Google Workspace, Microsoft 365, or self-hosted infrastructure.

**Can I use this email checker for GDPR-relevant contact data?**
You can, provided you have a lawful basis for processing those addresses. Email addresses tied to identifiable individuals are personal data, and verification does not change your obligations under GDPR or comparable regimes.

**What does the Gravatar check add to the results?**
When `check_gravatar` is enabled, the `misc` object carries a `gravatar_url` value if the address has a registered Gravatar image — a small but useful signal that the address belongs to an active person.

**How do I export verified emails to a CSV file?**
Open the run's Dataset tab and export as CSV, Excel or JSON, or pull the items through the Apify API with `run-sync-get-dataset-items` and write them wherever you need.

**Does this email verification scraper need proxy configuration?**
No. Proxy rotation is handled automatically by the actor; there is no proxy setting for you to configure.

**How often should I re-verify my email list?**
For active outreach lists, a re-verification each quarter is a sensible baseline, since contact data decays steadily as people change roles and domains are retired.

**Can I integrate the email verifier with my CRM or marketing platform?**
Yes. Results sit in a standard Apify dataset, so you can reach them via the API, forward them with a webhook, or connect them through Zapier, Make, Google Sheets or Slack.

***

### 🆘 Support & Feedback

Found a bug or hit an edge case the email verification actor handles badly? Open a ticket on the **Issues** tab of this actor — it is the fastest way to get a fix, and it keeps the report attached to the run so the behaviour can be reproduced.

Need a custom build — a different verification workflow, extra enrichment fields, or an integration into an existing pipeline? Get in touch at **scraperhubapi@gmail.com** and describe what you need.

If this email checker saves you a painful bounce report, please leave a review on the actor page. Ratings genuinely help other people find tools that work.

***

### ⚖️ Disclaimer

This email verification actor performs standard DNS and SMTP protocol checks against publicly reachable mail infrastructure. It does not access mailboxes, read messages, or bypass any authentication.

You are responsible for how you use the results. Email addresses that identify individuals are personal data under GDPR, the UK GDPR, CCPA and similar frameworks; you must have a lawful basis for processing them, honour opt-outs and deletion requests, and comply with anti-spam legislation such as CAN-SPAM and PECR when contacting anyone on a verified list. Verification is not consent.

Use of this actor must also respect the terms of service of the mail providers and networks involved, as well as Apify's platform terms. Verification results are best-effort signals, not guarantees of delivery.

If you believe data processed by this actor should be removed, contact **scraperhubapi@gmail.com** with the details and it will be addressed.

# Actor input Schema

## `email` (type: `string`):

The single email address to verify. Use emails (array) instead to check a batch.

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

Optional list of email addresses to verify in one run. If provided, 'email' is ignored.

## `from_email` (type: `string`):

Email address used in the SMTP MAIL FROM command during verification.

## `hello_name` (type: `string`):

Domain name announced in the SMTP HELO/EHLO greeting.

## `smtp_timeout` (type: `integer`):

How long to wait for each SMTP step before giving up.

## `smtp_port` (type: `integer`):

TCP port used to connect to the target mail server.

## `retries` (type: `integer`):

Number of retry attempts on transient SMTP/network failures.

## `check_gravatar` (type: `boolean`):

If true, looks up whether the email has a registered Gravatar image.

## Actor input object example

```json
{
  "email": "xyz.mikolabs@gmail.com",
  "from_email": "reacher.email@gmail.com",
  "hello_name": "gmail.com",
  "smtp_timeout": 15,
  "smtp_port": 25,
  "retries": 1,
  "check_gravatar": false
}
```

# Actor output Schema

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

Records scraped by Email Checker / Verifier, stored in the run's 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/email-checker-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/email-checker-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 '{}' |
apify call scrapers-hub/email-checker-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/email-checker-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/rURfBRbGp21YeZd37/builds/NC8TmeudO6teHGgOO/openapi.json