# Email Verifier, Account Finder & Domain Intel (`expanditumarca/email-verifier-account-finder-domain-intel`) Actor

Know which emails are ALIVE, not just deliverable. Personal addresses show the platforms registered to them - is a real person behind the mailbox? Corporate ones show the company behind the domain: services, age, certificate. Full verification on every row. One list, both kinds mixed.

- **URL**: https://apify.com/expanditumarca/email-verifier-account-finder-domain-intel.md
- **Developed by:** [Expandí tu Marca](https://apify.com/expanditumarca) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.20 / 1,000 email checkeds

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?

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 Verifier, Account Finder & Domain Intel

**Most email checkers only tell you the domain accepts mail. This one tells you whether somebody is actually behind the mailbox.**

Give it a list of emails. Get back, for every single one: whether the address is real, whether the mailbox is in use, and who is behind the domain.

One input, no sorting required. Personal and corporate addresses can be mixed freely in the same list — the Actor recognizes which is which and runs the check that fits each one.

> Built by **[Hi Agencia](https://hiagencia.com/?utm_source=apify\&utm_medium=actor\&utm_campaign=email-verifier-account-finder-domain-intel)** — data extraction, automation and custom software for companies that sell. Published on Apify as **Expandi tu Marca**.

***

### When To Use This Actor

Use it when you have **email addresses** and need to know which ones are worth acting on.

- Cleaning a purchased, scraped, or inherited list before it reaches an outreach tool.
- Scoring leads: separating a live personal mailbox from an abandoned one, and a real company from a landing page.
- Enriching contacts when you have the email but not the company website.
- Screening signups for throwaway addresses and generic mailboxes.
- Splitting a mixed list into people and companies in a single pass.

Do **not** use it to discover new email addresses — it verifies and enriches the ones you already have.

***

### What Makes It Different

Ordinary verification answers one question: *would a message bounce?* That leaves the expensive case untouched — the address that accepts mail and nobody reads.

**`inUse` answers that one.** For a personal address, the Actor reports which digital platforms hold an account registered to it. An address with accounts behind it belongs to somebody real and active. An address with none, on a valid domain, is usually secondary or abandoned. This is the strongest signal available without sending anything.

For corporate addresses the equivalent question is *who is behind this company?* — answered with a profile of the company's domain.

***

### How Each Address Is Handled

Every address goes through the same base check: format validity, whether the domain can receive mail, disposable-provider detection, generic-mailbox detection, and a suggested correction when the domain looks like a misspelling of a well-known one.

Then each address takes the branch that fits it:

| The address is | What it means | What you get |
|---|---|---|
| **Personal** — `john@gmail.com` | A **person** is behind the mailbox | Platform Account Detection, plus the `inUse` flag |
| **Corporate** — `info@company.com` | A **company** is behind the mailbox | Domain Intelligence on that company |

Personal addresses are recognized against a curated allowlist of **400+ consumer mail providers worldwide** — every country variant of the major webmail brands, plus the consumer ISPs of North America, the UK, Australia, Brazil, Spain, Italy, France, Germany, Eastern Europe, Asia and Latin America. Anything outside that list is treated as corporate.

***

### Input

One required field, and four optional extras that all start off.

| Field | Description | Default |
|---|---|---|
| **Emails** | The list to check. Personal and corporate mixed, in any order. Prefixes, query strings and duplicates are handled for you. | required |
| **Detected Services** | Which business services the company runs. | Off |
| **Domain Age** | When the company's domain was registered, how old it is, and its registrar. The slowest of these, and billed on its own. | Off |
| **SSL Certificate** | Certificate validity, expiry and issuer. | Off |
| **Server Location** | Country the company's server sits in. | Off |
| **Max concurrency** | Addresses processed in parallel (1-20). Raising it speeds up a large batch, up to a ceiling: one of the sources is queried one address at a time on purpose, and that sets the limit. | 10 |
| **Network strategy** | How the Actor reaches the services it queries. Automatic starts on the cheapest route and moves up only for the few checks that need it. | Automatic |

**Account detection has no switch.** It is what this Actor does, so it runs on every personal address, always. The four company lookups are the optional part: they apply only to corporate addresses, and until you turn one on it neither runs nor charges.

***

### Output

One row per address. **All fields are flat** — no nested objects — so CSV and Excel exports stay readable.

#### Always present

| Field | Meaning |
|---|---|
| `email` | The normalized address |
| `status` | `ok`, or `invalid` when the address is malformed |
| `isValid` | Well formed **and** its domain can receive mail |
| `mxValid` | The domain is configured to receive mail |
| `accountType` | `freemail` or `corporate` — which branch the address took |
| `provider` | Provider brand for personal addresses (Gmail, Outlook, Yahoo, Libero, Comcast, UOL, Naver...) |
| `isDisposable` | The domain is a known temporary-mail provider |
| `isRoleBased` | A generic mailbox (`info@`, `sales@`, `noreply@`) rather than a person |
| `didYouMean` | Suggested correction when the domain looks like a misspelling |
| `domain` | The domain written in the address |
| `companyDomain` | The company's root domain — what gets profiled, and the unit the domain events bill per. Equal to `domain` except when the address sits on a subdomain: `sales@mail.company.com` gives `company.com` |
| `checkedAt` | Timestamp |

#### Personal addresses only

| Field | Meaning |
|---|---|
| `inUse` | `true` if accounts were found, `false` if none were, `null` if the question did not apply |
| `platforms` | The services where the address is registered |

#### Corporate addresses only

| Field | Meaning |
|---|---|
| `domainReachable` | The company's domain is live |
| `domainServices` | Business services in use: Google Workspace, Microsoft 365, HubSpot, Salesforce, Shopify, Stripe, Mailchimp, Zendesk, Intercom and more |
| `domainCreated` · `domainAgeDays` · `domainRegistrar` | Registration data |
| `domainSslValid` · `domainSslDaysRemaining` · `domainSslExpiry` · `domainSslIssuer` | Certificate status |
| `domainServerCountry` | Where the company's server is hosted |

#### Reading the nulls

A field is `null` in three cases, and they are distinguishable:

1. **It does not apply to that row** — account fields on a corporate address, domain fields on a personal one. `accountType` tells you which.
2. **You did not ask for it** — that company lookup was left off.
3. **The lookup did not return an answer** — you asked for it and the address was corporate. `domainReachable: false` usually explains it.

`inUse` is deliberately three-state. `false` means the question was asked and no accounts were found. `null` means it was never asked. They are not the same, and the Actor never reports one as the other.

#### Dataset views

**Overview** — validity, type, provider and `inUse`, for a quick scan.
**Platform Accounts** — the account detection results.
**Domain Intel** — everything about the companies.

***

### Pricing

Pay-Per-Event. You pay for the checks that actually run.

| Event | When it is charged |
|---|---|
| **Email checked** | Once per address, for the base check. |
| **Platform detection** | Once per personal address actually checked for accounts. Corporate addresses are never charged for this. |
| **Domain intel** | Once per **company**, covering services, SSL and server location together. Ten addresses at one company cost one. |
| **Domain WHOIS** | Once per **company**, billed separately because registration lookups cost far more than the rest. |

Prices per event are listed on the Actor's page. The company lookups start off, so a run that does not ask for them is only ever charged the first two events. Note that services, SSL and server location share the single Domain intel event, so switching some of them off shortens the run and trims the output rather than that charge.

Nothing is charged for an address that turns out to be malformed beyond the base check, and nothing is charged for a domain that is not live at all.

***

### Tips

**Leave the memory at 1 GB.** More than that does not make the run faster — the work waits on the network, not on the machine — and the Actor start fee is charged per gigabyte, so raising it only raises the bill.

**Large batches run faster at higher concurrency — up to a point.** Account detection waits on the network, so parallelism pays. The gain flattens rather than growing without end: one of the sources is queried one address at a time on purpose, to stay below the rate at which it starts refusing, and that source sets the ceiling for this half of the work. The company lookups carry no such limit and scale with whatever you set.

**Cleaning a list on a budget.** Leave the company lookups off — the check that tells a live mailbox from a dead one runs regardless. If you do want company data, add Domain Age last: it is the slowest and most expensive of the four.

**Judging whether a mailbox is alive.** `inUse: true` is the strongest available signal short of sending a message. `inUse: false` on a valid address usually points to a secondary or abandoned mailbox. This answers for personal addresses only.

**Spotting real companies.** `domainServices` containing Google Workspace or Microsoft 365 means the company pays for business email. Combined with `domainAgeDays` above a few years, that is an established business rather than a landing page.

**Generic mailboxes are not useless.** `info@` and `sales@` bounce less than personal addresses and reach a team, but they convert differently. The flag lets you split them rather than discard them.

***

### Limitations

- **Platform Account Detection applies to personal addresses only.** Corporate domains return `null` for `inUse` and `platforms`, and are not charged for it. This is a property of the signal, not a gap in coverage.
- **Domain Intelligence applies to corporate addresses only.** Profiling a consumer webmail domain would describe the mail provider, not your lead, so it is skipped and not charged.
- **Mailbox-level confirmation is not offered.** The major providers deliberately make that answer unreliable, so an actor claiming it would be selling a guess. Deliverability plus account detection is what separates live addresses from dead ones here.
- **Registration data availability varies by country and registrar.** Some domains return partial or no registration data. Every other signal still returns independently, so one slow or silent lookup never blanks the rest of the row.
- **Addresses with non-ASCII characters** that have not been converted to their ASCII form are reported as `invalid`.
- **A domain that is not live at all is skipped** and not charged: there is nothing to profile.

***

### About

Built and maintained by **Hi Agencia**, published on Apify as **Expandi tu Marca**.

Hi Agencia builds the data and automation layer that commercial operations run on — extracting and enriching data wherever it lives, wiring it into CRMs and internal tools, and building whatever the operation needs around it. This Actor is one piece of that stack, packaged so it can be used on its own.

**[hiagencia.com](https://hiagencia.com/?utm_source=apify\&utm_medium=actor\&utm_campaign=email-verifier-account-finder-domain-intel)**

Need something this Actor does not cover, or the whole pipeline instead of one piece? Get in touch through the site.

# Actor input Schema

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

The addresses to check. Mix personal and corporate freely, in any order. Every address is verified — format, whether the domain can receive mail, disposable providers, generic mailboxes and a suggested correction for misspelled domains — and every PERSONAL address (Gmail, Yahoo, Outlook, Hotmail, AOL, iCloud, ISP mailboxes and 400+ more providers worldwide) is also checked for platform accounts, so you learn whether the mailbox is actually in use. That check is what this Actor is for and always runs. Company intelligence for CORPORATE addresses is optional and off by default. Prefixes, query strings and duplicates are handled for you.

## `enableDnsServices` (type: `boolean`):

Which business services the company runs: Google Workspace, Microsoft 365, HubSpot, Salesforce, Shopify, Stripe, Mailchimp, Zendesk, Intercom, Tiendanube and more. Tells a cloud-first company from a small local one.

## `enableWhois` (type: `boolean`):

Registration date, age in days and registrar of the company's domain. The slowest of these lookups by a wide margin, and billed as its own event.

## `enableSsl` (type: `boolean`):

Whether the certificate is currently valid, when it expires, how many days are left, and who issued it.

## `enableServerLocation` (type: `boolean`):

Country where the company's server is hosted.

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

Addresses processed in parallel (1-20). The work waits on the network far more than on the machine, so raising it speeds up a large batch — up to a ceiling: one of the sources is queried one address at a time on purpose, to stay below the rate at which it starts refusing. The company lookups carry no such limit. The default suits most lists; 1 GB of memory is enough at any value on this scale.

## `networkStrategy` (type: `string`):

How the Actor reaches the services it queries. Leave it on automatic: it starts on the cheapest route and moves up only for the few checks that need it, one at a time. Change it only if a run comes back with many blank results.

## `debug` (type: `boolean`):

Log every address as it is processed. Development flag, not part of the product.

## Actor input object example

```json
{
  "emails": [
    "jane.doe.7f3a91@gmail.com",
    "info@example.com"
  ],
  "enableDnsServices": false,
  "enableWhois": false,
  "enableSsl": false,
  "enableServerLocation": false,
  "maxConcurrency": 10,
  "networkStrategy": "auto",
  "debug": false
}
```

# Actor output Schema

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

Dataset with one row per email: validity, account type, platform accounts detected, and domain intelligence.

# 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": [
        "jane.doe.7f3a91@gmail.com",
        "info@example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("expanditumarca/email-verifier-account-finder-domain-intel").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": [
        "jane.doe.7f3a91@gmail.com",
        "info@example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("expanditumarca/email-verifier-account-finder-domain-intel").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": [
    "jane.doe.7f3a91@gmail.com",
    "info@example.com"
  ]
}' |
apify call expanditumarca/email-verifier-account-finder-domain-intel --silent --output-dataset

```

## MCP server setup

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

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/XsuwToKv3yawYNToK/builds/pm2B8Lfiua9AG7390/openapi.json