# πŸ”Ž Email Finder & Verifier - Name & Domain to Email (`renzomacar/email-finder`) Actor Turn a person's name + company domain into their most-likely professional email. Generates the standard business patterns (first.last@, flast@, first@…), ranks them by commonness, and MX-verifies the domain so you keep only deliverable guesses. Keyless Hunter/Snov alternative β€” build. - **URL**: https://apify.com/renzomacar/email-finder.md - **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community) - **Categories:** Lead generation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per usage This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use 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 ## πŸ”Ž Professional Email Finder β€” Name + Domain β†’ Verified Email **You have a list of names and the companies they work at β€” but no email addresses.** This Actor closes that gap. Give it a person's name and their company's domain, and it returns the **most-likely professional email**, a **0–100 confidence score**, and the **full ranked list of candidate addresses** β€” with the company's mail domain **MX-verified** so you keep only guesses that can actually receive mail. No API key. No per-seat SaaS subscription. A keyless, pay-per-result alternative to Hunter.io and Snov.io's email finder. --- ### The problem: names are easy, emails are hard Prospect lists are everywhere. You export attendees from an event, scrape a conference speaker page, pull a list of a company's engineers from LinkedIn, or inherit a spreadsheet of "first name / last name / company." What you almost never get is the one thing you need to actually reach them: **the email address.** Guessing by hand doesn't scale. Is it `jane.smith@acme.com`? `jsmith@acme.com`? `jane@acme.com`? Every company picks a convention and sticks to it β€” but the convention differs from company to company, and trying all of them by hand across a few hundred rows is a day you'll never get back. This Actor does that guessing the way the paid tools do: it knows the **standard professional email patterns**, ranks them by how common they are in the real world, and checks that the company's domain can receive mail before handing you an answer. --- ### How pattern-based email finding works Companies overwhelmingly use one of about a dozen local-part formats. Given `first = "jane"`, `last = "smith"`, `domain = "acme.com"`, the Actor builds every one of them: | Pattern | Example | Rough prevalence\* | |---|---|---| | `first.last` | `jane.smith@acme.com` | most common (~1 in 3) | | `first` | `jane@acme.com` | very common at startups | | `flast` | `jsmith@acme.com` | classic corporate | | `firstlast` | `janesmith@acme.com` | common | | `first_last` | `jane_smith@acme.com` | occasional | | `firstl` | `janes@acme.com` | occasional | | `f.last` | `j.smith@acme.com` | occasional | | `lastfirst` | `smithjane@acme.com` | rarer | | `last.first` | `smith.jane@acme.com` | rarer | | `last` | `smith@acme.com` | rare | | `first-last` | `jane-smith@acme.com` | rare | | `lastf` | `smithj@acme.com` | rare | \*Prevalence weights are baked into the ranking β€” `first.last` is treated as the default best guess unless a stronger signal overrides it. It then does **one DNS MX lookup** on the domain (not per candidate β€” that would be wasteful), which tells us: - **Can this domain receive email at all?** No MX (and no A-record fallback) β†’ the whole domain is undeliverable and every guess is worthless. We tell you that up front instead of handing you a dead address. - **Who runs the mailbox** β€” Google Workspace, Microsoft 365, Zoho, Proofpoint, Mimecast, and more β€” classified from the MX hostnames. Useful for segmentation. The top-ranked, syntactically-valid candidate on a live domain becomes `bestEmail`. #### Consistency across a team If you're finding emails for several people at the **same company** in one run and you already know that company's convention, add `"knownPattern": "flast"` (or any pattern key from the table) to those rows. Every teammate at that domain then gets the same, consistent format β€” and a confidence boost β€” instead of the generic guess. --- ### The confidence score (0–100) `confidence` blends the signals that actually predict whether a guess is right: - **Pattern commonness** (up to 40 pts) β€” how frequently this format appears in the wild. - **Known/consistent pattern** (+25) β€” the guess matches a convention you asserted for the domain. - **Real MX records present** (+30) β€” the company's mail server is live and configured. - **Implicit A-record MX only** (+12) β€” the domain can *probably* receive mail, but weaker. - **Not a throwaway domain** (+5). Hard caps keep the number honest: no MX β†’ confidence is capped low (the address can't be delivered no matter how common the pattern), and disposable domains are floored near zero. Read it as: **80–100** = high-confidence, standard pattern on a healthy business mailbox; **50–79** = plausible best guess, verify before a high-stakes send; **below 50** = weak β€” thin name data, unusual domain, or no MX. --- ### Honest note: best-guess + MX-verified, **not** SMTP-confirmed This is important, and most tools blur it. This Actor tells you the **most probable** address and proves the **domain** can receive mail. It does **not** open an SMTP connection to confirm that one specific mailbox exists. Two reasons: 1. **Cloud IPs can't SMTP-probe reliably.** Port 25 is blocked or greylisted from most cloud providers, so a "mailbox check" from here returns false negatives. 2. **Catch-all domains accept everything.** Many companies accept mail to *any* address at their domain, so an SMTP "yes" wouldn't prove the mailbox is real anyway. So every live-domain guess carries some residual risk that it's a catch-all or an alias β€” surfaced as **`isCatchAllRisk: true`**. Treat `bestEmail` as a strong lead, not a guarantee. **The clean workflow:** run this finder, then pipe `bestEmail` into our **[Email Verifier](https://apify.com/renzomacar/email-verifier)** for the full syntax + MX + disposable/role/free deliverability read before you send. Find here, verify there, send clean. --- ### Example **Input:** ```json { "people": [ { "firstName": "John", "lastName": "Doe", "domain": "stripe.com" }, { "fullName": "Jane Smith", "domain": "notion.so" } ] } ```` **Output (one record per person):** ```json { "firstName": "john", "lastName": "doe", "domain": "stripe.com", "bestEmail": "john.doe@stripe.com", "confidence": 80, "pattern": "first.last", "hasMx": true, "mxProvider": "Google Workspace", "isDisposable": false, "isFreeProvider": false, "isCatchAllRisk": true, "allCandidates": [ { "email": "john.doe@stripe.com", "pattern": "first.last", "weight": 34 }, { "email": "john@stripe.com", "pattern": "first", "weight": 14 }, { "email": "jdoe@stripe.com", "pattern": "flast", "weight": 13 }, { "email": "johndoe@stripe.com", "pattern": "firstlast", "weight": 9 } ], "foundAt": "2026-07-04T00:00:00.000Z", "reason": "ok" } ``` You get the single best guess to act on, plus every alternative to fall back to. *** ### Input reference | Field | Type | Notes | |---|---|---| | `people` | array **(required)** | One object per person. | | `people[].firstName` | string | First name. | | `people[].lastName` | string | Surname. | | `people[].fullName` | string | Alternative to first/last β€” split automatically ("Jane Q. Smith" β†’ jane / smith). | | `people[].domain` | string | Company domain. Scheme, `www.`, and paths are stripped (`https://www.Acme.com/` β†’ `acme.com`). | | `people[].knownPattern` | string | Optional. Force a company's known convention (`first.last`, `flast`, `first`, …). | | `maxConcurrency` | integer | Parallel lookups, 1–25 (default 5). | Names are normalized (accents stripped, lowercased): "JosΓ©-Luis PΓ©rez" β†’ `joseluis` / `perez`. *** ### Use cases - **Build an outreach list from a list of names.** You have "name + company" rows (event exports, speaker lists, hiring pages). Get the emails to actually run the campaign. - **Enrich a CRM.** Fill the missing `email` field on contacts where you already know the person and their employer's domain. - **Sales prospecting at scale.** Feed a target-account team roster and get a ranked best guess per person β€” the Hunter/Snov "email finder" job, keyless and pay-per-result. - **Recruiting.** Reach candidates or hiring managers when you have the name and company. - **Partnerships / PR.** Turn a "who to contact" shortlist into reachable inboxes. *** ### Hunter.io / Snov.io alternative Paid email finders lock the same core job β€” name + domain β†’ likely email β€” behind monthly seat pricing and credit tiers. This Actor does the pattern generation and MX verification with **no account on a third-party service and no subscription**: you pay per email found on Apify's usage-based billing, and you own the output dataset (JSON, CSV, Excel, API). Same job, keyless, and it slots straight into the rest of the suite below. *** ### The suite: find β†’ enrich β†’ verify This Actor is one link in a full lead-gen chain. Chain them for end-to-end lists: - **[Website Contact Finder](https://apify.com/renzomacar/website-contact-finder)** β€” crawl any domain and pull out emails, phones and social links that are already published. - **[Company Enrichment](https://apify.com/renzomacar/company-enrichment)** β€” turn a bare domain into tech stack, MX provider and company signals. - **πŸ”Ž Email Finder** *(this Actor)* β€” name + domain β†’ the most-likely professional email. - **[Email Verifier](https://apify.com/renzomacar/email-verifier)** β€” take any email (including this Actor's `bestEmail`) and get a full syntax + MX + disposable/role/free deliverability score before you send. Typical pipeline: **enrich** the domain β†’ **find** the person's email β†’ **verify** it β†’ send. *** ### FAQ **Does it guarantee the email is real?** No β€” and no honest tool can without sending. It gives you the *most probable* address and proves the *domain* can receive mail. For per-mailbox risk, verify with our Email Verifier and, ultimately, a low-stakes first send. **Why don't you SMTP-check each mailbox?** Port 25 is blocked/greylisted from cloud IPs (false negatives) and catch-all domains accept everything (false positives). MX + pattern ranking is the reliable, honest signal from the cloud. **What if the company has no MX record?** We flag `hasMx: false` and cap confidence low β€” the domain can't receive mail, so no guess is deliverable. You still get the ranked candidates for reference. **Can it handle free emails like gmail.com?** No β€” free consumer domains have no company convention to predict, so those rows return no guess (flagged `isFreeProvider`). This tool is for **business** domains. **What about accents and middle names?** Accents are stripped and names lowercased. For `fullName`, the first token is the first name and the last token is the surname (middle names/initials are ignored). **How am I charged?** Pay-per-event: you're charged only for each person who yields a **deliverable** best-guess email (a real address on a domain with MX). Rows with no MX or bad input aren't billed. The `ACTOR_MAX_TOTAL_CHARGE_USD` cap is respected. *** ### Automate it Run on a schedule or trigger it from your stack: - **Schedule** a run to enrich new CRM contacts nightly. - **Apify API / SDK** β€” POST a `people` array, read the dataset back as JSON/CSV. - **Integrations** β€” pipe results to Google Sheets, Airtable, Zapier, Make, or your CRM, then chain into the **Email Verifier** for a clean, send-ready list. Point it at a list of names today and get back reachable inboxes. # Actor input Schema ## `people` (type: `array`): One object per person. Provide { "firstName": "John", "lastName": "Doe", "domain": "stripe.com" } β€” or use "fullName" instead of first/last. For each person we generate the standard professional email patterns for the domain, do one DNS MX lookup, and return the best-guess email + a 0–100 confidence + the full ranked candidate list. Optional per row: "knownPattern" (e.g. "first.last") to force a company's known convention. ## `maxConcurrency` (type: `integer`): How many people to process in parallel. Higher = faster on big lists; the default is a friendly value for public DNS resolvers. ## Actor input object example ```json { "people": [ { "firstName": "John", "lastName": "Doe", "domain": "stripe.com" }, { "firstName": "Jane", "lastName": "Smith", "domain": "notion.so" } ], "maxConcurrency": 5 } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "people": [ { "firstName": "John", "lastName": "Doe", "domain": "stripe.com" }, { "firstName": "Jane", "lastName": "Smith", "domain": "notion.so" } ], "maxConcurrency": 5 }; // Run the Actor and wait for it to finish const run = await client.actor("renzomacar/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "people": [ { "firstName": "John", "lastName": "Doe", "domain": "stripe.com", }, { "firstName": "Jane", "lastName": "Smith", "domain": "notion.so", }, ], "maxConcurrency": 5, } # Run the Actor and wait for it to finish run = client.actor("renzomacar/email-finder").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("πŸ’Ύ Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # πŸ“š Want to learn more πŸ“–? Go to β†’ https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "people": [ { "firstName": "John", "lastName": "Doe", "domain": "stripe.com" }, { "firstName": "Jane", "lastName": "Smith", "domain": "notion.so" } ], "maxConcurrency": 5 }' | apify call renzomacar/email-finder --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=renzomacar/email-finder", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "πŸ”Ž Email Finder & Verifier - Name & Domain to Email", "description": "Turn a person's name + company domain into their most-likely professional email. Generates the standard business patterns (first.last@, flast@, first@…), ranks them by commonness, and MX-verifies the domain so you keep only deliverable guesses. Keyless Hunter/Snov alternative β€” build.", "version": "0.1", "x-build-id": "ZOH7ffmgyZyZK4Vzc" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/renzomacar~email-finder/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-renzomacar-email-finder", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/renzomacar~email-finder/runs": { "post": { "operationId": "runs-sync-renzomacar-email-finder", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/renzomacar~email-finder/run-sync": { "post": { "operationId": "run-sync-renzomacar-email-finder", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "people" ], "properties": { "people": { "title": "People to find emails for", "type": "array", "description": "One object per person. Provide { \"firstName\": \"John\", \"lastName\": \"Doe\", \"domain\": \"stripe.com\" } β€” or use \"fullName\" instead of first/last. For each person we generate the standard professional email patterns for the domain, do one DNS MX lookup, and return the best-guess email + a 0–100 confidence + the full ranked candidate list. Optional per row: \"knownPattern\" (e.g. \"first.last\") to force a company's known convention." }, "maxConcurrency": { "title": "Max concurrency", "minimum": 1, "maximum": 25, "type": "integer", "description": "How many people to process in parallel. Higher = faster on big lists; the default is a friendly value for public DNS resolvers.", "default": 5 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```