Pricing

from $10.00 / 1,000 company enricheds

Try for free

Go to Apify Store

B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones

Try for free

Find emails from a name + company domain, a LinkedIn profile, or a whole company, in bulk. Pick the decision-makers you want (founder, CEO, VP) and get names, titles, phones and B2B emails ranked by confidence. An optional SMTP check confirms the inbox exists. Pay only for verified contacts.

Pricing

from $10.00 / 1,000 company enricheds

Rating

5.0

(2)

Developer

Muhamed Didovic

Actor stats

Bookmarked

350

Total users

109

Monthly active users

3.9 hours

Issues response

12 days ago

Last modified

Categories

Lead generation

Agents

You can access the B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones 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.2",
    "x-build-id": "jXtf3T0BuR4YAJRLV"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/memo23~email-finder/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-memo23-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/memo23~email-finder/runs": {
      "post": {
        "operationId": "runs-sync-memo23-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/memo23~email-finder/run-sync": {
      "post": {
        "operationId": "run-sync-memo23-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",
        "properties": {
          "people": {
            "title": "🧑 People (name + company domain → their email)",
            "type": "array",
            "description": "Person-level lookups. Each item is {\"fullName\": \"Patrick Collison\", \"companyDomain\": \"stripe.com\"} (plain strings like \"Patrick Collison, stripe.com\" also work). A LinkedIn profile URL (linkedin.com/in/…) is enough - the actor reads the public card for name and employer, then runs the same email path. For each person you get the most-likely business email with a ranked candidate list, live MX verification, the company's mail provider, and a confidence score. The company site is also scanned so a published address or the org's real naming pattern beats a blind guess. Billed per person with a mail-capable result."
          },
          "peopleDatasetId": {
            "title": "Or a dataset of people",
            "type": "string",
            "description": "Apify dataset ID whose rows already have a person: firstName + lastName + domain, fullName + website, or a linkedin.com/in/ URL. Read after the People list. Company-only rows are skipped. Same billing as People: charged only when a mail-capable email is found."
          },
          "linkedinUrls": {
            "title": "🔗 LinkedIn profile URLs",
            "type": "array",
            "description": "Public linkedin.com/in/… profile links. Each one is read as a logged-out visitor (name, headline, employer), the company domain is resolved, then the same person-email path as the People field runs. No login or cookies. Billed only when a mail-capable business email is found. You can also paste these URLs into People or the list box.",
            "items": {
              "type": "string"
            }
          },
          "emailList": {
            "title": "✅ Verify a list of emails (verify-only mode)",
            "type": "array",
            "description": "Paste emails to validate - one per line. When this is filled the actor runs in <b>verify-only</b> mode: it validates each email and exits (no finding/discovery). Each email returns syntax, MX, disposable, role-based, free-provider flags and a <b>valid / risky / invalid</b> verdict. Billed per email via the <code>emails-verified</code> event.",
            "items": {
              "type": "string"
            }
          },
          "discoverPeople": {
            "title": "🔎 Discover people (find WHO works there → their emails)",
            "type": "array",
            "description": "Discovery mode - don't know the people yet? Each query finds them AND resolves their emails in one run. Example: {\"website\": \"stripe.com\", \"jobTitles\": [\"engineering\", \"marketing\"]} scans the company's team/about/leadership pages, extracts every person matching your title filter, then runs each through the same verification pipeline as the People input (pattern inference, MX check, cross-checked against the site). Add a RocketReach API key below to also search the open web by job title + location WITHOUT naming a company, e.g. {\"jobTitles\": [\"CTO\"], \"locations\": [\"Austin\"]}. Fields per query: company, website, personName, jobTitles, locations, maxPeople. Plain strings work too (\"CTO @ stripe.com\"). Billed per person with a mail-capable result - discovery itself is free."
          },
          "domains": {
            "title": "Websites / domains",
            "type": "array",
            "description": "Company websites or domains to find emails for (most accurate - the site is scraped directly). One per entry, e.g. stripe.com or https://stripe.com.",
            "items": {
              "type": "string"
            }
          },
          "companyNames": {
            "title": "Company names",
            "type": "array",
            "description": "Company / brand names to discover a website for, then find emails. Use when you don't have the domain. One per entry.",
            "items": {
              "type": "string"
            }
          },
          "targetPersona": {
            "title": "🎯 Target decision-maker roles",
            "type": "array",
            "description": "Pick the decision-maker roles to find at every domain / company you supply above - the actor auto-builds the people search for each, so a plain domain list becomes a decision-maker search. Combine several. Leave empty to use the Discover people queries instead.",
            "items": {
              "type": "string",
              "enum": [
                "founder_ceo",
                "c_suite",
                "sales_leader",
                "marketing_leader",
                "engineering_leader",
                "finance_leader",
                "hr_leader",
                "operations_leader"
              ],
              "enumTitles": [
                "Founder / CEO / Owner",
                "Full C-suite",
                "Sales leader (VP/Head/CRO)",
                "Marketing leader (VP/Head/CMO)",
                "Engineering leader (CTO/VP Eng)",
                "Finance leader (CFO/Controller)",
                "HR / People leader",
                "Operations leader (COO)"
              ]
            }
          },
          "defaultCountry": {
            "title": "🌍 Country hint (optional)",
            "type": "string",
            "description": "Bias the persona people-search toward one country/region (e.g. \"United States\", \"United Kingdom\"). Applied to every auto-built persona query. Leave empty for no location filter."
          },
          "inputText": {
            "title": "Paste a list",
            "type": "string",
            "description": "Alternative - paste a blob of domains, company names, or LinkedIn /in/ profile URLs separated by new lines, commas, or semicolons. Domains (containing a dot) are treated as websites; linkedin.com/in/… links become person lookups; everything else as a company name."
          },
          "companies": {
            "title": "Structured queries (advanced)",
            "type": "array",
            "description": "Advanced: mix name + website + city/state per row for best disambiguation. Merged with the fields above."
          },
          "guardMode": {
            "title": "Match precision",
            "enum": [
              "business",
              "off",
              "residential"
            ],
            "type": "string",
            "description": "How strictly a discovered domain must match the company name. 'business' = name match (default, recommended). 'off' = accept any Clearbit match. 'residential' = property/real-estate mode.",
            "default": "business"
          },
          "onlyWithEmails": {
            "title": "Only output companies with emails",
            "type": "boolean",
            "description": "On by default: emit (and bill) only company rows where at least one email was found - so you pay only for successful hits, never for a no-email company. Set to false to also emit no-email rows (useful for auditing coverage); those company rows are billed when emitted.",
            "default": true
          },
          "verifyEmails": {
            "title": "✅ Verify emails (find + validate in one pass, billed per email)",
            "type": "boolean",
            "description": "Validate every email found: checks syntax, looks up the domain's MX record (does it accept mail?), and flags disposable, role-based (info@, sales@) and free-provider (gmail, etc.) addresses. Adds an `emailVerifications` array plus `validEmails`, `validEmailCount` and `bestValidEmail` - so you get deliverable addresses, not just candidates. Includes a real SMTP mailbox check by default (toggle below), which adds `mailboxConfirmed` per email and `confirmedEmailCount` per company. Billed per email verified.",
            "default": false
          },
          "smtpCheck": {
            "title": "📮 Also check the mailbox over SMTP",
            "type": "boolean",
            "description": "Ask the company's mail server whether an address exists (EHLO → MAIL FROM → RCPT TO), with a random-address test to detect catch-all domains. Person rows: the top candidates (up to 4) are checked in order and the first one the server accepts becomes `email` with `mailboxConfirmed: true`; if the server refuses all of them, `email` is null and the row is not billed. Verified emails (`verifyEmails`, `emailList`) get an `smtp` object and `mailboxConfirmed`. Runs from our own mail-check server, because Apify blocks the SMTP port. When a server can't be reached or won't answer, results fall back to the DNS/MX check. A confirmed person email bills Person email confirmed on top of Person email found. Turn off for a faster DNS-only pass.",
            "default": true
          },
          "maxVerifiedEmailsPerCompany": {
            "title": "Max verified emails per company",
            "minimum": 1,
            "type": "integer",
            "description": "Optional ceiling on how many emails are verified per company. Verification is billed per email, and one company can legitimately expose dozens of addresses, so this is how you bound that spend. Any emails beyond the ceiling are still returned - just unverified and unbilled. Leave empty to verify everything found (the default behaviour)."
          },
          "qualifyByPayment": {
            "title": "💳 Qualify by payment (flag businesses that take money online)",
            "type": "boolean",
            "description": "Scans each business's website - reusing the pages already fetched for email discovery, so no extra cost or time - for payment processors and e-commerce platforms (Stripe, Shopify, PayPal, Paddle, Lemon Squeezy, WooCommerce, Square, Chargebee and more). Adds `takesPayments` (is this a real paying business?), `paymentProcessors` (which stack), `stripeLiveKey` (the public key if exposed) and `paymentConfidence`. Turn raw contacts into monetization-qualified leads. No extra charge - included with each enriched company (billed under the existing Company enriched event).",
            "default": false
          },
          "hunterApiKey": {
            "title": "Hunter.io API key (optional)",
            "type": "string",
            "description": "Optional - supply your own Hunter.io key to enable a paid domain-search fallback when the site scrape finds no emails. Leave empty to use the free site-scrape path only."
          },
          "rocketreachApiKey": {
            "title": "RocketReach API key (optional, unlocks open-web discovery)",
            "type": "string",
            "description": "Optional - an OFFICIAL RocketReach API key (rocketreach.co → Settings → API) upgrades Discovery mode to open-web people search: filter by job title, location, industry and employer without naming a company. The actor only calls the SEARCH endpoint and resolves emails with its own verification pipeline - it never triggers RocketReach per-contact lookups, so your unlock credits are not spent. Leave empty to use the built-in team-page discovery engine."
          },
          "maxDiscoveredPeople": {
            "title": "Max discovered people",
            "minimum": 1,
            "type": "integer",
            "description": "Global cap on people processed by Discovery mode this run (across all discovery queries). Per-query caps can be set with each query's maxPeople field (default 25).",
            "default": 200
          },
          "maxItems": {
            "title": "Max items (companies + people combined)",
            "minimum": 1,
            "type": "integer",
            "description": "Hard cap on how many items this run processes. The budget is SHARED: companies are taken first, and person lookups get whatever is left over, so a long company list can leave no room for the `people` you also submitted (the run log warns when that happens). Free plans are capped at 25.",
            "default": 100000
          },
          "maxConcurrency": {
            "title": "Max concurrency",
            "minimum": 1,
            "maximum": 50,
            "type": "integer",
            "description": "How many companies to enrich in parallel.",
            "default": 10
          },
          "proxy": {
            "title": "Proxy configuration (optional override)",
            "type": "object",
            "description": "Leave empty - the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
          }
        }
      },
      "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

B2B Email Finder & Verifier - Find Emails from LinkedIn 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 B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones 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:

B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones API in Python

B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones API in JavaScript

B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones API through CLI

B2B Email Finder & Verifier - Find Emails, LinkedIn & Phones API

bol.com Scraper — Seller Leads (VAT, KvK, Email) & Products

memo23/bol-com-seller-leads-scraper

Scrape bol.com (NL + BE) seller leads and products, pure HTTP. Each seller: legal company name, VAT number (NL and BE), KvK / KBO number, registered address and seller score, plus an optional verified email. Search, category, seller or product URLs. JSON/CSV.

Muhamed Didovic

Páginas Amarelas / pai.pt Scraper

memo23/paginasamarelas-scraper

Scrape pai.pt (Páginas Amarelas Portugal) into structured business rows: name, phone, email when listed, website, address, hours. Keyword plus city, nationwide PT, or a search/profile URL. JSON or CSV out. $5 per 1,000 listings.

Muhamed Didovic

Skroutz Seller Contact Scraper — Email, Phone, GEMI

memo23/skroutz-sellers-scraper

Turn a Skroutz.gr keyword, product or shop URL into a lead list of the shops selling those products — legal name, seat address, GEMI number, AFM when published, phone and email from the shop card. Every competing offer, not just the cheapest. Greece. Pure HTTP. JSON or CSV.

Muhamed Didovic

Collecting Cars [$3💰] | 33k SOLD prices + live bids

memo23/collectingcars-scraper

💰$3 per 1,000 lots. Turn Collecting Cars into auction-results data: ~33,000 finished lots with their sale prices, plus every live lot with its current bid and closing time. Filter by country, make, year and price. Optional VIN, colours, original market and full write-up.

Muhamed Didovic

Car & Classic [$1💰] | Full 46k catalogue | Beats 10k cap

memo23/carandclassic-scraper

💰$1 per 1,000 listings. Scrape the FULL Car & Classic catalogue. The site's API serves only the first 10,000 results of any search, so rival scrapers stop there; this one slices automatically and gets all ~46,000 listings across Europe, with dealer phones and live auction bids.

Muhamed Didovic

5.0

(2)

Dot Property + Lamudi Scraper | PH Real Estate + Exact GPS Pin

memo23/dotproperty-scraper

Scrape dotproperty.com.ph AND lamudi.com.ph — Philippines real-estate listings with the EXACT map-pin coordinates (lat/lng), price, beds, baths, areas, facilities, photos, agent info. Houses, condos, land, offices — rent or sale. Monitoring mode returns only new listings. JSON/CSV out.

Muhamed Didovic

Email Pattern Finder - Discover Company Email Formats

ryanclinton/email-pattern-finder

Detect the email naming convention any company uses (first.last, flast, first_last, etc.) from public sources — website, GitHub, WHOIS, and Hunter.io. Generate verified email addresses for any person. Bulk domain processing. $0.10/domain.

Ryan Clinton

743

1.0

(1)

Clean Email Verifier

corner_cutter/clean-email-verifier

Professional email validation tool that checks deliverability and identifies risky or invalid addresses. Validate bulk email lists with detailed status reports. Ideal for lead validation, CRM cleaning, and email marketing campaigns.

ReactRuby

5.0

(6)

PistonHeads.com [$1💰] | Full 208k catalogue | Real pagination

memo23/pistonheads-scraper

💰$1 per 1,000 cars. Scrape the FULL PistonHeads catalogue — rival scrapers loop on page one because the site ignores its own page parameter. Get price, mileage, spec, seller and photos per car. Filter by make, model, price, year, mileage or postcode radius. Optional descriptions + galleries.

Muhamed Didovic

5.0

(1)

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.