# B2B Email Finder Pro - Domain to Verified Contacts (`apricot_blackberry/b2b-email-finder-pro`) Actor

Verified B2B contact emails with MX validation, pattern detection, and deliverability scoring. Hunter.io / Apollo alternative.

- **URL**: https://apify.com/apricot\_blackberry/b2b-email-finder-pro.md
- **Developed by:** [Creator Fusion](https://apify.com/apricot_blackberry) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 verified email returneds

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 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

## B2B Email Finder Pro - Hunter.io Alternative

**Company domain in. Verified B2B contact emails out.** Crawlee scrape + MX validation + pattern detection + 1-5 deliverability score.

Hunter.io charges $0.50-$2.00 per email. Apollo charges $0.10+ per contact. We charge **$0.03 per verified email** with the same MX-validated, deliverability-scored output. That's a 16x undercut on Hunter and 3x on Apollo - for buyers who care about quality but not Hunter's brand premium.

### Input

```json
{
  "domains": ["stripe.com", "hubspot.com"],
  "include_patterns": true,
  "mx_validate": true,
  "max_emails_per_domain": 10
}
```

**Backward compatible:** legacy `urls` and `url` fields are still accepted and converted to domains.

### Output (per domain)

```json
{
  "domain": "stripe.com",
  "emails": [
    {
      "address": "press@stripe.com",
      "source": "scraped",
      "found_on": "https://stripe.com/about",
      "mx_valid": true,
      "confidence": 5,
      "format": "role"
    }
  ],
  "mx_records": ["mx1.stripe.com", "..."],
  "summary": {
    "scraped_count": 4,
    "pattern_count": 6,
    "high_confidence_count": 4
  },
  "scraped_at": "2026-05-20T12:34:56.000Z"
}
```

### Confidence (1-5)

| Source  | MX valid | Format match     | Score |
|---------|----------|------------------|-------|
| scraped | yes      | role/first.last  | 5     |
| scraped | yes      | other            | 4     |
| scraped | no       | role/first.last  | 4     |
| pattern | yes      | role             | 3     |
| pattern | no       | role             | 2     |

### Pricing

`$0.05` start + `$0.03` per verified email returned (PAY\_PER\_EVENT).

| Provider     | Per-email cost   | Notes                                    |
|--------------|------------------|------------------------------------------|
| Hunter.io    | $0.50 - $2.00    | Brand premium, similar feature set       |
| Apollo.io    | ~$0.10/contact   | Bundled in seat pricing; per-email higher|
| ZoomInfo     | $1 - $5          | Enterprise tier only                     |
| **This actor** | **$0.03**      | Same MX + pattern + scoring pipeline     |

Typical run: 1 domain -> ~5 verified emails for **$0.20** total ($0.05 start + 5 x $0.03).

### Cost transparency — what you pay for

This actor's per-event pricing covers the email-discovery work. **Two other Apify costs may apply, and they're billed directly to your Apify account, not to us:**

| Cost | Default | Who controls it |
|---|---|---|
| Compute units (CU) | ~0.001-0.01 CU per domain (free on most plans) | Apify (based on runtime) |
| Apify Proxy | **OFF by default** | YOU — enable only if needed |
| Storage (dataset) | ~free for small runs | Apify |

**Proxy specifically:** unless you turn it on, the actor crawls public company pages directly with no proxy. Saves you proxy data fees ($1+/GB on residential). If you're getting 403/429s on hostile domains (anti-bot, geo-restricted, etc.), enable Apify Proxy in the input — but know that Apify will bill the proxy data to your account, on top of our $0.05 + $0.03/email.

**Bottom line: with default settings, a typical 5-email run costs YOU $0.20 total** ($0.05 start + 5 × $0.03 = $0.20, no proxy).

### Field changes

- Output: `emails[]` with `confidence` 1-5, `source` (scraped|pattern), `found_on`, `mx_valid`, `format`
- Output: `summary` with `scraped_count`, `pattern_count`, `high_confidence_count`
- Output: `mx_records[]` for the domain
- Input: `domains`, `urls` (legacy), `url` (legacy), `include_patterns`, `mx_validate`, `max_emails_per_domain`

### Programmatic API usage

This actor is callable via the standard Apify API. Three patterns:

#### Pattern A — Run + wait + return dataset items (recommended)

```bash
curl -X POST "https://api.apify.com/v2/acts/apricot_blackberry~b2b-email-finder-pro/run-sync-get-dataset-items?token=YOUR_TOKEN&timeout=60" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["stripe.com", "hubspot.com"]}'
```

Returns dataset items as JSON. Single round-trip. Best for low-volume / interactive use.

#### Pattern B — Start run, poll, fetch dataset (high-volume)

```bash
## 1. Start
RUN_ID=$(curl -s -X POST "https://api.apify.com/v2/acts/apricot_blackberry~b2b-email-finder-pro/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["stripe.com"]}' | jq -r '.data.id')

## 2. Poll
curl "https://api.apify.com/v2/actor-runs/$RUN_ID?token=YOUR_TOKEN" | jq '.data.status'

## 3. Fetch when SUCCEEDED
DATASET_ID=$(curl "https://api.apify.com/v2/actor-runs/$RUN_ID?token=YOUR_TOKEN" | jq -r '.data.defaultDatasetId')
curl "https://api.apify.com/v2/datasets/$DATASET_ID/items?token=YOUR_TOKEN&clean=true"
```

#### Pattern C — Webhook on completion

Configure a webhook in Apify Console (Actor → Webhooks) to fire on `ACTOR.RUN.SUCCEEDED`. Use this for batch jobs / pipelines.

```json
POST your-receiver.example.com
{
  "userId": "...",
  "createdAt": "...",
  "eventType": "ACTOR.RUN.SUCCEEDED",
  "eventData": { "actorRunId": "...", "actorId": "..." }
}
```

#### Node.js (apify-client)

```js
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: "YOUR_TOKEN" });

const { defaultDatasetId } = await client
  .actor("apricot_blackberry/b2b-email-finder-pro")
  .call({ domains: ["stripe.com"] });

const { items } = await client.dataset(defaultDatasetId).listItems();
console.log(items[0].emails);
```

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("apricot_blackberry/b2b-email-finder-pro").call(
    run_input={"domains": ["stripe.com", "hubspot.com"]}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["domain"], len(item["emails"]), "emails")
```

#### MCP compatibility

This actor is callable from Claude Desktop, Cursor, and any MCP-aware client via the Apify MCP server. See [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

#### Rate limits + scaling

- Default actor timeout: 5 min per run (1 domain typically completes in ~3-8s)
- Crawlee browses with concurrency 5 by default
- For batch >50 domains: use Pattern B with concurrency 5-10
- Apify per-account rate limits apply; check your plan tier

# Actor input Schema

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

List of company domains to find email addresses for (e.g. stripe.com, hubspot.com). Recommended.

## `urls` (type: `array`):

LEGACY field, kept for backward compatibility with v0.0.4 callers. Pass URLs OR domains; each URL has its hostname extracted and treated as a domain.

## `url` (type: `string`):

LEGACY single-URL field, kept for backward compatibility. Use 'domains' for new integrations.

## `include_patterns` (type: `boolean`):

Always return common-format candidates (info@, contact@, etc.) even if not scraped. Reduces zero-result runs.

## `mx_validate` (type: `boolean`):

Verify the domain has working MX (mail) servers before scoring. Disable to save ~500ms per domain.

## `max_emails_per_domain` (type: `integer`):

Cap on emails returned per domain.

## `maxUrls` (type: `integer`):

LEGACY: cap on total domains/URLs processed. Defaults to 30.

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

⚠ COST NOTE: Proxy is OFF by default to save you money. Most company domains (stripe.com, hubspot.com, etc.) crawl fine WITHOUT a proxy. Only enable Apify Proxy if you're hitting anti-bot pages or getting 403/429 errors. When enabled, Apify Proxy data is billed directly to YOUR Apify account (not bundled in this actor's per-event price).

## Actor input object example

```json
{
  "domains": [
    "stripe.com"
  ],
  "include_patterns": true,
  "mx_validate": true,
  "max_emails_per_domain": 10,
  "maxUrls": 30
}
```

# Actor output Schema

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

All domain rows, each with an emails\[] array (address, source, mx\_valid, confidence 1-5, format) plus a summary and MX 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apricot_blackberry/b2b-email-finder-pro").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"] }

# Run the Actor and wait for it to finish
run = client.actor("apricot_blackberry/b2b-email-finder-pro").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"
  ]
}' |
apify call apricot_blackberry/b2b-email-finder-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apricot_blackberry/b2b-email-finder-pro"
        }
    }
}

```

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/dcETwMU355FhhxH2F/builds/k4yBnoHeVwTd40SuL/openapi.json