Pricing

$2.00 / 1,000 per person resolveds

Try for free

Go to Apify Store

Work Email Finder - Name + Domain to Email, Pattern & Score

Try for free

Give it a first name, last name and company domain; get back ranked work-email candidates. Each guess is built from REAL addresses observed at that domain (GitHub, npm, team pages) plus MX/SPF/DMARC, so the confidence score is earned, not invented. Source URLs on every row. No fake SMTP checks.

Pricing

$2.00 / 1,000 per person resolveds

Rating

0.0

(0)

Developer

Scrapers Delight

Actor stats

Bookmarked

Total users

Monthly active users

a day ago

Last modified

Categories

Lead generation

Automation

Business

You can access the Work Email Finder - Name + Domain to Email, Pattern & Score programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "sXZqrpk43oi0bd6qv"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/scrapersdelight~work-email-finder-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-scrapersdelight-work-email-finder-scraper",
        "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/scrapersdelight~work-email-finder-scraper/runs": {
      "post": {
        "operationId": "runs-sync-scrapersdelight-work-email-finder-scraper",
        "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/scrapersdelight~work-email-finder-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-scrapersdelight-work-email-finder-scraper",
        "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",
        "properties": {
          "people": {
            "title": "People to resolve",
            "type": "array",
            "description": "The list to resolve. One object per person: `{ \"firstName\": \"Michael\", \"lastName\": \"Broshi\", \"domain\": \"stripe.com\" }`. `fullName` works instead of first/last, and `companyDomain` / `website` work instead of `domain` (a full URL is fine - it is reduced to the host). Evidence is cached per domain, so 50 people at one company cost barely more than one."
          },
          "personLines": {
            "title": "People as text lines (paste-friendly)",
            "type": "array",
            "description": "An alternative to the JSON list, for pasting out of a spreadsheet. One person per line, comma separated: `Michael Broshi, stripe.com` or `Michael, Broshi, stripe.com`.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "firstName": {
            "title": "First name (single person)",
            "type": "string",
            "description": "Convenience path for resolving one person. Use with Last name + Company domain."
          },
          "lastName": {
            "title": "Last name (single person)",
            "type": "string",
            "description": "Convenience path for resolving one person. Use with First name + Company domain."
          },
          "companyDomain": {
            "title": "Company domain (single person)",
            "type": "string",
            "description": "The company's domain, e.g. `stripe.com`. A full URL is accepted and reduced to the host. This is the company's domain, NOT the person's email domain - if the two differ, the actor detects it and reports `mailDomain`."
          },
          "useGithub": {
            "title": "Use GitHub commit evidence",
            "type": "boolean",
            "description": "Read the company's public GitHub org and pull the author name + address off recent public commits. This is the single richest evidence source on technology companies (measured: 56 of 100 commits on one repo carried @stripe.com addresses). It contributes nothing on a domain with no GitHub org.",
            "default": true
          },
          "useRegistries": {
            "title": "Use npm + PyPI package evidence",
            "type": "boolean",
            "description": "Read public package-registry metadata (npm maintainers/contributors, PyPI author) for addresses at the company's domain.",
            "default": true
          },
          "useWebsite": {
            "title": "Use the company website",
            "type": "boolean",
            "description": "Read the company's own site: homepage, robots.txt -> sitemap-discovered team / people / contact pages, and /.well-known/security.txt. This is the tier that works on non-technology companies, and the one that catches a company whose people are on a different mail domain than its website.",
            "default": true
          },
          "maxWebsitePages": {
            "title": "Max website pages per domain",
            "minimum": 0,
            "maximum": 30,
            "type": "integer",
            "description": "How many discovered team/people/contact pages to read per domain, on top of the homepage. Higher finds more evidence and costs more time. 0 reads only the homepage.",
            "default": 8
          },
          "maxGithubRepos": {
            "title": "Max GitHub repos per domain",
            "minimum": 0,
            "maximum": 10,
            "type": "integer",
            "description": "How many of the org's most recently pushed public repos to read commits from (100 commits each). Each repo is one API call against GitHub's 60-per-hour unauthenticated limit.",
            "default": 3
          },
          "githubToken": {
            "title": "GitHub token (optional)",
            "type": "string",
            "description": "Optional read-only GitHub personal access token. Unauthenticated GitHub allows 60 requests per hour per IP; a token raises that to 5,000, which matters on bulk runs. No scopes are needed - a token with no permissions works for public data."
          },
          "maxCandidates": {
            "title": "Candidates per person",
            "minimum": 1,
            "maximum": 20,
            "type": "integer",
            "description": "How many ranked email candidates to return in `candidates[]`. The full ladder is what makes the row auditable: even when agreement is high, the true address is sometimes the #2 or #3 pattern.",
            "default": 8
          },
          "maxSecondsPerDomain": {
            "title": "Evidence budget per domain (seconds)",
            "minimum": 15,
            "maximum": 600,
            "type": "integer",
            "description": "Hard cap on how long the evidence tiers may spend on one domain. When it expires the row is still emitted from what was gathered plus the DNS/RDAP profile, and `blockedSources` says the budget ran out. This exists because a single site with a 6,000-URL sitemap or a stalling page would otherwise consume the whole run.",
            "default": 75
          },
          "maxPeople": {
            "title": "Max people",
            "minimum": 0,
            "type": "integer",
            "description": "Safety cap on how many people from the input are resolved in one run. 0 means no cap (up to a 5,000 hard limit).",
            "default": 1000
          },
          "proxyConfiguration": {
            "title": "Proxy configuration",
            "type": "object",
            "description": "Applies to GitHub, npm, PyPI and company websites. DNS-over-HTTPS always runs direct - Cloudflare's resolver does not block datacenter IPs and proxying it only adds latency. Switch to RESIDENTIAL if a company site refuses datacenter IPs.",
            "default": {
              "useApifyProxy": true
            }
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Email Finder by Name and Domain - Work Email Lookup OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Work Email Finder - Name + Domain to Email, Pattern & Score from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Work Email Finder - Name + Domain to Email, Pattern & Score API in Python

Work Email Finder - Name + Domain to Email, Pattern & Score API in JavaScript

Work Email Finder - Name + Domain to Email, Pattern & Score API through CLI

Work Email Finder - Name + Domain to Email, Pattern & Score API

Email Pattern Finder - Work Email Format by Name + Domain

flash_scraper/email-pattern-finder

Work email finder: give a person's name and a company domain and get ranked address guesses (first.last@, flast@, first@...). Crawls the company site to detect its real email format and pattern, and MX-checks the domain + provider. Confidence-scored, no API key, pay-per-result.

Flash Scrape

Email Finder & Verifier

novashieldai/email-finder

Find corporate email addresses by name and domain. Verify emails via SMTP, detect email patterns, and search domains for public emails.

Ali haydar Karadaş

Email Finder - Name + Domain to Work Email

logiover/work-email-finder

Find the most likely business email from a person's name and company domain. Ranks every common corporate pattern (first.last, flast, first…) by real-world frequency and validates the domain over DNS (MX). Pure DNS — no rate limits, no bans, always returns a result. Bulk in/out via CSV, Excel, JSON.

Logiover

🔎 Email Finder - Name & Domain to Verified Email

renzomacar/email-finder

Email finder: turn a name + company domain into the most-likely professional email. Generates standard business patterns (first.last@, flast@, first@...), ranks by commonness and MX-verifies the domain so you keep only deliverable guesses. No LinkedIn, no API key. Keyless Hunter/Snov alternative.

Renzo Madueno

Work Email Finder — Person & Company

coregent/work-email-finder

Find a verified work email from a name plus company domain, or a public LinkedIn handle — or discover the contacts at a whole company by domain or company name. Filter by department, seniority and decision-maker status. Bulk and CSV ready. No LinkedIn login, API key or proxy setup.

Delowar Munna

Email Finder — Name + Domain to Work Email + Score

bovi/email-finder

Find a person's likely work email from their name + company domain. Returns an MX-validated best-guess address with a numeric confidence score, role & disposable flags, and ranked alternative candidates — not a single bare guess.

Vitalii Bondarev

139

Email Finder & Verifier API — Find Verified B2B Emails

qualifyops/email-finder-verified

Email finder + verifier: give a name and company domain, get their verified, deliverable work email — live SMTP check, catch-all excluded, no bounces. Find and verify anyone's business email before you send. Pay only per verified email found. B2B leads, cold email, sales prospecting.

QualifyOps

Bulk Domain Email Finder — All Verified Emails at a Company

qualifyops/domain-email-finder-verified

Domain email finder: enter a company domain, get every verified deliverable email — published contacts plus role mailboxes (info@, sales@, contact@) — SMTP-checked, catch-all excluded, no bounces. Build B2B lead lists for cold email and sales prospecting. Pay only per verified email found.

QualifyOps

1.0

(1)

Email Finder & Verifier - MX + pattern confidence

korado_labs/email-finder-verifier

Find business emails from a name + company domain. Guesses the likeliest pattern, verifies the domain's MX records, scores confidence, and flags catch-alls. Plug in your own SMTP verifier API for mailbox-level checks. Clean per-contact pricing.