# RocketReach Alternative: Verified Work Email (`khadinakbar/rocketreach-alternative`) Actor

Find or validate work email for known B2B contacts. Returns provider deliverability results, DNS provenance, confidence, fallback state, and honest terminal outcomes.

- **URL**: https://apify.com/khadinakbar/rocketreach-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 verified contact enrichments

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

## RocketReach Alternative: Work Email & Public Profiles

Turn a known B2B contact—full name plus company domain—into a structured work-email result, or run a bounded public professional-profile search. Work-email mode uses EmailListVerify; public-profile mode returns only public profile name, headline, URL, location, query filters, and HarvestAPI provenance.

Choose this Actor for a CRM, account list, or manually sourced prospect list that already identifies the person and employer. This Actor is designed and works as a focused standalone workflow for caller-authorized professional contact records, where a verified work-email result and explicit fallback state are more useful than a broad people-search suite.

### Public professional-profile search

Use `operation: "public_profile_search"` to search public LinkedIn professional profiles by a professional query or a public LinkedIn company URL, with optional title and location filters. The route is limited to 25 complete profiles per run and does not return email, phone, private profile fields, or outreach actions. It is separately billed only when the new paid event is active; until then the Actor returns an explicit non-billable staged status.

```json
{
  "operation": "public_profile_search",
  "publicProfileSearch": {
    "query": "sales operations",
    "title": "Director",
    "location": "New York"
  },
  "maxProfiles": 10
}
```

### Output: what you get

One dataset row per completed known contact:

| Field | Meaning |
| --- | --- |
| `workEmailCandidate` | Provider-selected work email, or an explicitly labelled DNS-candidate fallback. |
| `verificationStatus` | Deliverability, confidence, catch-all risk, no-match, or fallback state; the exact result is preserved. |
| `provider` and `providerResult` | `email_list_verify` and its returned status whenever the verification route completes. |
| `providerConfidence` | Provider match confidence for contact discovery, when available. |
| `fallbackUsed` | `true` only when the requested DNS-candidate continuity policy served a provider outage. |
| `mxHost` | Domain mail-routing provenance when an MX record is available. |
| `externalId` | Your original CRM/spreadsheet key, carried through unchanged. |
| `collectedAt` | ISO timestamp for this DNS observation. |

### Quick start: known contacts

```json
{
  "contacts": [{
    "externalId": "crm-001",
    "fullName": "Ada Lovelace",
    "companyName": "Example Ltd",
    "companyDomain": "example.com",
    "linkedInUrl": "https://www.linkedin.com/in/example-person"
  }],
  "enrichmentMode": "find_and_verify",
  "fallbackPolicy": "strict",
  "maxResults": 25,
  "maxCandidatesPerContact": 3,
  "includeMxValidatedCandidates": true
}
```

Example record shape:

```json
{
  "externalId": "crm-001",
  "fullName": "Ada Lovelace",
  "companyDomain": "example.com",
  "workEmailCandidate": "ada.lovelace@example.com",
  "candidatePattern": null,
  "candidateRank": null,
  "verificationStatus": "deliverable_high_confidence",
  "verificationMethod": "email_list_verify",
  "provider": "email_list_verify",
  "providerConfidence": "high",
  "providerResult": "ok",
  "enrichmentMode": "find_and_verify",
  "fallbackUsed": false,
  "mxHost": "mail.example.com",
  "source": "user_provided_contact_and_dns_mx",
  "collectedAt": "<ISO-8601 collection timestamp>"
}
```

The example illustrates the schema only. Provider deliverability assessment is distinct from identity, employment, consent, and authorization decisions; teams can apply their own authorized review before downstream communication.

### Workflow: from CRM contact to a reviewable record

A sales-operations user starts with a caller-authorized CRM export, passes `fullName`, `companyDomain`, and an `externalId`, then receives one typed dataset row per contact. Next, the team can review the `verificationStatus`, provider result, confidence, source, collection time, and fallback state before it feeds an authorized CRM hygiene workflow. The Actor keeps each input, cost event, and output record easy to audit.

### Pricing

