# Website Email Finder: Pay Only for Checked Emails (`scoutforge/find-business-emails-from-websites`) Actor

Find public business emails on company websites. Scan homepages, contact, legal and about pages, filter junk addresses, and check mail routing. Includes company-domain and optional Gmail/Outlook emails. Pay only when an email is found.

- **URL**: https://apify.com/scoutforge/find-business-emails-from-websites.md
- **Developed by:** [Scout Forge](https://apify.com/scoutforge) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 website with a checked emails

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Stop opening websites one by one just to find an email.

### Give it your company websites. It finds the public business emails hiding on them. You pay only when a checked email is found.

You already have the companies.

Maybe you have 100 websites from a prospecting database. Maybe 1,000 domains from Google Maps. Maybe a list you've built yourself.

The websites are there.

But the email you need may be buried on the homepage, a Contact page, an About page, the legal notice, the team page — or several clicks away.

This Actor searches those pages for you.

For example, a website can return:

```
newviewroofing.com              → info@newviewroofing.com
dallasroofer.com                → info@dallasroofer.com
clcroofing.com                  → info@clcroofing.com
cabinet-dentaire-compagnone.fr  → contact@cabinet-dentaire-compagnone.fr
cabinetdentairemermoz.fr        → secretariat@cabinetdentairemermoz.fr
cnpandh.co.uk                   → contact@cnpandh.co.uk
```

The Actor tells you where the email was found and checks its syntax and the domain's mail-routing infrastructure.

**No guessing. No employee database. No opening websites one by one.**

Give it the websites. Get back the emails those websites publicly expose.

### Why you pay only when an email is found

Most website scraping workflows charge you for processing the website whether or not there is anything useful on it.

This Actor is different.

If a website contains no suitable public email, it can return:

```
no_email_found
```

It does not generate the successful `site-with-email` event.

When a checked email is found, the Actor pushes the billable email result.

That means your spend is tied to the outcome you actually want:

**a website with a usable public email.**

You are not paying the Actor's successful email-result fee simply because a website was visited and contained no email.

### Your first email list in 3 minutes

1. Click **Try for free**.
2. In **Company websites**, paste your domains or URLs, one per line.
3. Set **Number of websites** to the number you want to process.
4. Choose whether to **Include Gmail & other public email addresses**.
5. Set **Emails per website** if you want more than one address.
6. Click **Start**.
7. When the run finishes, open the **Output** tab and export your results.

Start with 10–20 websites.

You will immediately see how many businesses in your particular dataset publish an email and where those emails are located.

### The Actor looks where a human would look

A homepage-only email scraper misses a surprising number of addresses.

This Actor starts with the homepage and then looks for relevant internal pages.

It can follow links such as:

- Contact
- Contact Us
- Contactez-nous
- About
- À propos
- Team
- Équipe
- Legal
- Legal Notice
- Mentions légales
- Privacy
- Booking
- Appointment
- Rendez-vous

It can also check relevant fallback paths such as:

```
/contact
/contact-us
/contactez-nous
/mentions-legales
/legal
/privacy
/about
/a-propos
/team
/equipe
```

The objective is simple:

**If the company has publicly published an email somewhere on its website, look for it before giving up.**

### It prefers the email you actually want

A website can contain several email addresses.

For example:

```
info@company.com
contact@company.com
sales@company.com
support@company.com
someone@gmail.com
```

The Actor evaluates the candidates and prefers company-domain business addresses and useful generic or role-based mailboxes.

Typical preferred addresses include:

- `info@`
- `contact@`
- `sales@`
- `commercial@`
- `support@`
- `service@`
- `devis@`
- `accueil@`

The result includes an `emailQuality` classification:

- `preferred`
- `good`
- `acceptable`

### Want Gmail and Outlook too?

Some small businesses publish a Gmail, Outlook, Orange or other public email address instead of using their own domain.

You can decide whether to include them.

Turn **Include Gmail & other public email addresses** on to include publicly listed addresses from providers such as:

- Gmail
- Outlook
- Hotmail
- Yahoo
- Orange
- Free
- SFR
- iCloud
- Proton
- GMX
- and other supported public email providers

Turn it off when you want company-domain emails only.

### What happens to every website?

Not every website produces an email.

The Actor keeps track of what happened.

| Status | Meaning |
|---|---|
| `found` | A suitable public email was found |
| `no_email_found` | The website was accessible, but no suitable email was found |
| `blocked` | The website blocked access |
| `unreachable` | The website could not be reached |
| `invalid_website` | The supplied website could not be processed |

This matters when you're processing a large list.

You can distinguish:

**"There is no email on this website"**

from:

**"The website could not be accessed."**

### What each result contains

| Field | Content |
|---|---|
| `website` | Website supplied as input |
| `finalUrl` | Final URL reached after redirects |
| `domain` | Website domain |
| `status` | Processing result |
| `failureReason` | Reason when processing failed |
| `httpStatusCode` | HTTP response status |
| `email` | Best email found |
| `otherEmails` | Additional emails found |
| `emailType` | Type of email |
| `emailQuality` | Quality classification |
| `emailSourceType` | How the email was detected |
| `emailEvidence` | Evidence associated with the email |
| `emailCheck` | Syntax and mail-routing check |
| `mailRouting` | Whether mail-routing infrastructure was detected |
| `foundOn` | Page where the email was found |
| `pagesCheckedCount` | Number of pages checked |
| `contactPage` | Relevant contact page information |
| `contactFormFound` | Whether a contact form was detected |
| `checkedAt` | Date and time of the check |

Emails are found on publicly accessible website pages, including home, contact, legal, about and other relevant pages.

### Where the emails come from

The Actor does not guess an email address from a person's name.

It searches the website itself.

An email can be found:

- in visible page content
- in a `mailto:` link
- on the homepage
- on a contact page
- on a legal page
- on an about page
- on a team page
- on another relevant page discovered while crawling the website

That distinction is important.

**You are extracting what the company has publicly published — not guessing what its email address might be.**

### What "checked" means

The Actor performs two checks on a discovered email.

#### Email syntax

It checks whether the address has valid email syntax.

#### Mail routing

It checks whether the email domain has mail-routing infrastructure.

The Actor checks DNS records such as:

- MX
- A
- AAAA

For example:

```
email: info@example.com
emailCheck: syntax + MX
mailRouting: true
```

#### Important

A working mail server does **not** prove that the individual mailbox exists.

This Actor does not perform SMTP mailbox verification.

So when the Actor says an email has been checked, it means:

**valid email syntax + mail-routing infrastructure detected for the domain.**

It does not mean:

**"we sent a test email and confirmed that the mailbox exists."**

### One website. Several possible emails.

When a website exposes several addresses, the Actor can return the main email together with additional addresses.

For example:

```
email: contact@example.com
otherEmails:
  - info@example.com
  - sales@example.com
```

This gives you more information to work with without having to crawl the website yourself.

### For agencies, sales teams and prospecting workflows

This Actor is useful whenever you already have the websites but are missing contact information.

Typical users include:

- Lead generation agencies
- Sales teams
- SEO agencies
- Freelancers
- Consultants
- Local prospecting teams
- Data-enrichment workflows
- B2B researchers

For example:

**SEO agency:** collect websites of local businesses, then find their publicly listed contact emails.

**Sales team:** enrich an existing company list before prospecting.

**Lead generation agency:** turn a list of domains into a structured email dataset.

**Local prospecting:** process websites collected from Google Maps or business directories.

### Google Maps lists work too

If you already have the websites from a Google Maps scraping workflow, you can pass those URLs directly to the Actor.

For example:

```
https://company-a.com
https://company-b.fr
https://company-c.co.uk
```

The Actor does not need the company's name.

**The website is enough to start the search.**

### Receive more than one email per website

By default, the Actor can return multiple email addresses when they are found.

Use **Emails per website** to control the maximum number returned.

This is useful when a company publishes separate addresses for:

- sales
- support
- commercial
- administration
- customer service

If you only want the main contact email, keep the setting low.

### Scan deeper when needed

Use **Pages to scan per website** to control how deeply the Actor searches.

A small website may reveal its email immediately.

Another website may require several pages.

Increasing the page limit gives the Actor more opportunities to find a publicly available email, at the cost of additional processing.

For slow websites, you can also increase the advanced **Timeout** setting.

### Who uses it

#### Lead generation agencies

Turn a list of company websites into a structured list of public business emails.

#### Sales teams

Enrich an existing prospect list before starting outreach.

#### SEO agencies

Find contact addresses for businesses identified during local SEO research.

#### Freelancers and consultants

Quickly collect contact information from a list of websites without manually opening every site.

#### Data enrichment workflows

Combine website data with other Apify Actors to build a complete prospecting pipeline.

### Input

| Field | What it does |
|---|---|
| `websites` | Company websites or domains, one per line |
| `maxDomains` | Maximum number of websites to process |
| `includeFreemail` | Include Gmail, Outlook and other public email providers |
| `maxEmailsPerSite` | Maximum emails returned per website |
| `maxPagesPerSite` | Maximum pages scanned per website |
| `timeoutSeconds` | Maximum processing time for an individual website |

The advanced technical settings are grouped separately so that the basic workflow stays simple.

#### Example

```json
{
  "websites": [
    "https://newviewroofing.com",
    "https://dallasroofer.com",
    "https://clcroofing.com"
  ],
  "maxDomains": 10,
  "includeFreemail": true,
  "maxEmailsPerSite": 3,
  "maxPagesPerSite": 8,
  "timeoutSeconds": 10
}
```

### Output example

```json
{
  "website": "https://newviewroofing.com",
  "finalUrl": "https://newviewroofing.com/",
  "domain": "newviewroofing.com",
  "status": "found",
  "email": "info@newviewroofing.com",
  "otherEmails": [],
  "emailType": "generic",
  "emailQuality": "preferred",
  "emailSourceType": "mailto_link",
  "emailEvidence": "mailto_link",
  "emailCheck": "syntax + MX",
  "mailRouting": true,
  "foundOn": "homepage",
  "pagesCheckedCount": 1,
  "contactPage": null,
  "contactFormFound": false,
  "checkedAt": "2026-10-02T00:00:00.000Z"
}
```

### Pricing

The Actor uses pay-per-event billing for websites where a checked email is found.

| What | Billing |
|---|---|
| Website with a checked email | Successful email-result event |
| Website with no email | No successful email-result event |
| Blocked website | No successful email-result event |
| Unreachable website | No successful email-result event |

Run a small sample first.

Then you can see how many websites in your own dataset actually produce useful email results before scaling up.

**Check the Actor's current pricing panel for the exact event price.**

### Free usage

Free users can process up to **10 websites per run**.

Paid users can process up to the configured `maxDomains` limit.

This lets you test the Actor on a small list before processing a larger dataset.

### Connect it to your tools

Once the Actor has produced the dataset, you can use the results in your existing workflow.

For example:

- Apify integrations
- Google Sheets
- Make
- n8n
- Zapier
- Webhooks
- Your own API workflow
- CRM enrichment workflows

A common workflow is:

**Company scraper → Business Email Finder → CRM / Google Sheets → Outreach**

You can also call the Actor from your own application using the Apify API.

### A simple prospecting workflow

If you are building a B2B prospecting system, the Actor can sit in the middle of the workflow:

```
Find companies
      ↓
Collect company websites
      ↓
Business Email Finder
      ↓
Public business emails
      ↓
CRM / Google Sheets
      ↓
Sales outreach
```

This keeps website discovery and email discovery as separate steps.

You can therefore replace the upstream company-data source without changing the email-finding step.

### What the Actor does not do

This Actor is focused on public email discovery from company websites.

It does not:

- guess personal email addresses
- guess email patterns
- require a person's name
- access private databases
- bypass authentication
- guarantee mailbox existence
- guarantee email deliverability
- perform SMTP mailbox verification

If an email is returned, it was found in publicly accessible website content that the Actor could process.

### Questions

**I received fewer emails than I expected.**

Check the `status` field.

Some websites simply do not publish an email. Others may block automated access.

You can also increase `maxPagesPerSite` to search deeper.

**I received `no_email_found`.**

The website was accessible, but no suitable public email was found within the pages the Actor scanned.

**Some websites are `blocked`.**

The website prevented the Actor from accessing its content.

This is different from a website that simply has no email.

**Can it find Gmail or Outlook addresses?**

Yes.

Enable `includeFreemail`.

**Can I search only company-domain emails?**

Yes.

Set `includeFreemail` to `false`.

**Can it find more than one email?**

Yes.

Increase `maxEmailsPerSite`.

**Does it verify that the mailbox exists?**

No.

It checks email syntax and domain mail-routing infrastructure.

It does not perform individual mailbox verification.

**Does it scan the whole website?**

It scans the homepage and relevant internal pages up to `maxPagesPerSite`.

**Can I process thousands of websites?**

Yes.

For large datasets, test a small batch first and adjust the number of pages and timeout according to the websites you are processing.

**Can I use websites from Google Maps?**

Yes.

Pass the website URLs extracted from your Google Maps workflow.

**Does it work with URLs as well as domains?**

Yes.

You can provide:

```
example.com
https://example.com
https://www.example.com/contact
```

The Actor normalizes the website and starts the scan from the appropriate domain.

**What happens if a website redirects?**

The final URL is recorded in `finalUrl`.

**Can it find emails hidden behind a contact form?**

The Actor can detect contact forms, but a contact form does not itself provide an email address.

If the website publishes an email elsewhere, the Actor can return it.

**What does `mailRouting` mean?**

It means the domain has detectable mail-routing infrastructure through DNS, such as MX, A or AAAA records.

It does not prove that a specific mailbox exists.

**Missing a feature?**

Open an issue on this Actor page and describe what you need.

# Actor input Schema

## `websites` (type: `array`):

Enter one company website per line. You can paste full URLs, domains, or website URLs from a Google Maps export. Example: https://example.com, example.fr, www.example.co.uk/contact.

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

Maximum number of unique website domains to check in this run.

## `includeFreemail` (type: `boolean`):

Keep public Gmail, Outlook, Yahoo, Orange, Free and similar addresses shown on the company website. Useful for small local businesses and tradespeople. Turn this off to keep only emails using the company's own domain.

## `maxEmailsPerSite` (type: `integer`):

The Actor returns the best email first, then additional emails from the same site. It prioritizes emails on the company domain and contact-style addresses such as info@ or contact@.

## `maxPagesPerSite` (type: `integer`):

The Actor checks the homepage first, then relevant contact, legal and about pages. Higher values may find more emails but make the run slower. Recommended: 8.

## `timeoutSeconds` (type: `integer`):

Maximum time to wait for one page. Raise this only for slow websites. Higher values can make the run longer. Recommended: 10 seconds.

## Actor input object example

```json
{
  "maxDomains": 10,
  "includeFreemail": true,
  "maxEmailsPerSite": 3,
  "maxPagesPerSite": 8,
  "timeoutSeconds": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxDomains": 10,
    "includeFreemail": true,
    "maxEmailsPerSite": 3,
    "maxPagesPerSite": 8,
    "timeoutSeconds": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scoutforge/find-business-emails-from-websites").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 = {
    "maxDomains": 10,
    "includeFreemail": True,
    "maxEmailsPerSite": 3,
    "maxPagesPerSite": 8,
    "timeoutSeconds": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scoutforge/find-business-emails-from-websites").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 '{
  "maxDomains": 10,
  "includeFreemail": true,
  "maxEmailsPerSite": 3,
  "maxPagesPerSite": 8,
  "timeoutSeconds": 10
}' |
apify call scoutforge/find-business-emails-from-websites --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scoutforge/find-business-emails-from-websites"
        }
    }
}
```

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/nEyx7tL0CbkfZ4Wc7/builds/N70AOJIy1rLQaxfGi/openapi.json