# Company Email Finder by Domain | Business Emails, $2.50/1K (`berkaydev/company-email-finder-by-domain`) Actor

Company email finder: give a list of domains, get every business mailbox the company publishes on its own website (info@, sales@, support@), where each was found, MX check and email provider. No personal addresses. Pay only per domain with emails found.

- **URL**: https://apify.com/berkaydev/company-email-finder-by-domain.md
- **Developed by:** [Gezgin Data](https://apify.com/berkaydev) (community)
- **Categories:** Lead generation, Automation, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 domain with company emails

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

**Company email finder by domain.** Give it a list of company domains and get back every business mailbox each company publishes on its own website (info@, sales@, support@, office@), with the page it was found on, whether the domain accepts mail, and which provider hosts it (Google Workspace, Microsoft 365, IONOS and others). Personal addresses like firstname.lastname@ are skipped on purpose, so the output is company contact data only. You pay only for domains where at least one company email was found.

### Who uses it

Sales and lead-generation teams turn a list of company domains into reachable company mailboxes without buying a contact database. Agencies enrich Google Maps or trade directory results with the email the business itself publishes. Recruiters, partner managers and journalists find the right department mailbox (sales@, partners@, press@) fast. Because personal addresses are never returned, the output stays company contact data, which keeps GDPR questions simple.

### What you get for each domain

You get one row per domain. The `emails` list holds every company mailbox found, best first: addresses on the company's own domain come before others, and general mailboxes (info@, contact@, sales@) come before department ones (support@, jobs@, press@). Each address says how it was found. A `mailto:` link is a stated fact, structured data on the page is nearly as good, and plain page text is the weakest source, so you can decide how much to trust it.

Next to the emails you get the phone number from the website, an MX check that tells you whether the domain can receive mail at all, and the mail provider. The provider is a useful sign for sales teams: a company on Microsoft 365 or Google Workspace is set up differently from one using its web host's mailbox.

Each domain also gets a mail-authentication check from public DNS: whether it publishes SPF and DMARC records and how strict they are. `emailAuthNote` puts the finding into one sentence, for example "No DMARC record: Gmail and Yahoo expect one from bulk senders, and the domain is easier to spoof." For an agency that sells email deliverability or IT security, that sentence is the reason to get in touch. In a sample of German manufacturers, several had SPF but no DMARC, or DMARC set to `p=none`, which only monitors.

When a domain has no company email, the row says why in plain words. The website may be dead, it may refuse automated visits, it may only publish a contact form, or it may list only personal addresses.

### Example

Input:

```json
{ "domains": ["acme-bakery.de", "https://www.example-studio.com/about"] }
```

Output (shortened):

```json
{
  "domain": "acme-bakery.de",
  "primaryEmail": "info@acme-bakery.de",
  "emails": [
    { "email": "info@acme-bakery.de", "type": "role", "onCompanyDomain": true, "source": "mailto_link", "foundOn": "https://acme-bakery.de/kontakt" },
    { "email": "bestellung@acme-bakery.de", "type": "role", "onCompanyDomain": true, "source": "page_text", "foundOn": "https://acme-bakery.de/impressum" }
  ],
  "emailCount": 2,
  "personalEmailsSkipped": 1,
  "phone": "+497071123456",
  "mxFound": true,
  "emailProvider": "IONOS",
  "spfFound": true,
  "spfPolicy": "fail",
  "dmarcFound": false,
  "dmarcPolicy": null,
  "emailAuthNote": "No DMARC record: Gmail and Yahoo expect one from bulk senders, and the domain is easier to spoof.",
  "statusNote": null
}
```

### How it works

The Actor opens the homepage, then reads up to six contact, imprint and about pages: the ones linked from the homepage first, then the usual paths in several languages (/contact, /kontakt, /impressum, /legal ...). It decodes Cloudflare's email protection and "name \[at] domain \[dot] com" style writing. It needs no browser and no API key, which keeps runs fast and cheap. A run of 100 domains usually takes one to two minutes.

It never guesses addresses. If info@ is not written on the website, it is not in the output.

### Input

- `domains` (required): domains or URLs, one per line.
- `maxPagesPerDomain`: extra pages to read per site (default 6, max 10).
- `includeDepartmentEmails`: also return support@, jobs@, press@ (default on).
- `includeOtherDomains`: also return addresses on other domains, such as the web agency in the footer (default off).
- `checkMx`: MX check and mail provider (default on).
- `checkEmailAuth`: SPF and DMARC check with a plain-words note (default on, free).
- `onlyWithEmails`: leave out domains without results.
- `compact`: short rows for AI agents.

### Chain it with other Actors

You do not have to copy websites between tools. Pass the dataset ID of an earlier run in `datasetId` and the Company Email Finder reads the websites from it. It finds the website column on its own (website, url, domain and similar); set `datasetField` if the column has another name, and `maxDomains` for a small first test.

A typical chain: run the [Google Maps Email Scraper](https://apify.com/berkaydev/google-maps-email-scraper-business-leads) for a trade and city, pass its dataset to the [Website Technology Detector](https://apify.com/berkaydev/website-technology-detector) and its results to the Company Email Finder, and you end up with businesses, their technology and their company mailboxes without touching a spreadsheet. AI agents can do the same in three calls. To know which of these companies are hiring right now, pass the same dataset to [Company Hiring Signals](https://apify.com/berkaydev/company-hiring-signals).

### FAQ

#### Can the Company Email Finder read websites from another Actor's results?

Yes. Pass the dataset ID of an earlier run in datasetId. The Company Email Finder detects the website column automatically and reads only that dataset, which you grant access to by passing it.

#### What does the Company Email Finder return?

The Company Email Finder returns every company mailbox published on a company's own website, such as info@, sales@ or support@, with the page it was found on, plus an MX check and the mail provider.

#### Does the Company Email Finder return personal email addresses?

No. The Company Email Finder counts personal addresses like firstname.lastname@ in personalEmailsSkipped but never returns them, so the output is company contact data only.

#### Does the Company Email Finder guess email addresses?

No. The Company Email Finder only returns addresses that are written on the company's website. If info@ is not published, it is not in the output.

#### What input does the Company Email Finder need?

The Company Email Finder needs a list of domains or URLs in domains, for example {"domains": \["stripe.com", "pipedrive.com"]}.

#### What does the Company Email Finder cost?

The Company Email Finder charges once per domain that returned at least one company email. Domains with nothing found, dead websites and refused requests are free. The price is in the Pricing tab.

#### Does the Company Email Finder verify that a mailbox exists?

The Company Email Finder checks whether the domain has a mail server (MX record), which shows the domain can receive email. It does not test individual mailboxes.

### Use it from an AI agent (MCP)

Connect this Actor to Claude, ChatGPT, Cursor or any other MCP client with one URL:

```
https://mcp.apify.com/?tools=berkaydev/company-email-finder-by-domain
```

Then ask in plain words, for example: *"Find the company email addresses for these 30 domains."* The agent fills in the input, runs the Actor and reads the results.

### Pricing

You pay per domain that returned at least one company email. Domains with nothing found, dead websites and refused requests are free. The current price is shown in the Pricing tab.

### Good to know

- Only addresses published on the company's own website are returned. Sites that hide contacts behind JavaScript or only offer a form will have no email.
- Personal addresses are counted in `personalEmailsSkipped` but never returned. This keeps the output to company contact data.
- An MX record shows that the domain can receive mail. It does not prove that a particular mailbox exists.
- Use the data in line with the laws that apply to you, for example GDPR and anti-spam rules for unsolicited email.

Questions or a site that should work but does not? Open an issue on the Issues tab.

# Actor input Schema

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

One company per line: a domain like acme.com or a full URL. Duplicates and paths are cleaned up automatically. Or leave this empty and use the dataset of an earlier run below.

## `datasetId` (type: `string`):

Chain Actors: pick or paste the dataset ID of an earlier run, for example from Google Maps Email Scraper or any scraper with a website column. The website field is detected automatically. Pass it in this field (datasetId) so the Actor is allowed to read it.

## `datasetField` (type: `string`):

Optional. Name of the column holding the website if it is not detected automatically, e.g. companyUrl.

## `maxDomains` (type: `integer`):

Process at most this many websites (0 = all). Useful for a cheap first test on a large dataset.

## `maxPagesPerDomain` (type: `integer`):

Besides the homepage, how many contact, imprint and about pages to read. More pages find more mailboxes but take longer.

## `includeDepartmentEmails` (type: `boolean`):

Also return support@, jobs@, press@ and similar department addresses. Turn off to get only general and sales mailboxes.

## `includeOtherDomains` (type: `boolean`):

By default only addresses on the company domain (and free-mail addresses the company publishes) are returned. Turn on to also see addresses on other domains, e.g. the web agency in the footer.

## `checkMx` (type: `boolean`):

Look up whether the domain accepts email and which provider hosts it (Google Workspace, Microsoft 365, IONOS ...).

## `checkEmailAuth` (type: `boolean`):

Read the domain's SPF and DMARC records from public DNS: is mail from this domain protected against spoofing, and how strictly? Free, adds well under a second per domain.

## `onlyWithEmails` (type: `boolean`):

Leave out rows for domains where no company email was found.

## `compact` (type: `boolean`):

Return only domain, primaryEmail, emails, phone, emailProvider and statusNote.

## `maxConcurrency` (type: `integer`):

How many domains are processed at the same time.

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

Usually not needed. Some sites refuse datacenter IPs; a proxy can help there.

## `maxRunTimeSecs` (type: `integer`):

The run stops cleanly before this limit and keeps everything found so far.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "basecamp.com"
  ],
  "maxDomains": 0,
  "maxPagesPerDomain": 6,
  "includeDepartmentEmails": true,
  "includeOtherDomains": false,
  "checkMx": true,
  "checkEmailAuth": true,
  "onlyWithEmails": false,
  "compact": false,
  "maxConcurrency": 10,
  "maxRunTimeSecs": 3000
}
```

# Actor output Schema

## `results` (type: `string`):

One row per domain with all company mailboxes, sources, MX check and provider.

## `runStatus` (type: `string`):

Domains processed, how many had company emails, hit rate, and the reason if nothing was found.

# 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": [
        "apify.com",
        "basecamp.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("berkaydev/company-email-finder-by-domain").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": [
        "apify.com",
        "basecamp.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("berkaydev/company-email-finder-by-domain").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": [
    "apify.com",
    "basecamp.com"
  ]
}' |
apify call berkaydev/company-email-finder-by-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,berkaydev/company-email-finder-by-domain"
        }
    }
}
```

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/xcyZXaoF6jmp3Tdey/builds/LCTjnQll4HIkIht0j/openapi.json
