# Business Email Discovery — B2B Contact Finder API (`nexgensignal/business-email-discovery-api`) Actor

Company domain to business emails: published role and personal contact addresses from the company's public pages plus standard role addresses, each DNS mail-verified. One record per email. Keyless; B2B use, honour outreach/privacy law.

- **URL**: https://apify.com/nexgensignal/business-email-discovery-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $67.00 / 1,000 business email records

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

## Business Email Discovery — B2B Contact Finder API

**Pay per email. Give it a company domain and get back the business email addresses to reach that company — published role and contact addresses plus standard role addresses, each DNS-verified.**

Feed one domain or thousands and, for each, get a clean list of business emails your sales team can actually use: the addresses the company publishes on its own pages, plus the standard role addresses (`info@`, `sales@`, `contact@`) for any domain that can receive mail — one tidy record per email, keyed by domain.

### What this is, in one paragraph

Every company publishes a way to reach it, but it's spread across a contact page, an about page, a footer. This actor pulls it together: for each domain it reads the homepage and a few likely contact/about pages, extracts the business emails published there (classifying each as a role address like `sales@` or a named-person business address), adds the standard role addresses that almost every business runs, and confirms via a DNS lookup whether the domain can receive mail at all. You get one record per email, each tagged as published or inferred, so you know exactly what came off the site and what is a standard-role suggestion. It is a keyless, code-friendly B2B contact-discovery endpoint.

### Who buys this and for what job

- **Sales and RevOps teams** turning a list of target-company domains into a reachable contact per account.
- **Lead-generation and agency teams** building B2B prospect lists at scale.
- **Data teams** assembling a company-email table keyed by domain.
- **Builders and agents** who need a keyless company-email endpoint they can call from code.

The job it does: take a company's domain and return the business emails that reach it — published and standard-role — verified at the domain level, without an account or key.

### Pricing

Pay per event. One event: a business email record delivered. Tiered by your Apify plan; the record is delivered before it is charged. No subscription. A domain that yields nothing still returns one record (with `success: false`) and counts as one processed lookup.

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| Business email record | $0.10 | $0.09 | $0.08 | $0.067 |

There is also a negligible per-run start fee. About 10 emails per dollar at the base rate.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `domains` | array | *(required)* | One or more company domains (e.g. `stripe.com`). One record is returned per business email found. |
| `includeInferredRoles` | boolean | true | Also return standard role addresses (`info@`, `contact@`, `sales@`, …) for mail-capable domains, marked as inferred. |
| `maxPerDomain` | integer | 50 | Cap on email records returned per domain. |
| `proxyConfiguration` | object | Residential | Proxy for site requests; residential is recommended. |

### Output

One JSON object per email. Real example:

```json
{
  "record_id": "sales@stripe.com",
  "domain": "stripe.com",
  "email": "sales@stripe.com",
  "email_type": "published_role",
  "local_part": "sales",
  "source_url": "https://stripe.com/contact",
  "discovered": true,
  "has_mx": true,
  "mx_provider": "Google Workspace",
  "success": true,
  "error": null,
  "observed_at": "2026-08-25T00:00:00Z"
}
```

`email_type` is one of `published_role`, `published_personal`, or `inferred_role`; `discovered` is true only for addresses actually published on the site. An unbilled `RUN_RECEIPT` records how many domains went in, how many email records were delivered, and how many domains yielded at least one.

### Field reference

Each record carries `record_id` (the email), the `domain`, the `email` and its `local_part`, the `email_type` and `discovered` flag that tell you whether it was published or a standard-role suggestion, the `source_url` it came from, and the domain's mail capability (`has_mx`, `mx_provider`) from a DNS check. `success` and `error` let your pipeline branch on empty domains. Provenance travels on every record: `source`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

For each domain the actor fetches the homepage and a few likely contact/about pages over a residential proxy, extracts every email that belongs to that domain, and classifies each. It confirms the domain's mail server via a DNS MX lookup, and — when that check passes and you've left inferred roles on — adds the handful of standard role addresses every business runs, marked `inferred_role` so they're never confused with published data. Each email becomes one delivered, billed record; a domain with nothing to show still returns a single honest record so every input is accounted for.

### Published vs. inferred

The distinction is deliberate and always explicit. A `published_role` or `published_personal` address was found in the company's own public pages — that's data. An `inferred_role` address (`info@company.com` and friends) is a standard-role suggestion returned only when the domain's DNS says it can receive mail — that's a lead, not a claim that the mailbox is monitored. Filter on `discovered` to keep only what was published, or keep both for maximum reach; either way you always know which is which, so you never mistake a suggestion for a verified find.

### Running at scale

Feed a single domain to test or a list of thousands to build a whole prospect base in one pass. Cost tracks output exactly: the number of email records delivered is the number of events billed, and `maxPerDomain` caps how many emails any one domain can contribute so a single large site can't blow the budget. Every domain resolves to at least one record — a real email or an honest miss — so nothing silently disappears from a big run, and the unbilled run receipt reconciles domains-in against records-out and how many domains produced a contact. Site fetches run over a residential proxy with automatic session re-rolls, so an intermittent block on one company doesn't cost you the rest of the batch.

### Use with AI agents

Point Claude, an OpenAI Agents SDK tool, an n8n or Make flow, or any MCP-aware client at this actor and hand it a list of company domains. Because the output is flat JSON keyed by `domain` and `email`, an agent can build a reachable-contact list per account in one call and prefer published addresses over inferred ones. A typical prompt: *find the business contact emails for each of these company domains and flag which were actually published.*

### Lawful use and limitations

- **Business contacts, public sources.** Every published address comes from the company's own public pages; inferred addresses are standard business roles gated on a DNS mail check. This is a B2B prospecting dataset for contacting businesses and their published business contacts — not private individuals.
- **Use it lawfully.** Respect applicable outreach and data-protection law (for example GDPR legitimate-interest and CAN-SPAM requirements) and honour opt-outs and unsubscribe requests.
- **MX is a DNS check.** It confirms a *domain* can receive mail; it is never an SMTP mailbox probe and does not confirm a specific address is monitored.
- **Coverage varies.** Some companies publish no addresses or obfuscate them; those return an honest empty record. No data beyond business email details is collected.

***

*Business email addresses discovered from a company's public web pages plus standard role addresses, DNS-verified at the domain. For B2B outreach to businesses and their published business contacts, not private individuals. Use in line with applicable outreach and data-protection law, and honour opt-outs.*

# Actor input Schema

## `domains` (type: `array`):

One or more company domains (e.g. stripe.com). One record is returned per business email found.

## `includeInferredRoles` (type: `boolean`):

Also return standard role addresses (info@, contact@, sales@, ...) for domains that can receive mail, marked as inferred.

## `maxPerDomain` (type: `integer`):

Cap on email records returned per domain.

## `proxyConfiguration` (type: `object`):

Proxy for site requests. Residential is recommended.

## Actor input object example

```json
{
  "domains": [
    "stripe.com"
  ],
  "includeInferredRoles": true,
  "maxPerDomain": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Delivered records.

# 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 = {
    "domains": [
        "stripe.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/business-email-discovery-api").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 = {
    "domains": ["stripe.com"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/business-email-discovery-api").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 '{
  "domains": [
    "stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nexgensignal/business-email-discovery-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/business-email-discovery-api"
        }
    }
}

```

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/Ln3CdEcPYz4TzIJfR/builds/W76C66wIloFZh34ap/openapi.json