# B2B Contact Enricher — Verified Emails, Roles & Firmographics (`nexgendata/b2b-contact-enricher`) Actor

- **URL**: https://apify.com/nexgendata/b2b-contact-enricher.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 enriched contact delivereds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## B2B Contact Enricher — Company → Verified Business Emails, Roles & Firmographics

**Drop in a list of company names or domains. Get back clean, verified, role-classified _public business_ contact records — and optionally a ready-to-use Notion CRM, built in the same run.**

This is the B2B enrichment workhorse of the NexGenData contact stack. For every company you give it, it discovers the public business email addresses on that company's own domain, classifies each by role, verifies deliverability against live MX records, detects the email provider, and layers on basic firmographics (industry + estimated company size). One row per contact, ready for outreach, CRM import, or scoring.

> **Public business data only.** This Actor works exclusively from public business sources — company domains, company names, and role/public business email addresses published on the company's own website (info@, sales@, support@, hr@, press@, billing@…). It does **not** collect, infer, or output private personal data, home addresses, or personal profiling. Use responsibly and follow applicable outreach and privacy laws (GDPR, CAN-SPAM, etc.).

---

<!-- nexgendata-pipeline:start -->
### 🎯 The NexGenData Lead-Gen Pipeline

Turn this into a full pipeline: **find prospects → enrich with firmographics → verify deliverability → export.** Each step is its own NexGenData actor.

**Find leads**

