# Decision Maker Email Finder: Domain to Verified Contacts (`ntriqpro/decision-maker-email-finder`) Actor

Decision Maker Email Finder: type a company domain, get its decision-makers with title, source URL and confidence, plus work e-mails the mail server accepted. $0.012 per person, $0.06 per verified e-mail, about $0.10 per domain. Site, Wikidata, SEC and UK register, no setup.

- **URL**: https://apify.com/ntriqpro/decision-maker-email-finder.md
- **Developed by:** [Daniel Carter](https://apify.com/ntriqpro) (community)
- **Categories:** Lead generation, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 decision-maker-founds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Decision Maker Email Finder: Domain to Verified Contacts

Type a company domain. Get the people who decide there: **name, title, the page that shows them at the company, a confidence grade, and a work e-mail the mail server accepted.** It reads the company's own site, Wikidata, SEC filings and (with an operator key) the UK company register in one run, then checks the e-mail address, profiles the company and scores every person. An AI model reads each title and says whether that person decides on a purchase, and why.

No LinkedIn login, no cookies, no setup: paste domains and run. Unofficial: not affiliated with any company named in the results.

### Free vs Paid

| | Free plan | Paid plan |
|---|---|---|
| Domains per run | 5 | up to 1,000 |
| Decision-makers per domain | 3 (best score first) | up to 25 (default 25) |
| Verified e-mail rows | for the people shown | for the first 10 people per domain (the rest get guessed addresses only) |
| Company profile and buying-committee rows | up to 1 per domain | every one that qualifies |
| AI judgment rows | 1 sample per domain | every person |
| Pick functions (`roleFamilies`) and "what changed since my last run" (`previousDatasetId`) | locked (paid plans only) | yes |
| Price | list price x 1.5 | list price (the same for every paid plan, no volume tiers) |

A free run ends with `free-plan-locked` rows (for example `3 of 8 decision-makers shown for hubspot.com`) and one `free-plan-preview` row that says what the same input returns on a paid plan, with an estimate in dollars: the hidden people, their AI readings, the locked domains beyond the first 5 at this run's average, and the whole input on a paid plan. It also says the same rows cost 33% less on a paid plan. Estimates are labelled as estimates; the counts are measured. Free runs finish as SUCCEEDED; nothing looks like an error. On our 5-domain sample a paid run returned 2.4x the billable rows of the free run (74 vs 31).

### What you pay (pay per event)

List price, what BRONZE and every higher plan pays. The free plan pays 1.5x.

| Event | Charged for | Price |
|---|---|---|
| `run-started` | one run (also when every input line is unusable) | $0.005 |
| `domain-checked` | one domain we checked: the sources answered, and the row names the company or says `found: false` (parked page, no website, not in a register) | $0.005 |
| `decision-maker-found` | one person: name, title, source URL that shows them at the company, identity medium or high | $0.012 |
| `verified-email-found` | one work e-mail the mail server accepted, on a domain that does not accept everything | $0.06 |
| `company-profile-enriched` | one company profile with at least three of: tech, social, domain age, public contacts | $0.02 |
| `committee-mapped` | one buying-committee map (three or more different functions found) | $0.02 |
| `change-detected` | one person who is new, left or changed title since `previousDatasetId` | $0.01 |
| `decision-maker-judged` | one AI judgment row (is this person a decision-maker, and why) | $0.004 |

Not charged: notice rows, a second source for the same person, a name without a title, low identity grade, guessed e-mail patterns, catch-all domains, role addresses (info@, sales@), and a domain whose sources did not answer (a timeout or failure on our side). A person unchanged since your earlier run is not charged again.

Example, one domain with three people and one verified e-mail: $0.005 + $0.005 + 3 x $0.012 + $0.06 + 3 x $0.004 = **$0.118**, plus a profile or committee row when the data is there. Over our 20-domain sample the average came to about $0.10 per domain with every layer on.

Expect this: verified e-mails are found on a minority of domains (catch-all domains cannot be confirmed). In the 20-domain sample 4 of 73 people had one; the other people carry up to five guessed addresses on their row, free. You pay $0.06 only when the mail server accepted the address.

Every input you typed is accounted for. An entry that was not looked up (wrong format, a repeat, over the plan's domain limit) is listed in one free `input-skipped` row (when none of your entries is usable, the same `skipped` list is on the single `invalid-input` notice instead); if the run stops early (time budget or your spending limit) the entries it did not reach are listed in one free `not-processed` row.

### What you get

1. **Collect**: the company site (home, about, team, leadership, imprint, contact; links two levels deep; one sitemap hit), Wikidata (current CEO and chair, company IDs), SEC Form 3/4 (officers and directors of listed companies), RDAP (domain age). UK Companies House officers for `.uk` domains when the operator key is set.
2. **Cross-check**: the same person written differently in two sources becomes one row (Kate = Kathryn); for UK Companies House officers the name must appear on a company page (Wikidata and SEC people need no page match); customer quotes, former staff and outside board seats are filtered out. Identity grade high, medium or low.
3. **Enrich**: five work-address patterns checked against the mail server (MX and SMTP RCPT, no mail is sent), catch-all detection, role and disposable addresses; company profile with tech stack, socials and public contacts.
4. **Judge**: `fit_score`, `send_decision` (send, review or skip with reasons), `confidence`, and a one-line `evidence_reason` per person; a buying committee per company; changes against your earlier run; an AI judgment row per person with `authority_level` and `buying_role`.

Every row carries `source_url`, `checked_at`, `confidence` and `basis`, so a person or an AI agent can see where it came from and why.

### Input

- `domains` (required): one per line. A web domain (`acme.com`), a website address, or a company name.
- `maxPeoplePerDomain`: 1-25, default 25 (free plan: 3).
- `aiJudgment`: default on. `buyerContext`: one sentence such as "the person who buys marketing software" to judge against.
- Paid plans: `roleFamilies` (exec, sales, marketing, ops, finance, tech, hr, legal) and `previousDatasetId`.
- `proxyConfiguration`: used for a site only after the direct request was refused.

### Output

One row per company, person, e-mail, profile, committee, change or AI judgment (`row_type`). A person row:

```json
{
  "row_type": "decision-maker",
  "domain": "buffer.com",
  "full_name": "Joel Gascoigne",
  "job_title": "CEO & Co-Founder",
  "role_family": "exec",
  "seniority": "c-level",
  "email": "joel@buffer.com",
  "email_status": "verified",
  "email_basis": "smtp-accepted",
  "catch_all": false,
  "identity_status": "medium",
  "fit_score": 72,
  "send_decision": {"action": "send", "risk_level": "medium", "confidence": 0.7},
  "evidence_reason": "Joel Gascoigne is listed as CEO & Co-Founder at Buffer by the company's own page buffer.com; one source only.",
  "source_url": "https://buffer.com/about",
  "confidence": 0.7,
  "basis": "Named with this title by: site."
}
```

The company row has `sources_status` (ok, none, failed or timeout per source) and `partial`: a count that is missing is unknown, not zero.

### What is still being checked

- **UK Companies House**: built and tested with recorded answers; the live register answer has not been seen yet (checking). It runs only for `.uk` domains and only when the operator sets a key; without it the source is skipped and says so in `sources_status`.
- **LinkedIn profile address by public search**: tested with recorded answers; no live case where it returned an address has been seen (checking). When it finds an address the row says `linkedin_source: public-search`; when it does not, the field is empty and nothing is charged for it.

### Notes

- Titles come from public pages and can be stale; always read `source_url` and `identity_status` before you send mail. On our 20-domain hand check 51 of 53 people were right, and the grade, source and reason are on every row so you can filter.
- Accuracy depends on what the company publishes. A domain with no public team page returns the company row and few or no people.
- You are responsible for how you use the contacts (e-mail, privacy and anti-spam rules where you send). The Actor reads public pages and registers only.

# Actor input Schema

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

One per line: a company web domain (acme.com), a website address, or a company name. Everything else runs by itself: company site, Wikidata, SEC and UK register, work e-mail check, company profile, scoring. Free plan: 5 domains per run, 3 decision-makers each. You are responsible for a lawful purpose and for the data-protection, anti-spam and marketing law that applies when you contact the people listed.

## `roleFamilies` (type: `array`):

Leave empty to get the best-scoring people of every function. Pick functions to list only those people (paid plans). On the free plan this input is ignored. (paid plans)

## `previousDatasetId` (type: `string`):

Paste the dataset ID of an earlier run of this Actor. People who are new, left or changed title get a change row (a new person also gets a decision-maker row, each charged by its own event); people who did not change come back as free `roster` rows and are not charged again, so you can chain the next run from this dataset. Paid plans only. (paid plans)

## `maxPeoplePerDomain` (type: `integer`):

1-25, default 25. Free plan: 3 per domain. The best-scoring people come first.

## `aiJudgment` (type: `boolean`):

An AI model reads each person's title and the text that names them and says whether they decide on a purchase, and why. One extra row per person (event decision-maker-judged). Free plan: one sample per domain.

## `buyerContext` (type: `string`):

One sentence for the AI judgment, e.g. 'the person who buys marketing software'. Leave empty to judge general purchasing power.

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

Apify Proxy is used for a site only after the direct request was refused.

## Actor input object example

```json
{
  "domains": [
    "hubspot.com"
  ],
  "roleFamilies": [],
  "maxPeoplePerDomain": 25,
  "aiJudgment": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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": [
        "hubspot.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ntriqpro/decision-maker-email-finder").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": ["hubspot.com"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ntriqpro/decision-maker-email-finder").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": [
    "hubspot.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call ntriqpro/decision-maker-email-finder --silent --output-dataset

```

## MCP server setup

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

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/V1t5PfyYHGLwKVLx4/builds/Md8wmYWrdhwZTxSy4/openapi.json