Email Finder by Name and Domain: Verified Work Email

Find a person's work email address from their first name, last name and company domain. It returns the most likely address, a score, the reasons, and ranked alternatives, and checks the best candidates with a catch-all email verifier. You are billed only for addresses that were found and verified (verifier verdict keep), not for attempts, guesses or unverified results.

One run, real output

Four invented names, run for real. Two sit at stripe.com, whose public site shows the first.last address shape; one at lyfeoffshore.com (a project-owned domain with no such evidence); one at a domain that does not exist. The names are generic examples, not people, so these are pattern inferences, not addresses anyone confirmed.

Locally, without verification (pattern + website evidence only; nothing is billed):

Person	Result	Score	Why
Maria Gonzalez at stripe.com	found maria.gonzalez@stripe.com	0.65	the site publishes first.last addresses
John Smith at stripe.com	found john.smith@stripe.com	0.65	same
Jan van der Berg at lyfeoffshore.com	not found; best guess jan.vanderberg@lyfeoffshore.com	0.29	compound surname, no format evidence, below the 0.60 threshold
Ana García-López at a non-existent domain	not found	0	"the domain does not exist in DNS": an explicit row, never a silent gap

"Found" here means a likely address with unverified evidence. It is returned, but only an address the verifier confirms with keep is billed, so these two cost nothing in this run.

With the verifier (an earlier test run of the real verification engine on lyfeoffshore.com, three candidates per person): all three names came back test (p = 0.69), so they were returned as best guesses, not found and not billed. The verifier only says keep when it has real evidence, and a lone name on a domain with no other addresses to compare against is often not enough. That is the intended behaviour: an unconvincing address costs you nothing.

What it does

1. Normalises the name. Accents are folded (Tomáš → tomas, Søren → soren), German spellings tried as a variant (Müller → muller, mueller), compound surnames split (van der Berg → vanderberg, berg; García-López → garcialopez, garcia, lopez), double first names (Jean-Pierre → jeanpierre, jean).
2. Checks the domain over DNS: no domain, no MX, or a null MX (RFC 7505) ends in an explicit row with the reason.
3. Reads the company's own site (home, contact, about, team; robots.txt honoured; 8-second timeouts; only that one domain) to see which address shape it publishes (first.last, flast, …). Role addresses (info@, sales@) are ignored. If the exact address is published, it scores 0.97.
4. Generates and ranks candidates from twelve conventions (first.last, flast, first, firstlast, f.last, first_last, firstl, last.first, …).
5. Verifies the top N (default 3) per person through lyfe_tools/catchall-email-verifier, and returns the best one only if the verifier says keep. test, review and discard stay a best guess and are free.

What it does not do

• It does not guarantee an address exists. Unverified scores are the share of the candidate weight, not a probability. The prior weights are rough orders of magnitude, not fitted to data. Only the verifier's score is calibrated, and on catch-all domains even that is a judgement, not a fact.
• No SMTP probing. Apify blocks outbound mail ports; verification works from DNS and name signals, which is what the verifier was measured on.
• It does not read LinkedIn or any third-party site, and it does not search the web for people. It only needs what you give it.
• It finds work addresses on company domains. Free-mail domains (gmail.com, …) make no sense as input.

Input example

{
  "people": [
    { "first_name": "Maria", "last_name": "Gonzalez", "domain": "stripe.com" },
    { "first_name": "Jan", "last_name": "van der Berg", "domain": "lyfeoffshore.com" }
  ],
  "verify": true, "verifyTop": 3, "minScore": 60, "inspectWebsite": true
}

domain may also be company_domain, website, url or an email at the company; a single name (or full_name) column works too, or pass inputDatasetId to read the rows from another Actor's dataset.

Output example

One row per person. This row is from a local run with verification off (so verified is false and nothing is billed):

{
  "firstName": "Maria", "lastName": "Gonzalez", "domain": "stripe.com",
  "email": "maria.gonzalez@stripe.com",
  "found": true, "score": 0.653, "status": "found",
  "verified": false, "billable": false,
  "pattern": "first.last",
  "reasons": ["pattern first.last (65% of candidate weight)"],
  "sitePublishedShape": "dot",
  "alternatives": [
    { "email": "m.gonzalez@stripe.com", "score": 0.115, "pattern": "f.last" },
    { "email": "gonzalez.maria@stripe.com", "score": 0.058, "pattern": "last.first" },
    { "email": "maria.g@stripe.com", "score": 0.038, "pattern": "first.l" },
    { "email": "mgonzalez@stripe.com", "score": 0.037, "pattern": "flast" }
  ]
}