- [b2b-leads-finder](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b) — Apollo/ZoomInfo alternative — build targeted prospect lists
- [made-in-china-b2b-suppliers](https://apify.com/nexgendata/made-in-china-b2b-suppliers?fpr=2ayu9b) — Find China/APAC manufacturers & wholesale suppliers
- [contact-info-scraper](https://apify.com/nexgendata/contact-info-scraper?fpr=2ayu9b) — Pull emails & phone numbers from any website
- [website-email-extractor](https://apify.com/nexgendata/website-email-extractor?fpr=2ayu9b) — Bulk-extract email addresses from a list of sites
- [company-email-finder](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b) — Find B2B contact emails by company domain
- [person-business-email-finder](https://apify.com/nexgendata/person-business-email-finder?fpr=2ayu9b) — Name + company → verified business email

**Enrich**

- **b2b-contact-enricher** — Add verified emails, roles & firmographics to a company **← you are here**
- [company-enrichment-tool](https://apify.com/nexgendata/company-enrichment-tool?fpr=2ayu9b) — Domain → firmographics, size, industry & contacts
- [company-data-aggregator](https://apify.com/nexgendata/company-data-aggregator?fpr=2ayu9b) — LEI, SEC funding & tech-stack company intelligence
- [lead-list-enricher](https://apify.com/nexgendata/lead-list-enricher?fpr=2ayu9b) — Enrich any domain with emails, phones & social profiles

**Verify**

- [email-verification-tool](https://apify.com/nexgendata/email-verification-tool?fpr=2ayu9b) — Bulk deliverability, SMTP & MX verification
- [email-validator](https://apify.com/nexgendata/email-validator?fpr=2ayu9b) — Bulk email validator — syntax, MX & clean your lists
<!-- nexgendata-pipeline:end -->

### ⚡ What you get

| Capability | What it does |
|---|---|
| 🔎 **Email discovery** | Crawls the company homepage + common contact/about/legal pages for public business emails on the domain |
| 🏷️ **Role classification** | Tags every email: `general`, `sales`, `support`, `hr`, `press`, `billing`, `admin`, `marketing`, or `business` |
| ✅ **MX / deliverability verification** | Live DNS MX lookup so you keep only domains that can actually receive mail |
| 📮 **Email provider detection** | Identifies Google Workspace, Microsoft 365, Zoho, ProtonMail, Mimecast, and more |
| 🏢 **Firmographics** | Estimates industry (Fintech, SaaS, E-commerce, …) and company size band from public signals |
| 🗂️ **Optional Notion CRM** | Connect Notion and it builds a real database with one row per contact — your credentials never touch the Actor |
| 🧾 **Provenance on every row** | `source_url`, `data_source`, and `as_of_timestamp` so every record is auditable |

---

### 🎯 Use cases

- **Outbound prospecting** — turn a target account list into a contactable, role-segmented email list.
- **CRM hygiene & enrichment** — append verified business emails, provider, industry, and size to existing company records.
- **Lead routing** — send `sales@` to sales, `press@` to PR, `billing@` to finance using the `contact_type` field.
- **Partnerships & BD** — quickly find the right public inbox at hundreds of target companies.
- **Notion-native teams** — auto-build a contact CRM in your Notion workspace with zero manual entry.

---

### 🚀 How to use

Provide a `companies` list (names **or** domains). Set `verifyEmails` to keep only mail-capable domains (default on). Optionally attach a Notion MCP connector to write a CRM.

#### Python (Apify client)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("nexgendata/b2b-contact-enricher").call(run_input={
    "companies": ["stripe.com", "https://shopify.com", "Notion"],
    "verifyEmails": True,
    # "notionConnector": "<your-notion-mcp-connector>",   # optional
    # "notionParentId": "<notion-page-id>",               # optional
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("_type") == "run_summary":
        continue
    print(item["company"], item["email"], item["contact_type"], item["industry"])
````

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~b2b-contact-enricher/runs?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
        "companies": ["stripe.com", "shopify.com"],
        "verifyEmails": true
      }'
```

***

### 📊 Output fields

Each contact record in the dataset contains:

| Field | Description |
|---|---|
| `company` | Company name (from the site title) or domain |
| `domain` | Resolved company domain |
| `email` | Public business email address |
| `contact_type` | `general` / `sales` / `support` / `hr` / `press` / `billing` / `admin` / `marketing` / `business` |
| `mx_verified` | Boolean — domain has valid MX records (can receive email) |
| `email_provider` | Detected mail provider (Google Workspace, Microsoft 365, Zoho, …) |
| `industry` | Estimated industry from public signals (may be null) |
| `company_size` | Estimated employee band, e.g. `1-10`, `11-100`, `101-1000`, `1000+` (may be null) |
| `source_url` | The page where the contact / company data was found |
| `data_source` | Always `nexgendata/b2b-contact-enricher` |
| `as_of_timestamp` | UTC ISO timestamp of when the record was collected |

A final `run_summary` item reports counts, the Notion database URL (if delivered), and any companies that returned no results.

***

### ❓ FAQ

**Does this find personal emails of named individuals?**
No. It returns only public business inboxes published on the company's own domain (info@, sales@, support@, etc.). No personal profiling, no home addresses, no private PII.

**Can I pass plain company names instead of domains?**
Yes. A name like `Notion` is resolved to a best-effort domain. For maximum accuracy, pass the domain directly (`notion.so`).

**What does `verifyEmails` do?**
With it on (default), only contacts on domains with valid live MX records are returned — i.e. domains that can actually receive email. Turn it off to include unverified-MX domains too.

**Why did a company return no contacts?**
Common reasons: the apex domain has no MX records (mail runs on a different domain), the site blocks crawlers, or it simply publishes no contact emails. These appear in `companies_with_no_results` in the run summary.

**How does the Notion delivery work?**
Attach a Notion MCP connector and the Actor builds a database (via `notion-create-database`) and inserts one row per contact (via `notion-create-pages`). Apify injects your Notion credentials server-side — the Actor never sees them.

**How am I charged?**
This Actor uses pay-per-event: you're charged per **enriched contact delivered** (`result`). No results, no charge for results.

***

### 🔗 Related actors

Build a full pipeline with the rest of the NexGenData contact/lead stack:

- [**Company Email Finder**](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b) — the focused public-email discovery engine.
- [**B2B Leads Finder**](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b) — find target companies and leads to feed into this enricher.
- [**Leads → Notion CRM**](https://apify.com/nexgendata/leads-to-notion-crm?fpr=2ayu9b) — turn discovered leads into a Notion CRM automatically.

***

### 🏢 About NexGenData

NexGenData builds reliable, business-grade data Actors for lead generation, enrichment, and automation — engineered for clean output, honest provenance, and responsible use of public data. Questions or custom needs? Reach out through our Apify Store profile.

# Actor input Schema

## `companies` (type: `array`):

List of company names or domains/URLs to enrich (e.g., 'stripe.com', 'https://notion.so', or a plain name like 'Shopify'). Public business data only.

## `verifyEmails` (type: `boolean`):

When enabled (default), only contacts on domains with valid MX records (i.e. domains that can actually receive email) are returned. Disable to include contacts on domains without verified MX.

## `notionConnector` (type: `string`):

Optional. Connect your Notion workspace and this Actor builds a CRM database of the enriched contacts in the same run — it never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here. (Without a connector you get the dataset only.)

## `notionParentId` (type: `string`):

Optional. The Notion page ID to create the CRM database under. If blank, Notion creates it as a private page in your workspace.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "https://shopify.com",
    "Notion"
  ],
  "verifyEmails": true
}
```

# 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 = {
    "companies": [
        "stripe.com",
        "notion.so"
    ],
    "verifyEmails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/b2b-contact-enricher").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 = {
    "companies": [
        "stripe.com",
        "notion.so",
    ],
    "verifyEmails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/b2b-contact-enricher").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 '{
  "companies": [
    "stripe.com",
    "notion.so"
  ],
  "verifyEmails": true
}' |
apify call nexgendata/b2b-contact-enricher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/b2b-contact-enricher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Contact Enricher — Verified Emails, Roles & Firmographics",
        "version": "0.0",
        "x-build-id": "uZv9G1eiszdsXEhcM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~b2b-contact-enricher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-b2b-contact-enricher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~b2b-contact-enricher/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-b2b-contact-enricher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~b2b-contact-enricher/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-b2b-contact-enricher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies (names or domains)",
                        "type": "array",
                        "description": "List of company names or domains/URLs to enrich (e.g., 'stripe.com', 'https://notion.so', or a plain name like 'Shopify'). Public business data only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "verifyEmails": {
                        "title": "Verify email deliverability (MX)",
                        "type": "boolean",
                        "description": "When enabled (default), only contacts on domains with valid MX records (i.e. domains that can actually receive email) are returned. Disable to include contacts on domains without verified MX.",
                        "default": true
                    },
                    "notionConnector": {
                        "title": "Deliver to Notion CRM (optional)",
                        "type": "string",
                        "description": "Optional. Connect your Notion workspace and this Actor builds a CRM database of the enriched contacts in the same run — it never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here. (Without a connector you get the dataset only.)"
                    },
                    "notionParentId": {
                        "title": "Notion parent page ID (optional)",
                        "type": "string",
                        "description": "Optional. The Notion page ID to create the CRM database under. If blank, Notion creates it as a private page in your workspace."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
