# Website Contact Scraper: Emails, Phones & Social Links (`magnova/website-contact-info-scraper`) Actor

One row per company website: emails (role or person, MX-checked), validated phones (E.164), LinkedIn/Facebook/Instagram/X/YouTube links, address, contact-form URL, company name. Plain HTTP, robots.txt respected. $3 per 1,000 websites, charged only when contacts are found.

- **URL**: https://apify.com/magnova/website-contact-info-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 scraped websites

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Website Contact Scraper: emails, phone numbers and social links from company websites

**Give this Actor a list of company websites and it returns one clean row per site: the best contact email, validated phone numbers in international format, LinkedIn, Facebook, Instagram, X and YouTube links, the postal address, a contact-form URL and the company name.** It reads only the public, server-rendered pages that any visitor can open (home, contact, about, team, support and legal-notice pages), needs no login and no API key, and costs **$3 per 1,000 websites**, charged only for sites where a contact was actually found.

Typical uses: B2B lead lists from a spreadsheet of domains, enriching a CRM with phone numbers and social profiles, finding the right inbox for a PR or partnership pitch, compiling supplier or agency directories, and giving an AI agent a one-call "how do I contact this company?" tool.

### Website Contact Scraper API: what you get per website

| Field | What it holds |
|---|---|
| `primaryEmail` | The best address to write to: a company-domain role mailbox such as contact@, info@, sales@ or hello@, on a domain that accepts mail |
| `emails[]` | Every email found with `type` (role, person or other), `onSiteDomain`, `domainAcceptsMail` (MX check) and the page it was found on |
| `primaryPhone`, `phones[]` | Phone numbers validated with Google's libphonenumber: E.164 (`+18889262289`), international format, country, where found |
| `linkedin`, `facebook`, `instagram`, `twitter`, `youtube`, `tiktok` | The profile URLs the company links to from its own site |
| `socialLinks` | Everything found, including GitHub, Pinterest, WhatsApp, Telegram, Threads, Discord, Bluesky, Mastodon, Medium, Snapchat and Vimeo |
| `address` | Street, city, region, postal code and country from schema.org data or an `<address>` block |
| `companyName`, `legalName`, `vatId`, `description`, `language` | Company details from structured data and meta tags |
| `contactFormUrl`, `contactPageUrl` | Where the site's contact form and contact or imprint page live |
| `status`, `pagesCrawled`, `pagesCrawledUrls`, `note`, `error` | Why a site returned nothing, and which pages were read |

### Use it as an API (Server Actor)

This actor also runs as a **server**: send one HTTP request and get the contact records back in the response — no run to start, no dataset to poll.

```
POST https://magnova--website-contact-info-scraper.apify.actor
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"websites": ["stripe.com", "apify.com"]}
```

The body takes the same fields as the normal input. The response is `{"records": [...], "summary": {...}}` — one record per website, exactly the rows a normal run writes to the dataset. Server mode is a snapshot lookup and one request covers at most 10 websites. You are charged the same $0.003 per delivered site with contacts as a normal run (tiered by your Apify plan), billed to your own Apify account; sites without contact info are never charged.

### Use with AI agents / MCP

The Actor has one required input (`websites`), a working prefill and a flat result, so an agent can call it with no setup through the Apify MCP server or the API.

```json
{ "websites": ["stripe.com", "https://www.python.org"], "onlyRoleBasedEmails": true }
```

Sample output (shortened):

```json
{
  "domain": "stripe.com",
  "status": "ok",
  "companyName": "Stripe",
  "primaryEmail": "sales@stripe.com",
  "emails": [{ "email": "sales@stripe.com", "type": "role", "onSiteDomain": true, "domainAcceptsMail": true, "foundOn": "https://stripe.com/support-plans" }],
  "primaryPhone": "+18889262289",
  "linkedin": "https://www.linkedin.com/company/stripe",
  "facebook": "https://www.facebook.com/StripeHQ",
  "instagram": "https://www.instagram.com/stripehq",
  "twitter": "https://twitter.com/stripe",
  "pagesCrawled": 6
}
```

### How do I extract emails and phone numbers from a website?

1. Paste domains or URLs into **Websites**, one per line (up to 20,000 per run).
2. Leave the defaults on, or set **Max pages per website**, **Only role-based emails** or a **Default phone country**.
3. Run it, then download the table as JSON, CSV or Excel, or read it from the API.

For every site the Actor loads the home page, picks the links that look like contact, about, team, support, imprint, location or press pages (in English, German, French, Spanish, Italian and Portuguese), and reads up to the page limit you set. If a site hides its contact page behind an unusual URL, it also tries `/contact`, `/contact-us`, `/about` and `/impressum`.

What it understands: `mailto:` links, plain text addresses, simple obfuscation such as `name [at] company [dot] com`, Cloudflare "email protection" addresses, schema.org JSON-LD organization data, `tel:` links, and phone numbers written in running text (kept only when libphonenumber validates them for the right country).

### How much does it cost to scrape website contacts?

