# Website Email Finder (`futurizerush/website-email-finder`) Actor

Find a website's email by domain. Returns only real published emails, never guessed — one clean email per website, ready for outreach and lead generation. (Beta)

- **URL**: https://apify.com/futurizerush/website-email-finder.md
- **Developed by:** [Rush](https://apify.com/futurizerush) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## 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

## Website Email Finder

Website Email Finder takes a list of websites or domains and returns the best public email for each one. Drop in a domain like `apify.com` or a full link like `https://apify.com/contact`, and get a clean, ready-to-use email per website.

It is built for one job: finding emails. It reports the email it actually found and does not guess addresses or invent inboxes that were never published.

### What You Get

- The best public email for each website, chosen for outreach
- Every public email found for the website
- A clear status showing whether an email was found for each website
- The source page where the email appeared, so you can review it
- One simple row per website you submit — including websites where no public email was found

When the run finishes, click **Export** to download every result as CSV or Excel, ready to load into your outreach tool, CRM, or spreadsheet.

### Input

Add one or more websites or domains — up to 100 per run. Both a bare domain and a full link work:

```json
{
  "domains": ["https://apify.com/contact", "python.org", "https://www.mozilla.org/en-US/contact/"]
}
````

That is the only input — no settings to configure. The Actor does the work for you, so you do not need to tune anything.

- **Paste a whole column** of domains from your spreadsheet — each line becomes one website.
- **Up to 100 websites per run.** For a larger list, split it into separate runs of 100.
- **Duplicate websites are merged automatically.** If the same website appears more than once (for example `apify.com` and `https://apify.com/`), it is searched once and returned once, so you are never charged twice for the same website.

### Output

The default dataset contains one row per website:

```json
{
  "inputUrl": "yourcompany.com",
  "domain": "yourcompany.com",
  "status": "found_on_entry_page",
  "primaryEmail": "hello@yourcompany.com",
  "allEmails": ["hello@yourcompany.com", "sales@yourcompany.com"],
  "emailCount": 2,
  "sourceUrl": "https://yourcompany.com/",
  "message": "Email found and saved.",
  "savedAt": "2026-06-27T00:00:00.000Z"
}
```

For outreach, use the **Best email** (`primaryEmail`) column — one email per row, ready to import. **All emails** (`allEmails`) is a full list for manual review. The **Input** (`inputUrl`) column returns each website exactly as you submitted it, so you can match results back to your original list.

The `status` field tells you exactly how each result was reached:

- `found_on_entry_page` — the email was on the page you submitted
- `found_on_linked_page` — the email was found on another page of the same website
- `not_found` — the website was searched and no public email was found
- `skipped` — the entry could not be searched as a public website (for example, it is not a public website address). This will not change on a re-run unless you fix the entry.
- `failed` — the website could not be searched this time (for example, it was unavailable or does not allow automated searching). A later run may succeed.

A run summary is also saved with the totals for the run, including how many duplicate websites were merged.

### Good Use Cases

- Building public company contact lists for outreach
- Enriching a list of domains with one email each
- Lead research and sales prospecting
- Filling the email gap in a CRM or spreadsheet

### FAQ

#### How many results do I get?

You get one result row for each website you submit, including websites where no public email was found. Duplicate websites are merged before searching, so the same website is never searched or returned twice.

#### How do I know if a website has an email?

Look at the **Best email** column. If it is filled, that website has a public email. If it is empty, the **Status** tells you why: `not_found` means the website was searched and none was published; `skipped` means the entry is not a searchable website address; and `failed` means the website could not be reached this time and may work on a later run. None of these is a confirmed "no". To keep only the websites with an email, filter for **Best email is not empty**.

#### Does it check whether the email can receive messages?

No. The Actor reports emails that are publicly published on a website. It does not test whether an inbox accepts messages.

#### Does it guess addresses like info@?

No. It only returns emails that are actually published on the website. When none is found, it says so honestly.

#### Why do some websites return no email?

Some websites do not publish an email, or hide it behind a contact form or sign-in. In those cases the result is `not_found`.

#### Can I enter a bare domain?

Yes. Both `example.com` and `https://example.com/contact` work.

### Responsible Use

Always follow applicable laws, website terms, and privacy rules. Public emails can still be personal data in many regions, and you are the data controller for how you use them — make sure you have a lawful basis and honor opt-out requests. The **All emails** list may include personal addresses, so keep only what you need. Review results before outreach and make sure your use is compliant.

The Actor reads only publicly available website pages and honors sites' automated-access signals — when a website indicates it does not allow automated access, the result is reported as `failed` or `skipped` and no attempt is made to bypass it.

### Related

More Apify tools from FuturizeRush: https://apify.com/futurizerush?fpr=rush

### Keywords

Email Finder, Website Email Finder, Find Email by Domain, Domain Email Lookup, Email Extractor, Email Scraper, Contact Finder, Lead Generation, Sales Prospecting, CRM Enrichment, Outreach Research, Apify Actor, Claude Code, OpenClaw, Gemini, Antigravity, Codex, ChatGPT

# Actor input Schema

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

Add up to 100 websites or domains — for example apify.com or https://apify.com/contact. Paste a whole column from your spreadsheet; each line becomes one website. Duplicate websites are merged automatically. For larger lists, split them into separate runs. The Actor finds the best public email for each website.

## Actor input object example

```json
{
  "domains": [
    "https://apify.com/contact",
    "python.org",
    "https://www.mozilla.org/en-US/contact/"
  ]
}
```

# Actor output Schema

## `emails` (type: `string`):

One row per website with its best public email and where it was found.

## `runSummary` (type: `string`):

Run-level totals: websites searched, emails found, not found, skipped, failed, and duplicates merged.

# 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": [
        "https://apify.com/contact",
        "python.org",
        "https://www.mozilla.org/en-US/contact/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurizerush/website-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "https://apify.com/contact",
        "python.org",
        "https://www.mozilla.org/en-US/contact/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("futurizerush/website-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 '{
  "domains": [
    "https://apify.com/contact",
    "python.org",
    "https://www.mozilla.org/en-US/contact/"
  ]
}' |
apify call futurizerush/website-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=futurizerush/website-email-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Email Finder",
        "description": "Find a website's email by domain. Returns only real published emails, never guessed — one clean email per website, ready for outreach and lead generation. (Beta)",
        "version": "0.0",
        "x-build-id": "CfHic5577c5jSJOol"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futurizerush~website-email-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futurizerush-website-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/futurizerush~website-email-finder/runs": {
            "post": {
                "operationId": "runs-sync-futurizerush-website-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/futurizerush~website-email-finder/run-sync": {
            "post": {
                "operationId": "run-sync-futurizerush-website-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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "🌐 Websites or domains",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add up to 100 websites or domains — for example apify.com or https://apify.com/contact. Paste a whole column from your spreadsheet; each line becomes one website. Duplicate websites are merged automatically. For larger lists, split them into separate runs. The Actor finds the best public email for each website.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