This Actor uses **Pay per event** pricing plus Apify platform usage. A provider-backed `verified-contact` record costs **$0.20**; a DNS-candidate `contact-enriched` record costs **$0.12**; and a complete `public-profile-discovered` record costs **$0.05** once that new paid event takes effect. The live [Pricing tab](https://apify.com/khadinakbar/rocketreach-alternative/pricing) is the current source of truth. The public-profile route has a one-request provider cap and retains a 72% worst-case gross margin on customer spend after Apify's share, before user-paid platform usage. Provider configuration, outage, incomplete-profile, and staged paths are not billed as completed results.

### Reliability and continuity

`strict` is the default fallback policy: a missing secret, exhausted provider credits, or provider outage produces an explicit, non-billable terminal outcome rather than a completed verification. `dns_candidate` is the affordable continuity route: it returns a DNS MX-backed conventional candidate with `fallbackUsed: true` and `provider_unavailable_candidate`, separate from provider verification. EmailListVerify is the primary verifier; a direct EmailListVerify API integration is the practical outside-Apify continuity route when an Apify run is unavailable. A genuinely independent verifier requires a separately contracted second provider and becomes part of the route after its API integration has been tested.

### How this bounded workflow compares with RocketReach

This is an independent, focused alternative for turning an already-known name and company domain into a provider-backed work-email result, or finding bounded public professional profiles. RocketReach remains the broader choice when a hosted people/company database, phone data, browser extension, outbound sequences, team workspace, or suite-level integrations are required.

| Decision | This Actor | RocketReach | Best fit |
| --- | --- | --- | --- |
| Starting point | Known name + company domain, or a bounded public professional search query | Product-managed people/company search and lookups | Use this Actor for a specific email-verification or public-profile research job. |
| Output | Provider result, confidence, DNS provenance, fallback state, and explicit status semantics | Broader lookup and suite data | Use RocketReach for its broader database workflow. |
| Effective efficiency | One complete candidate/status/provenance record for each supplied contact | No same-job timing comparison has been authorized | Compare accepted records and operator minutes for your actual workflow. |
| Billing | $0.12 per completed enrichment plus platform usage | Subscription/credit plans; check current RocketReach pricing | Compare current prices only for the same volume and fields. |
| Automation | Apify dataset/API output after a batch run | Product API/integration availability depends on plan | Choose the tool whose tested integration meets your workflow. |
| Deliverability route | EmailListVerify result when provider mode completes; DNS fallback is explicit | Outside this Actor's contract | Use an authorized workflow for contact policy decisions. |

RocketReach is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by RocketReach.

### API

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/rocketreach-alternative').call({
  operation: 'public_profile_search',
  publicProfileSearch: { query: 'sales operations', location: 'New York' },
  maxProfiles: 3
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### AI agent and MCP prompt

> Search public professional profiles for this explicit business query, without email, phone, private-profile data, or outreach. Return the run outcome, dataset readback, source, collection time, and billed event count for every complete record.

An AI agent can run this Actor through the Apify API example above. It should read `OUTPUT` after the dataset, use `verificationStatus` to distinguish provider results from DNS-candidate continuity records, and preserve `externalId` as the downstream join key.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow when a caller-authorized CRM already holds the professional identity and employer domain.

### Best results and scope

Provide a complete professional name and the employer's canonical mail domain for work-email enrichment. A CRM key in `externalId` makes the result easy to join back to the source record. Use `find_and_verify` for a provider-backed contact search, `verify_supplied_email` for a known email, and `candidate_only` when a DNS pattern is the appropriate scoped result. For public-profile search, provide a professional query or public LinkedIn company URL and optional title/location filters. Treat public-profile data as public research data, not proof of identity, employment, contactability, consent, or authorization.

### Builder's note

I built this Actor around a deliberately inspectable contract: known business contact in, provider-backed work-email result or explicitly labelled DNS continuity record out. My goal is to make the source, collection time, provider result, fallback state, and billing event visible so a team can decide the appropriate authorized next step.

### Responsible use

Use professional contact data you are authorized to process. Respect opt-outs, privacy law, platform terms, and your organization's outreach rules. Treat a candidate string, an MX record, or a profile URL as a data point within your organization’s authorized contact policy.

# Actor input Schema

## `operation` (type: `string`):

Choose work\_email\_enrichment for caller-supplied known contacts, or public\_profile\_search for a bounded public professional-profile search. Public-profile search is available only after its separately priced event becomes active; it never returns email or phone data.

## `contacts` (type: `array`):

Required for work\_email\_enrichment: one to 200 contacts you already know, each with fullName and companyDomain. An optional externalId is preserved for CRM matching and optional linkedInUrl is stored only as supplied provenance. Leave empty for public\_profile\_search.

## `publicProfileSearch` (type: `object`):

Required for public\_profile\_search: provide a professional search query or a public LinkedIn company URL, with optional title and location filters. Results are public profile name, headline, URL, and location only; no email, phone, personal contact data, or outreach capability is returned.

## `maxProfiles` (type: `integer`):

For public\_profile\_search, process one to 25 returned public profiles. Each accepted complete profile is charged only after the separately priced public-profile event has become active. Defaults to 10.

## `enrichmentMode` (type: `string`):

Choose find\_and\_verify to find a work email from the known name and employer domain, verify\_supplied\_email to validate contact.email, or candidate\_only for DNS-backed conventional patterns. The default uses the owner-configured EmailListVerify route. Verification modes require the EMAIL\_LIST\_VERIFY\_API\_KEY Actor secret and return explicit provider outcomes. candidate\_only preserves an MX-backed candidate boundary without asserting mailbox delivery.

## `fallbackPolicy` (type: `string`):

Choose strict to fail truthfully without billing when the required verification provider is unavailable. Choose dns\_candidate to return the MX-backed candidate route when provider verification cannot complete. The default strict policy keeps provider availability distinct from a completed verification. The fallback never labels a conventional candidate as mailbox-verified.

## `maxResults` (type: `integer`):

Hard cap on contacts processed in one run. Defaults to 25 and accepts 1 to 200 contacts, limiting maximum event charges to $0.12 per completed enrichment plus platform usage. This is not a search-result page limit because the Actor does not search a people database.

## `maxCandidatesPerContact` (type: `integer`):

Number of common work-email patterns returned for an MX-capable employer domain. Defaults to 3 and accepts 1 to 5 patterns, ordered by conventional pattern priority. This does not verify that a specific mailbox exists or that the person currently works there.

## `includeMxValidatedCandidates` (type: `boolean`):

Return candidate work-email strings only when the supplied company domain advertises an MX mail host. Defaults to true; turning it off still returns the enrichment status and DNS provenance without email strings. This is not mailbox, SMTP, ownership, or personal-email verification.

## Actor input object example

```json
{
  "operation": "work_email_enrichment",
  "contacts": [
    {
      "fullName": "Ada Lovelace",
      "companyDomain": "example.com",
      "externalId": "crm-001"
    }
  ],
  "publicProfileSearch": {
    "query": "sales operations",
    "title": "Director",
    "location": "New York"
  },
  "maxProfiles": 10,
  "enrichmentMode": "find_and_verify",
  "fallbackPolicy": "strict",
  "maxResults": 25,
  "maxCandidatesPerContact": 3,
  "includeMxValidatedCandidates": true
}
```

# Actor output Schema

## `contacts` (type: `string`):

One record per processed known contact or complete public professional profile, with explicit provider provenance.

## `compactOutput` (type: `string`):

Stable outcome, counts, warnings, and charged events for the selected operation.

## `runSummary` (type: `string`):

Detailed terminal diagnostics, provider attempts, fallback use, and event-charge counts.

# 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 = {
    "operation": "work_email_enrichment",
    "contacts": [
        {
            "fullName": "Ada Lovelace",
            "companyDomain": "example.com",
            "externalId": "crm-001"
        }
    ],
    "publicProfileSearch": {
        "query": "sales operations",
        "title": "Director",
        "location": "New York"
    },
    "maxProfiles": 10,
    "enrichmentMode": "find_and_verify",
    "fallbackPolicy": "strict",
    "maxResults": 25,
    "maxCandidatesPerContact": 3,
    "includeMxValidatedCandidates": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/rocketreach-alternative").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 = {
    "operation": "work_email_enrichment",
    "contacts": [{
            "fullName": "Ada Lovelace",
            "companyDomain": "example.com",
            "externalId": "crm-001",
        }],
    "publicProfileSearch": {
        "query": "sales operations",
        "title": "Director",
        "location": "New York",
    },
    "maxProfiles": 10,
    "enrichmentMode": "find_and_verify",
    "fallbackPolicy": "strict",
    "maxResults": 25,
    "maxCandidatesPerContact": 3,
    "includeMxValidatedCandidates": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/rocketreach-alternative").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 '{
  "operation": "work_email_enrichment",
  "contacts": [
    {
      "fullName": "Ada Lovelace",
      "companyDomain": "example.com",
      "externalId": "crm-001"
    }
  ],
  "publicProfileSearch": {
    "query": "sales operations",
    "title": "Director",
    "location": "New York"
  },
  "maxProfiles": 10,
  "enrichmentMode": "find_and_verify",
  "fallbackPolicy": "strict",
  "maxResults": 25,
  "maxCandidatesPerContact": 3,
  "includeMxValidatedCandidates": true
}' |
apify call khadinakbar/rocketreach-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/rocketreach-alternative"
        }
    }
}

```

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/kFR5TDChnXFhWBRu0/builds/o92w4xCogM3jXeeAf/openapi.json