# Website Email & Contact Scraper: Phones, Socials, Forms (`tablewise/website-email-contact-scraper`) Actor

Extract emails, phone numbers, social media links, contact pages and contact forms from any list of company websites or domains, or from a Google Maps dataset. One row per website, no duplicates, the page each email came from. Pay only for websites with contacts.

- **URL**: https://apify.com/tablewise/website-email-contact-scraper.md
- **Developed by:** [table wise](https://apify.com/tablewise) (community)
- **Categories:** Lead generation, Social media
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 website with contacts

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

### What is Website Email & Contact Scraper?

Website Email & Contact Scraper reads a list of company websites and returns,
for each one, the emails, phone numbers, social media links, contact page and
contact form that the company publishes on its own site. In our test with
500 real business websites it found an email or a phone number on
79 % of them (91 % of the ones that were online), in
under 11 minutes, for USD 0.008 per website with contacts.

Give it URLs or bare domains (`acme.com`), or point it at the dataset of
another Actor, such as a Google Maps scraper, and it adds the contacts of
every website in that list. One row per website, everything merged and
without duplicates, with the page where each email was found. No login,
no API key; export as JSON, CSV or Excel, or read it through the API.

### What you can do with it

- **Enrich a list of leads:** take the `website` column of a Google Maps,
  directory or CRM export and get the emails and phones behind each site.
- **Find the right inbox:** generic addresses (`info@`, `sales@`) come
  apart from named ones (`jane.doe@`), with the page they came from.
- **Reach companies through their own channels:** contact page, contact
  form, LinkedIn, Facebook, Instagram, X, YouTube, TikTok and more, in
  separate columns.
- **Clean a domain list:** dead domains, parked sites and websites that
  block visitors come back with a status, at no cost.

### Use cases

Ready-to-run examples, with the input already filled in:

- [Extract emails and phone numbers from a list of websites](https://apify.com/tablewise/website-email-contact-scraper/examples/extract-emails-and-phones-from-websites):
  emails and phone numbers from three websites (a hotel group, a museum and a software company).
- [Find company social media profiles from their websites](https://apify.com/tablewise/website-email-contact-scraper/examples/company-social-profiles-from-websites):
  LinkedIn, Facebook, Instagram, X, YouTube and TikTok links from the websites of Hootsuite, Mailchimp and Buffer.

### Example output

Two real rows from our test run (shortened: `email_details` and
`phone_details` list every email and phone, the social columns are all
present).

```json
[
  {
    "input": "https://www.memmohotels.com/",
    "domain": "memmohotels.com",
    "url": "https://www.memmohotels.com/",
    "status": "ok",
    "status_message": null,
    "emails": ["hotel@memmohotels.com", "alfama@memmohotels.com", "baleeira@memmohotels.com", "preal@memmohotels.com"],
    "phones": ["+351282624212", "+351212425880", "+351210495660", "+351219016800"],
    "contact_page_url": "https://www.memmohotels.com/contact-us",
    "contact_form_url": "https://www.memmohotels.com/contact-us",
    "company_name": "Memmo Group Portal",
    "company_address": "Sítio da Baleeira, 1100-348, Sagres, Algarve, Portugal",
    "cloudflare_emails": 0,
    "email_details": [
      {
        "email": "hotel@memmohotels.com",
        "type": "generic",
        "domain_match": true,
        "found_on": ["https://www.memmohotels.com/", "https://www.memmohotels.com/contact-us"]
      }
    ],
    "phone_details": [
      {"phone": "+351282624212", "raw": "+(351)282624212", "found_on": ["https://www.memmohotels.com/"]}
    ],
    "pages_crawled": ["https://www.memmohotels.com/", "https://www.memmohotels.com/contact-us",
                      "https://www.memmohotels.com/about-memmo", "https://www.memmohotels.com/hotel-gdpr.html"],
    "scraped_at": "2026-11-16T01:17:33Z"
  },
  {
    "input": "https://www.tate.org.uk/",
    "domain": "tate.org.uk",
    "status": "ok",
    "emails": ["hello@tate.org.uk", "liverpool.press@tate.org.uk", "visiting.liverpool@tate.org.uk", "pressoffice@tate.org.uk"],
    "phones": ["+442078878888"],
    "facebook": ["https://www.facebook.com/tategallery"],
    "instagram": ["https://www.instagram.com/tate"],
    "youtube": ["https://www.youtube.com/user/tate"],
    "tiktok": ["https://www.tiktok.com/@tate"],
    "contact_page_url": "https://www.tate.org.uk/about-us/contact-us",
    "contact_form_url": null
  }
]
```

| Field | What it is |
| --- | --- |
| `input` | The website exactly as you entered it |
| `domain` | Registered domain of the website, without `www.` |
| `url` | Home page after redirects |
| `status` | `ok` when at least one email or phone was found; otherwise why not (table below) |
| `status_message` | Details of the status, in plain English |
| `emails` | Emails published on the website, the site's own domain first |
| `phones` | Phone numbers in international E.164 format (`+351282624212`) |
| `linkedin`, `facebook`, `instagram`, `twitter`, `youtube`, `tiktok`, `pinterest`, `telegram`, `whatsapp`, `discord`, `threads` | Links to the company's profiles on each network, as published on the website |
| `contact_page_url` | The website's contact page, if it has one |
| `contact_form_url` | A page with a contact form (a form with a message box) |
| `company_name`, `company_address` | From the website's structured data (JSON-LD), when it has it |
| `cloudflare_emails` | How many of the emails were hidden by Cloudflare email protection and decoded |
| `email_details` | Each email with its type (`generic`, `personal` or `other`), whether it is on the site's own domain, the pages it was found on and, with the mail server check, `has_mx_record` |
| `phone_details` | Each phone in E.164, as written on the page, and the pages it was found on |
| `pages_crawled` | Pages that were read |
| `scraped_at` | When the website was read (UTC) |

Every website you enter gives exactly one row. Only `ok` rows are charged:

| `status` | What it means | Charged? |
| --- | --- | --- |
| `ok` | At least one email or phone number found | Yes |
| `no_contacts` | The website was read but shows no email or phone (social links and contact page still come back) | No |
| `not_found` | The domain does not exist or the page is gone (404) | No |
| `blocked` | The website refused our requests, also through the proxy | No |
| `error` | The website did not answer, timed out or returned a server error | No |
| `unsupported_site` | A social network or big platform (Facebook, Instagram, Google Maps, Booking...), not a company website | No |
| `invalid_input` | Not a URL or a domain | No |
| `robots_disallowed` | Only with **Respect robots.txt** on: the site's robots.txt disallows it | No |

### What it costs

| Event | Price |
| --- | --- |
| Actor start | USD 0.0005 per run |
| Website with contacts | USD 0.008 per website with at least one email or phone |

**Example:** 1,000 websites where 790 have contacts = 0.0005 +
790 × 0.008 = USD 6.32. You pay per website, not per page
or per email: a website with 12 emails costs the same USD 0.008 as one with
a single phone number. Websites without contacts, dead, blocked or invalid
cost nothing. Use **Max websites** to cap the spend.

#### How many websites can I get with the free plan?

Apify's free plan includes USD 5 of credit every month. Used only for this
Actor, that is about 620 websites with contacts: for example, one run of
800 websites where 620 have contacts = 0.0005 + 620 × 0.008 = USD 4.96.

### How to use it

1. Paste your websites into **Websites**, one per line: full URLs
   (`https://www.acme.com/contact`) or bare domains (`acme.com`).
   Or, in **Websites from a dataset**, put the dataset of another Actor (for example a
   Google Maps scraper) and in **Website field in that dataset** the column with the
   website (`website` by default).
2. Optional: **Max pages per website** (5 by default), **Max emails per
   website**, **Default country for phone numbers** (for numbers written
   without a country code), **Check the email domain's mail server (MX)**
   (adds `has_mx_record` to each email).
3. Click **Start** and download the results as JSON, CSV or Excel.

#### Input

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `websites` | array | — | URLs or domains, one per line |
| `datasetId` | string | — | Read the websites from this dataset |
| `datasetField` | string | `website` | Column of that dataset with the website |
| `maxPagesPerSite` | integer | 5 | Pages read per website (1–20): home page first, then contact, legal notice, about, team, privacy and locations |
| `maxEmailsPerSite` | integer | 0 (no limit) | Keep at most this many emails per website |
| `defaultCountry` | string | — | Two-letter country code for local phone numbers when the website does not tell (a `.pt` domain is read as Portugal anyway) |
| `checkMailServer` | boolean | `false` | Looks up the MX record of each email domain (does not contact the mail server) |
| `maxWebsites` | integer | 1000 | Stops after this many websites |
| `delayBetweenRequests` | integer | 1 | Seconds between two requests to the same website |
| `respectRobotsTxt` | boolean | `false` | Skip pages that the website's robots.txt disallows |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Proxy used only for websites that block direct requests |

### Speed and reliability

Each website is read with a single connection and a pause between pages, so
no website gets more than one request at a time; 15 websites are read in
parallel. In our test on Apify, 500 real business websites (hotels,
restaurants, dentists, lawyers and shops from more than 15 countries) took 11
minutes (632 seconds): 395 `ok`, 38 `no_contacts`, 27 `blocked`,
36 `error` and 4 other statuses. Of the websites that were
online, 82 % had an email and 80 % a phone
number. An aborted and resumed run continues where it stopped, without
duplicate rows or double charges.

Websites that block the IP addresses of Apify's servers are read again
through the proxy: in our tests, 8 to 11 of the 35 websites that blocked
us could then be read.

**Compared with the most used contact scraper on the Store**, on the same 25
websites (16 November 2026, 5 pages per website): emails on 18 websites
against 16, phone numbers on 20 against 9 (counting its "certain" phones).

### Limits and known issues

- **Only what the website publishes.** It does not guess emails
  (`firstname@...`), does not verify them by connecting to the mail server
  and does not use third-party lead databases.
- **Websites built entirely with JavaScript** show little to a reader that
  does not run a browser: about 3 % of the websites in our test. They
  usually come back as `no_contacts`.
- **Some websites block automated visitors** even through the proxy
  (5 % in our test). They come back as `blocked`, free.
- Emails and phones of other organizations that a website publishes (a
  taxi company, a bus station) can appear. Emails of another domain found
  only on legal pages (the web agency, the hosting company) are left out,
  and so are lists of three or more addresses of another organization.
- Social networks are not crawled: the profile links come from the
  website itself.
- `robots.txt` is not applied unless you turn on **Respect robots.txt**.

### FAQ

#### Do I need an account or an API key?

No. It reads the same public pages that any visitor sees, without logging
in anywhere.

#### Can I use it with Google Maps results?

Yes. Run a Google Maps scraper first, then put its dataset ID in **Websites
from a dataset** and `website` (or the name of its website column) in
**Website field in that dataset**. Places without a website are skipped, repeated websites are read
once.

#### Why are some emails decoded from Cloudflare?

Many websites behind Cloudflare hide their emails from simple scrapers and
show them to visitors with a small script. This Actor decodes them the same
way the visitor's browser does. In our 500-website test, 33 websites hid emails this
way, and for 29 of them those were the only emails. `cloudflare_emails` tells you how many came
from there.

#### Is it legal to scrape contact details from websites?

This Actor reads public pages, without logging in. The results can include
personal data, such as an employee's email published on the company's
website. You are responsible for using it lawfully: in the EU and UK the
GDPR applies (you need a legal basis and must inform the people you
contact), and email marketing has its own rules (CAN-SPAM in the US, PECR in
the UK). If you are not sure, ask a lawyer.

#### Can I run it from the API or from Python?

Yes: with the Apify API or the official Apify clients for Python and
JavaScript. This call runs the Actor and returns the rows when it finishes
(it waits up to 5 minutes; for longer runs, start the run and read its
dataset when it ends):

```bash
curl -X POST "https://api.apify.com/v2/acts/tablewise~website-email-contact-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"websites": ["https://www.memmohotels.com/", "tate.org.uk"]}'
```

#### Can I schedule it or send the results to other tools?

Yes. You can run it on a schedule, export each run as JSON, CSV or Excel, get
a webhook when it finishes, and connect it to Make, Zapier, n8n, Google
Sheets, HubSpot and other tools through Apify integrations.

#### Can AI agents use it?

Yes. AI agents can find and run it through Apify's MCP server
(`https://mcp.apify.com`). Every output field has a description, so an agent
knows what each value means.

### Support

Found a problem? Open an issue on the Actor's **Issues** tab with the run ID
and we'll look into it.

### More Actors from the same developer

- [LinkedIn Company Scraper](https://apify.com/tablewise/linkedin-company-scraper): size, industry, employees, website and offices of any LinkedIn company page.
- [Semrush Domain Metrics Scraper](https://apify.com/tablewise/semrush-domain-metrics-scraper): Authority Score, backlinks, referring domains and traffic for any list of domains.
- [LinkedIn Jobs Scraper](https://apify.com/tablewise/linkedin-jobs-scraper): LinkedIn job postings with full description, salary, seniority and applicants, without login.
- [Company Jobs Scraper: Workday, Greenhouse, Lever & Ashby](https://apify.com/tablewise/workday-greenhouse-lever-jobs-scraper): every open job from company careers sites on those four platforms.
- [Google Trends Scraper](https://apify.com/tablewise/google-trends-scraper): interest over time, interest by region and related queries for any keyword.
- [YouTube Transcript & Subtitles Scraper](https://apify.com/tablewise/youtube-transcript-scraper): the transcript of any YouTube video, Short or channel as text or SRT, with the video details.
- [Google Hotels Scraper](https://apify.com/tablewise/google-hotels-scraper): hotel prices for your dates, ratings and prices by booking site.
- [AliExpress Search Scraper](https://apify.com/tablewise/aliexpress-search-scraper): prices, discounts, ratings and units sold from any AliExpress search.
- [Amazon Best Sellers Scraper](https://apify.com/tablewise/amazon-bestsellers-scraper): the top 100 of any Amazon.com Best Sellers or Hot New Releases list.
- [Amazon Product Details Scraper](https://apify.com/tablewise/amazon-product-details-scraper): price, Best Sellers Rank, specs and images for any list of ASINs.
- [Tennis Results & Odds Scraper](https://apify.com/tablewise/tennis-results-scraper): ATP, WTA, Challenger and ITF results and fixtures with set scores and betting odds.

# Actor input Schema

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

Company websites to scan, as full URLs (https://www.example.com) or bare domains (example.com). You get one row per website. Duplicates are removed. Social network pages (Facebook, Instagram, LinkedIn...) are not crawled.

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

Read the websites from another Actor's dataset, for example the output of a Google Maps scraper. Pick the dataset, or paste its ID, and set the field name below. Used together with the Websites list.

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

Name of the field that holds the website in each dataset row. Google Maps scrapers use 'website'. Use a dot for nested fields, like 'contact.website'.

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

How many pages to read per website, starting with the home page. The scraper picks the pages that usually have contacts first: contact, imprint/legal notice, about, team, privacy and location pages.

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

Keep at most this many emails per website (emails on the website's own domain and generic ones like info@ come first). 0 keeps all of them.

## `defaultCountry` (type: `string`):

Two-letter country code (US, GB, ES, BR...) for phone numbers written without the international prefix. Used only when the website itself gives no clue: its country domain (.co.uk, .es), its address or its language come first.

## `checkMailServer` (type: `boolean`):

Adds has_mx_record to each email: whether its domain has mail server (MX) records. It does not contact the mail server or send anything.

## `maxWebsites` (type: `integer`):

Maximum number of websites to process in this run. Use it to cap what you spend. You only pay for websites where at least one email or phone number is found.

## `delayBetweenRequests` (type: `integer`):

Pause between two requests to the same website. Several websites are scanned at once, each with a single connection. A website's robots.txt Crawl-delay is respected (up to 10 seconds).

## `respectRobotsTxt` (type: `boolean`):

If enabled, pages that a site's robots.txt disallows are skipped and the site gets the status robots_disallowed (its Crawl-delay is applied too). Off by default: only a few pages per site are read, one at a time, with a pause between requests.

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

Websites are read directly first. Only the ones that block direct requests are retried through this proxy (Apify datacenter proxy by default). In our tests, 8 to 11 of 35 websites that blocked direct requests could be read through the datacenter proxy. Turn it off to never use a proxy.

## Actor input object example

```json
{
  "websites": [
    "https://apify.com/",
    "https://www.tate.org.uk/",
    "https://www.memmohotels.com/"
  ],
  "datasetField": "website",
  "maxPagesPerSite": 5,
  "maxEmailsPerSite": 0,
  "checkMailServer": false,
  "maxWebsites": 1000,
  "delayBetweenRequests": 1,
  "respectRobotsTxt": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per website: emails, phone numbers, social links, contact page and company details, with a status for websites where 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 = {
    "websites": [
        "https://apify.com/",
        "https://www.tate.org.uk/",
        "https://www.memmohotels.com/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tablewise/website-email-contact-scraper").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": [
        "https://apify.com/",
        "https://www.tate.org.uk/",
        "https://www.memmohotels.com/",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("tablewise/website-email-contact-scraper").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 '{
  "websites": [
    "https://apify.com/",
    "https://www.tate.org.uk/",
    "https://www.memmohotels.com/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call tablewise/website-email-contact-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tablewise/website-email-contact-scraper"
        }
    }
}
```

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/e98S6gFodRMbDxVoH/builds/ebkVH7Xjn71W5YhCD/openapi.json
