# Bulk Contact & Email Scraper — Emails, Phones & Socials (`jimmywhyte/website-contact-finder`) Actor

Bulk email & contact scraper: feed a list of websites — a few or thousands from a spreadsheet, CRM, or API — and get every email, phone, and social profile from their homepage and contact pages. Each email is typed (sales, support, personal) and tagged with its source page. For lead generation.

- **URL**: https://apify.com/jimmywhyte/website-contact-finder.md
- **Developed by:** [Jim Whyte](https://apify.com/jimmywhyte) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Bulk Contact & Email Scraper — Emails, Phones & Socials from a List of Websites

Turn a **whole list of company websites** into a contact list in one run. Feed it a handful of
domains or thousands, and it returns every **email address**, **phone number**, and
**social profile** it can find across each site's homepage and its contact / about / team pages.

**Built for bulk lead generation.** You already have a list of company websites — from a
spreadsheet, a CRM export, a Google Maps scrape, a directory, or a conference attendee list —
and this fills in how to actually reach them, at scale.

#### Feed it your whole database of sites
- Paste a list, or upload one, right in the input form.
- Pipe thousands in via the **API** straight from your CRM, database, or app.
- **Chain it** after another Apify actor (e.g. a Google Maps or directory scraper that outputs
  company websites) so the whole pipeline runs hands-off.
- Pull the input list from **Google Sheets** using Apify's built-in integrations.

It processes many sites **concurrently**, so a large list finishes fast.

### What it does

For each website you provide, it:

1. Fetches the homepage.
2. Finds the most contact-relevant internal pages (contact, about, team, imprint…) and fetches those too.
3. Extracts and de-duplicates:
   - **Emails** — from `mailto:` links and page text, junk filtered, each **typed**
     (sales, support, info, careers, billing, press, legal, personal…) and tagged with the page it came from.
   - **Phones** — from `tel:` links and text, validated, each with a **label** (the department or
     nearby text, e.g. "Sales" — `null` when the site gives no context) and the page it came from.
   - **Socials** — LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok (company profiles, not share links).

### Input

| Field | Description |
|---|---|
| `websites` | List of domains or URLs (`stripe.com`, `https://example.com`) |
| `websitesText` | Or paste them separated by newlines/commas/spaces |
| `maxPagesPerSite` | Homepage + N best contact pages (default 3) |
| `includePhones` | Extract phone numbers (default on) |
| `includeSocials` | Extract social profiles (default on) |
| `maxConcurrency` | Sites processed in parallel (default 10) |
| `proxyConfiguration` | Route through Apify Proxy (recommended for large runs) |

### Output

One record per website:

```json
{
  "input": "acme.com",
  "url": "https://acme.com",
  "status": "ok",
  "emails": [
    { "email": "sales@acme.com", "type": "sales", "source": "https://acme.com/contact" },
    { "email": "jane.doe@acme.com", "type": "personal", "source": "https://acme.com/team" }
  ],
  "phones": [
    { "phone": "+44 20 3695 7895", "label": "Sales", "source": "https://acme.com/contact" }
  ],
  "socials": {
    "linkedin": "https://www.linkedin.com/company/acme",
    "instagram": "https://www.instagram.com/acme"
  },
  "pages_crawled": 3
}
````

Each email carries a **type** so you know whether it's a department or a person, and each contact
carries the **source** page it was found on — so you're never left guessing what a number is for.

`status` is one of `ok`, `no_contacts_found`, `unreachable`, `invalid_input`, or `error` — so you
always know whether a blank row means "no contacts", "couldn't reach the site", or "bad input".

Export to CSV, JSON, or Excel, or pull via the API.

### Pairs with: Company Data Enrichment

Got the contacts? Now find out **who the company is.** Feed the same list of domains to
[**Company Data Enrichment**](https://apify.com/jimmywhyte/company-enrichment) and get each
company's name, description, industry, HQ location, founding date, tech stack, and logo —
no LinkedIn. Two steps, one lead-gen pipeline.

### Pricing

Pay per website processed — no subscription, no minimum. You only pay for the sites you run.
If you set a **maximum charge** on a run, the actor stops cleanly once that budget is reached
and reports how many sites it processed — it never runs up costs beyond your cap.

### Notes

- Respectful crawling: identifies itself, follows redirects, only fetches HTML pages.
- Some companies deliberately publish no email (common for banks/fintech); you'll still get
  their phone and socials where available.

# Actor input Schema

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

Domains or URLs to scan, e.g. 'stripe.com' or 'https://example.com'.

## `websitesText` (type: `string`):

Alternative input: paste domains/URLs separated by newlines, commas, or spaces. Merged with the list above and de-duplicated.

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

How many pages to fetch per site: the homepage plus the highest-priority contact/about/team pages found on it.

## `includePhones` (type: `boolean`):

Pull phone numbers from tel: links and page text.

## `includeSocials` (type: `boolean`):

LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok profile links.

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

How many sites to process in parallel.

## `requestTimeoutSecs` (type: `integer`):

Per-page fetch timeout before giving up on that page.

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

Proxy to route requests through. Recommended for larger runs to avoid rate-limiting.

## Actor input object example

```json
{
  "websites": [
    "apify.com",
    "stripe.com"
  ],
  "maxPagesPerSite": 3,
  "includePhones": true,
  "includeSocials": true,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `contacts` (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 = {
    "websites": [
        "apify.com",
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jimmywhyte/website-contact-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 = { "websites": [
        "apify.com",
        "stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jimmywhyte/website-contact-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 '{
  "websites": [
    "apify.com",
    "stripe.com"
  ]
}' |
apify call jimmywhyte/website-contact-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Contact & Email Scraper — Emails, Phones & Socials",
        "description": "Bulk email & contact scraper: feed a list of websites — a few or thousands from a spreadsheet, CRM, or API — and get every email, phone, and social profile from their homepage and contact pages. Each email is typed (sales, support, personal) and tagged with its source page. For lead generation.",
        "version": "0.1",
        "x-build-id": "RjPFU7hh27WoVgIyW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jimmywhyte~website-contact-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jimmywhyte-website-contact-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/jimmywhyte~website-contact-finder/runs": {
            "post": {
                "operationId": "runs-sync-jimmywhyte-website-contact-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/jimmywhyte~website-contact-finder/run-sync": {
            "post": {
                "operationId": "run-sync-jimmywhyte-website-contact-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": {
                    "websites": {
                        "title": "Websites or domains",
                        "type": "array",
                        "description": "Domains or URLs to scan, e.g. 'stripe.com' or 'https://example.com'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "websitesText": {
                        "title": "Or paste websites as text",
                        "type": "string",
                        "description": "Alternative input: paste domains/URLs separated by newlines, commas, or spaces. Merged with the list above and de-duplicated."
                    },
                    "maxPagesPerSite": {
                        "title": "Max pages per site",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages to fetch per site: the homepage plus the highest-priority contact/about/team pages found on it.",
                        "default": 3
                    },
                    "includePhones": {
                        "title": "Extract phone numbers",
                        "type": "boolean",
                        "description": "Pull phone numbers from tel: links and page text.",
                        "default": true
                    },
                    "includeSocials": {
                        "title": "Extract social profiles",
                        "type": "boolean",
                        "description": "LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok profile links.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many sites to process in parallel.",
                        "default": 10
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 3,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Per-page fetch timeout before giving up on that page.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy to route requests through. Recommended for larger runs to avoid rate-limiting.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