**$0.003 per website with contacts found** (about $3 per 1,000), with no start fee and no per-page charges. Silver, Gold and higher Apify plans get automatic discounts, down to $0.0015. Websites that are blocked, unreachable, disallowed by robots.txt, invalid, or that simply have no contact data cost nothing. Tools that bill per page typically charge about $0.002 for each of the 5 to 10 pages they read, which is $0.01 to $0.02 for the same site. The platform cost of a run is tiny: scanning 93 mixed company sites took 97 seconds on 256 MB.

### Options that matter

- **Respect robots.txt** (on by default): pages a site disallows for bots are skipped and reported as `robots_disallowed`.
- **Only role-based emails**: keep company inboxes (info@, sales@, press@) and drop named-person addresses.
- **Only emails on the website's own domain**: drop third-party addresses from footers and widgets.
- **Check that email domains accept mail**: a DNS MX lookup; nothing is ever sent to any mailbox.
- **Default phone country**: reads local numbers written without a prefix.
- **Proxy**: optional. Helps with sites that rate-limit one IP; it does not defeat advanced bot protection.

### What this Actor does not do

- It does not run JavaScript. Sites that render everything in the browser return `no_contact_found` with a note.
- It does not log in, solve CAPTCHAs or scrape social networks; social links are only the ones printed on the company's own site.
- It does not guess or verify individual mailboxes, so it cannot tell if `anna@company.com` exists.
- Large brands behind strict bot protection (some news and retail sites) answer 403 and come back as `blocked`, free of charge.

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

The Actor collects only information that companies publish on public pages for anyone to read, identifies itself honestly with a bot user agent, honours robots.txt by default and never bypasses a login or access control. Business contact data is widely used for B2B outreach, but you are responsible for how you use it: in the EU and UK, rules such as GDPR and PECR apply to emails that identify a person, so prefer role-based inboxes (the `type` field and the role-only switch exist for this), follow anti-spam laws such as CAN-SPAM and CASL, and honour opt-outs. This is not legal advice.

### Website Contact Scraper alternatives

Apify's own Contact Details Scraper is a general crawler that bills per page and offers browser and residential add-ons. Lead databases return people from a private index instead of reading the company's site. This Actor is the lightweight middle: one flat price per website, structured output ready for a CRM, validated phones, MX-checked emails and a clear status for every input.

### FAQ

**Why did a website return no emails?** Many companies publish only a contact form or load their details with JavaScript. Check `contactFormUrl`, `phones` and the `note` field.

**Can I scan thousands of sites?** Yes. Up to 20,000 websites per run, 10 in parallel by default (raise it to 30).

**Can I schedule it?** Yes, use Apify Schedules or the API, and connect the dataset to Google Sheets, Make, Zapier or n8n.

**What do the statuses mean?** `ok` (charged), `no_contact_found`, `blocked`, `robots_disallowed`, `not_found`, `unreachable`, `invalid_input` (all free).

# Actor input Schema

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

Company websites to scan, one per line: a domain (stripe.com) or a full URL (https://www.stripe.com/contact). Each site is checked on its home page plus the contact, about, team, support and legal-notice pages it links to.

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

Home page plus up to N-1 pages that look like contact, about, team, support, imprint or location pages. 6 is enough for most sites. Example: 3.

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

Skip pages that the site's robots.txt disallows for bots. Leave on unless you have the site owner's permission.

## `verifyEmailDomains` (type: `boolean`):

Looks up the MX record of each email's domain (a DNS query, nothing is sent to the mailbox) and returns domainAcceptsMail true/false. Addresses on dead domains are never chosen as primaryEmail.

## `onlyRoleBasedEmails` (type: `boolean`):

Keep only company mailboxes such as info@, sales@, support@, hello@, press@ and drop addresses that look like a named person (anna.meyer@) or are unclear. Use it for company-level outreach and to avoid personal data.

## `onlyEmailsOnSiteDomain` (type: `boolean`):

Drop addresses that belong to other domains, such as a privacy vendor or an agency listed in the footer.

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

Two-letter country code used to read phone numbers written without a country prefix, e.g. GB, DE, US. Leave empty to guess it from the site's domain ending (.de, .co.uk, ...).

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

Cap on emails returned for each website (best ones first: company-domain role mailboxes).

## `maxPhonesPerSite` (type: `integer`):

Cap on validated phone numbers returned for each website.

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

How many websites are scanned at the same time. Higher is faster; each website is still fetched politely, one batch of pages at once.

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

Only needed for sites that answer 403/429 to the plain request (status 'blocked'). Apify proxy usage is billed by Apify to your account. Leave empty for normal sites.

## Actor input object example

```json
{
  "websites": [
    "stripe.com",
    "apify.com",
    "https://www.python.org"
  ],
  "maxPagesPerSite": 6,
  "respectRobotsTxt": true,
  "verifyEmailDomains": true,
  "onlyRoleBasedEmails": false,
  "onlyEmailsOnSiteDomain": false,
  "maxEmailsPerSite": 15,
  "maxPhonesPerSite": 8,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `contacts` (type: `string`):

No description

## `summary` (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": [
        "stripe.com",
        "apify.com",
        "https://www.python.org"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("magnova/website-contact-info-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": [
    "stripe.com",
    "apify.com",
    "https://www.python.org"
  ]
}' |
apify call magnova/website-contact-info-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/website-contact-info-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/vZaHH2RzoqaLH92zP/builds/1jgqrfTlu5XiDVmtj/openapi.json