Field	Meaning
email	The address, or null when not found
found	With verification on: the best candidate scored at least minScore and the verifier said keep. With it off: the best candidate scored at least minScore
billable	true only when found and verified as keep; these are the rows you pay for
verified / verifierAction	Whether the verifier checked the best candidate, and its verdict (keep, test, review, discard)
score	0 to 1. Unverified: share of the candidate weight. Verified: the verifier's probability
pattern	The address convention of the best candidate (first.last, flast, ...)
reasons	Why it scored as it did, or why the person failed
alternatives	Up to four other candidates with score and pattern
bestGuess	When not found: the top candidate, never billed
sitePublishedShape	The address shape seen on the company's own site, if any
status	found, not_found, no_domain, no_name, domain_null_mx, domain_no_domain, domain_no_mail, domain_dns_error
firstName, lastName, domain, company	The person as read from the input

A SUMMARY record in the key-value store has the totals.

Price, and what verification adds

Price per 1,000 by your Apify plan (Apify applies the right column automatically):

	Free	Starter	Scale	Business and up
Email address found, per 1,000	$5.00	$2.40	$2.00	$1.60

No start fee. The figures below use the Free-plan price; on a paid plan the same run costs less.

	Price
Email address found and verified	$0.005 per address the verifier marks keep; everything else is free

Platform usage is included. Verification is billed separately, on your account: with verify on, this Actor starts the verifier once per run as your run, so you pay its price too: $0.0012 per candidate address on the Free plan ($0.0006 to $0.0009 on paid plans), no start fee. Only people whose domain passes the DNS check send candidates. At the default 3 candidates per person:

People	Verifier (billed by the verifier)	This Actor	Total
1,000	up to $3.60	$0.005 per verified address, at most $5.00	at most $8.60
10,000	up to $36.00	at most $50.00	at most $86.00

The "at most" assumes every person is found and verified; you pay this Actor only for the ones that are. Fewer candidates (verifyTop) lowers the verifier part, and with verify: false (or outside the platform) nothing is billed by this Actor at all. A run's max-charge limit (ACTOR_MAX_TOTAL_CHARGE_USD) caps the number of people processed.

Use it from code or an AI agent

curl -X POST "https://api.apify.com/v2/acts/lyfe_tools~email-finder-by-name-domain/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"people": [{"first_name": "Maria", "last_name": "Gonzalez", "domain": "stripe.com"}], "verify": true}'

The response is the dataset rows as a JSON array. The Actor also works through the Apify MCP server (https://mcp.apify.com), so AI agents such as Claude or Cursor can call it as a tool: an agent sends people (first_name, last_name, domain) and reads email, found, billable and reasons; when email is null, bestGuess is an unconfirmed candidate, not a found address.

Part of a lead-list workflow

1. Find: Email Finder by Name and Domain (this Actor)
2. Clean: Email List Cleaner
3. Verify: Catch-All Email Verifier
4. Check the domain: SPF, DKIM & DMARC Checker

Next step: pass this run's dataset ID as inputDatasetId to the Email List Cleaner. It reads the email column and skips people without a found address for free. Each later step accepts the previous run's dataset in inputDatasetId too. With verify on, found addresses here have already been through the verifier.

FAQ

How do I find someone's work email from their name and company? Send first_name, last_name and the company domain. The Actor builds candidates from twelve address conventions, ranks them using the formats the company's own site publishes, and verifies the top ones.

Do I pay for emails that are not found? No. This Actor bills only rows with billable: true (found and verified as keep). The verifier, when on, bills its own per-candidate price for every person it checks.

Is the email verified? With verify on, the top candidates go through the Catch-All Email Verifier, and only a keep counts as found. There is no SMTP probing, so on catch-all domains the verdict is a calibrated judgement, not proof.

Does it handle accents and compound surnames like van der Berg or García-López? Yes: accents are folded, German spellings tried as a variant, and compound surnames and double first names split into several candidates.

Does it search LinkedIn or the web? No. It reads only the company's own site (up to four pages, robots.txt honoured) and DNS.

Issues and questions: tools@lyfeoffshore.com.