# Contact Details Scraper & Website Email Finder (`aurelmark/website-contact-finder`) Actor

Contact details scraper and website email finder: paste websites or domains, get one business email per site with the page that proves it, plus phone, contact page and social links. $2 per 1,000 websites with an email found; no email, no charge.

- **URL**: https://apify.com/aurelmark/website-contact-finder.md
- **Developed by:** [Aurelmark](https://apify.com/aurelmark) (community)
- **Categories:** Lead generation, Automation, Integrations
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 found business emails

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Contact Details Scraper & Website Email Finder

A contact details scraper and website email finder for lists of company websites, also an email extractor for website contacts. Paste the websites or domains; get back **one row per website with the one best business email**, the reason it was chosen and the page that proves it, plus phone, company name and social pages. **You pay only for websites where a business email is found: $0.002 each ($2 per 1,000), plus Apify's $0.00005 start fee per run. No email, no charge.**

- **One best email per website**, a role address such as info@ or sales@ by default, with its confidence and the page that shows it.
- **Phone, contact page, company name and social links** when the site publishes them; nothing is guessed.
- **Spreadsheet-ready:** open the **Spreadsheet** table and press Download -> CSV or Excel, use Google Sheets, or run it from n8n, Make or Zapier.

**Tested on 500 real company websites (13 Nov 2026):** a business email for 262 of 500 (52%), and for 245 of the 342 that show one on their site (72%). On a second list of 150 small local firms: 49 (33%). Details under "Measured on a sealed test list".

### A real sample

The first three rows are the prefilled websites, run on 10 Nov 2026. The last three are other real websites, run on 15 Nov 2026 (shopify.com has no published email, so that row is free):

| website | status | bestEmail | bestEmailConfidence | bestEmailReason | bestEmailSourceUrl |
|---|---|---|---|---|---|
| zalando.de | found | impressum@zalando.de | high | Role address on the site's own domain, found in the text of the legal notice; the domain accepts mail. | `https://www.zalando.de/zalando-impressum/` |
| innocentdrinks.co.uk | found | hello@innocentdrinks.co.uk | high | Role address on the site's own domain, published as a link on the contact page; the domain accepts mail. | `https://www.innocentdrinks.co.uk/get-in-touch` |
| kingarthurbaking.com | found | customercare@kingarthurbaking.com | high | Role address on the site's own domain, published as a link on the contact page; the domain accepts mail. | `https://www.kingarthurbaking.com/contact` |
| stripe.com | found | sales@stripe.com | high | Role address on the site's own domain, found in the page source of the contact page; the domain accepts mail. | `https://stripe.com/contact/sales` |
| gymshark.com | found | support@gymshark.com | high | Role address on the site's own domain, published as a link on the contact page; the domain accepts mail. | `https://support.gymshark.com/en/articles/11186132-contact-us` |
| shopify.com | no_email_found | | | No email address is published on the pages read (6 pages read). The site may use a contact form only. | |

Every row says why the address was chosen and where it is published, so you can open the page and check.

Try it free: Apify's free plan includes $5 of monthly credit.

**Who it is for:** sales and marketing teams, agencies and anyone with a list of company websites (from a CRM, a directory or a spreadsheet) who needs one checked business email per company, with proof, without paying for sites that have none.

### What it costs: three worked bills

**Price:** $2 per 1,000 websites where a business email is found ($0.002 each). You never pay more than $2 per 1,000 websites, however large a site is, and nothing for a site where no business email is found. In words: 100 websites with an email found cost 20 cents.

| Your list | What happens | You pay for results |
|---|---|---|
| 1 website | an email is found | 1 x $0.002 = $0.002 |
| 1 website | no email is found, or the site is blocked | $0.00 |
| 100 websites | an email is found on 70; 30 have none, are blocked or do not answer | 70 x $0.002 = $0.14 |
| 1,000 websites | an email is found on every one (the most it can cost) | $2.00 |

There is no charge per page, per request or per minute, and no charge for a website without an email, a blocked site, a skipped row or an input error. The only other charge is Apify's standard start fee of $0.00005 per run.

If you set a spending limit for a run, the tool checks it before every charge and stops cleanly when it is reached. The last message then says "Stopped at your spending limit after N results", and every website that was not read comes back as a free row with status `not_checked`, so you can see which rows to run again.

### First run in 60 seconds

1. Copy the column of websites from your sheet and paste it into **Websites**, one per line (`example.com` or `https://www.example.com`). Replace the three example sites, or they are read and billed too.
2. Press **Start**. The status line shows progress in plain words, for example "Checked 40 of 200 websites, 29 emails found".
3. Open the **Spreadsheet** table and press **Download -> CSV** or **Excel**. Every website you sent has exactly one row with a `status`.

**Three presets.** A sheet column: paste it as it is. An agency list (many small sites): keep the defaults, and set **Default country for phones** (`defaultCountry`) to your country. A monthly recheck of the same list: turn on `skipSeen` with `recheckAfterDays: 30` and schedule the run, so you pay only for new or changed websites:

```json
{ "websites": ["zalando.de", "hetzner.com"], "skipSeen": true, "recheckAfterDays": 30 }
```

### Input

| Name | Type | Default | Meaning |
|---|---|---|---|
| `websites` | list | required | Websites or bare domains. Through the API each item may also be a row: `{"website": "example.com", "id": "A-17", "country": "GB"}`. Your other columns come back unchanged under `input`. Up to 10,000 in one run. |
| `maxPagesPerSite` | number, 1 to 10 | 5 | The most pages read on one website. |
| `includeNamedPeople` | true or false | false | Also return addresses that belong to a named person, or that may be one person's mailbox. |
| `includePhones` | true or false | true | Return phone numbers. |
| `defaultCountry` | two-letter code | empty | Used to read phone numbers when a row gives no `country`. |
| `includeSocial` | true or false | true | Return the company's own social pages. |
| `legalNotice` | true or false | false | Also read the company's legal notice (Impressum): legal form, register court, register number, VAT ID. |
| `extraSources` | true or false | true | Only when the pages give no address on the site's own domain: also read its security.txt. Such an address is a security-report desk: ranked last, low confidence, `bestEmailSource` `security_txt`, counted apart in the summary and **not charged**. It does not count against `maxPagesPerSite`. |
| `skipSeen` | true or false | false | Do not read or charge a website that an earlier run with this option delivered. |
| `recheckAfterDays` | number | empty | With `skipSeen`: read a website again after this many days. |
| `resetSeen` | true or false | false | Forget the websites delivered so far. |
| `maxComputeUsd` | number | see Limits | The most compute, in US dollars, this run may use before it stops cleanly with the rows it has. |

**A mistyped input name stops the run at no cost.** An input name the tool does not know stops the run before any work: you get one row with status `input_error` that lists the accepted names, and nothing is charged. Nothing is silently ignored.

#### Examples

German companies (reads the Impressum): `{ "websites": ["zalando.de", "hetzner.com", "sipgate.de"], "defaultCountry": "DE" }`

Enrich a CRM export and keep your own columns:

```json
{ "websites": [{ "website": "apify.com", "crmId": "A-1001" }, { "website": "hetzner.com", "crmId": "A-1002" }] }
```

**Switching from another contact scraper.** The name `startUrls` is accepted for the list, with `{"url": "..."}` items or plain strings. Send `websites` or `startUrls`, not both:

```json
{ "startUrls": [{ "url": "https://apify.com" }, { "url": "https://www.hetzner.com" }] }
```

### Output: one row per website

| Field | Meaning |
|---|---|
| `website`, `domain` | The website as you gave it, and its domain. |
| `status`, `statusReason` | What happened, and one plain sentence that says why (see the table below). |
| `bestEmail` | The one address to use. |
| `bestEmailType` | `role` (info@, sales@), `named` (a person, or an address that may be one person's mailbox such as a role word beside a name, an address with a plus tag or a single word on no list such as smith@; only when you switch it on) or `unknown` (an address named after the company itself, such as acme@acme.com). |
| `bestEmailConfidence` | `high`, `medium` or `low` (see below). |
| `bestEmailReason` | One sentence: why this address. |
| `bestEmailSourceUrl` | The page where it is published. Open it to check. |
| `bestEmailSource` | `site_page`, or `security_txt` when the only address is the site's security-report desk (low confidence, counted apart in the summary, not charged). |
| `otherEmails` | Up to 10 other business addresses, each with its type, confidence and page. |
| `namedEmailsWithheld` | How many addresses of named people, or that may be one person's mailbox, were left out. |
| `phone`, `otherPhones`, `doubtfulPhones` | The best number in international format, the other valid numbers, and numbers that could not be confirmed (never chosen as best). |
| `contactPageUrl`, `legalPageUrl` | The contact page and the legal notice, when the home page links to them. |
| `companyName`, `address` | Only when the site states them in structured data or in its legal notice. |
| `legalNoticeUrl`, `legalForm`, `registerCourt`, `registerNumber`, `vatId` | Only with `legalNotice` on; see below. Empty when not found. |
| `social` | The company's own LinkedIn, Facebook, Instagram, X, YouTube and TikTok pages, as linked from its site. |
| `pagesChecked`, `checkedAt` | How many pages were read, and when. |
| `charged` | Whether this row was charged. |
| `input` | Your own columns, unchanged. |
| `schemaVersion` | The version of this shape. Field names never change inside a major version; fields are only added. |

| `status` | Meaning | Charged |
|---|---|---|
| `found` | A business email was found. | yes |
| `no_email_found` | The site was read and publishes no usable address. | no |
| `blocked` | The site refused the request. | no |
| `unreachable` | No usable answer, on any spelling of the address, within the time one website gets. | no |
| `unreachable_dead` | No live website behind the name: the domain does not exist in DNS (not registered, expired or on hold), points at no web server, or is parked (parking name servers or a "domain for sale" page). Proven from public DNS and registry data, never guessed. | no |
| `needs_browser` | The site shows its content only with JavaScript. | no |
| `robots_disallowed` | The site's robots.txt asks tools not to read it. | no |
| `skipped_seen` | Delivered in an earlier run, or a repeat inside your list ("same website as item N"). | no |
| `invalid_input` | The item is not a usable website address. | no |
| `not_checked` | The run stopped at your spending limit before this website was read. | no |
| `input_error` | The input as a whole was refused; this is the run's only row. | no |

**Legal notice (off by default).** With `legalNotice` on, the tool also reads the legal notice (Impressum, mentions légales) of German, Austrian and Swiss sites, from the page it reads anyway, and adds the five fields above; the price and the pages read do not change. The register number and VAT ID are left empty for sole traders (e.K., e.U., Einzelunternehmen) and whenever the legal form is not stated. No person's name is ever returned.

**How the best email is chosen.** By fixed rules, in this order: on the site's own domain; found on a contact or legal page; published as a link; a role address. Data-protection addresses are kept and ranked last. An address at a domain that accepts no mail is dropped. An address on another domain counts only when the company states it on its contact or legal page, or gives it as its organisation's own email in its own structured data; `bestEmailReason` then says so.

**Confidence.** `high`: own domain, a role address, the domain accepts mail, and published as a link or on a contact or legal page. `medium`: own domain but not a role address, or found only in text; or another domain stated as above. `low`: a free-mail address (gmail.com and the like) that the site gives as its contact, shown only when nothing better exists, or an address whose mail check could not be confirmed. A free-mail address with a person's name is left out like any named address.

Four table views: **Spreadsheet** (eight flat columns: website, company name, email, confidence, phone, proof page, contact page, status), **Leads**, **Proof** and **Every website and its status**.

A run also writes a `SUMMARY` record: rows by status, results charged, the amount charged for results and the time taken.

### Measured on a sealed test list

The test list is 500 real company websites: 125 each from the United Kingdom, the United States, the EU and India, drawn from Wikidata (CC0) by a fixed random seed and sealed before the run. Each website was first labelled by a separate check that does not use this tool's code: is it alive, does it show an email, and which one (only a fingerprint of each address is kept). These firms are notable enough to be in Wikidata, so they lean older and larger than a typical list of small local businesses; expect a lower rate on tiny shops and trades. One run of the list on the Apify platform, 13 November 2026, default settings, took 13 minutes 55 seconds:

| Measure | Result |
|---|---|
| **Found, of all 500 websites** | 262 of 500 (52%) |
| **Found, of the 342 websites that show an email** | 245 of 342 (72%) |
| Best emails that are a right business address (233 matched our separate check; the other 29 were checked one by one by a separate reviewer: 23 right, 2 wrong, 4 privacy or unclear) | 256 right, 2 wrong |
| Found, of the websites that answered the tool | 262 of 393 (67%) |
| Websites that show no email anywhere, dead or refusing visits (to the separate check) | 57 no email, 68 dead or no answer, 33 refused or bot check |

A second, fresh list of 300 websites was run the same day (150 from Wikidata and 150 small local firms from OpenStreetMap, data © OpenStreetMap contributors, ODbL 1.0), and every pick was judged against a separate reader's labels: a right business email for 136 of 300 (45%) and for 119 of the 159 sites that publish one (75%), with 2 wrong in 138 judged. On the small local firms alone: 49 of 150 (33%), and 44 of the 69 that publish one (64%).

### Limits

- The tool reads a site the way a polite visitor does: it names itself, obeys robots.txt, waits when asked and never goes around a block. Some sites refuse automated requests or do not answer; those rows are not charged.
- Sites that only offer a contact form have no address to find.
- At most 10 pages a site, 15 seconds and 2 MB a page, at most 22 seconds for one website in all, and never beyond the site's own domain.
- A run stops after 1 hour by default (about 1,500 websites); for a longer list, raise the run timeout or split the list.
- **Compute cap.** A run also stops cleanly when its own compute (memory x run time at $0.2 per compute unit) passes `maxComputeUsd`. The rows saved so far stay, websites not read yet get a free `not_checked` row, nothing is charged for them, the `SUMMARY` says `stoppedAtComputeCap: true` and the final message says why; the run still succeeds. The default is $0.050 per 1,000 websites x 3, and never below $0.02: $0.02 up to 133 websites, $0.15 for 1,000, $1.50 for 10,000, at 512 MB; a run given more memory gets a cap larger in the same ratio. Source: Apify run `y0ImHtxsJbYLyThMH` (11 Nov 2026, the frozen list of 200 websites, 512 MB) used 0.04994 compute units ($0.00999), which is $0.050 per 1,000 websites (one website gives at most one result).

**What this tool does not do.** It does not find people, guess addresses, verify mailboxes, scrape social networks, or use a browser in version 1. If a value was not published, the field is empty: nothing is guessed. If you need one of these, this is the wrong tool, and we would rather say so here than after you have paid.

### Use it from the API, MCP, n8n, Make and Zapier

- **API:** start a run with a JSON body such as `{"websites": ["example.com"]}` and read the dataset when it finishes. One website is a normal call: it returns one row.
- **MCP and AI agents:** every input and every output field is described in the schema, so an agent can fill the form and read the rows without this page. Errors come back as rows with a `status`, not as failed runs.
- **n8n, Make and Zapier:** use Apify's own app in each tool, choose this Actor, map your website column to `websites`, and map `bestEmail` back to your sheet or CRM. Send your row id as an extra column and read it back under `input`. Winners of public contracts: run our UK & EU Contract Winners tool (`aurelmark/contract-winners`) with `"onlyWithWebsite": true`, then send each `winnerWebsite` whose `contactEmail` is empty here, once per site, e.g. `{"websites": ["https://photonicsolutions.co.uk/"]}`. Match `website` back to `winnerWebsite`; skip `bestEmailSource: "security_txt"`.
- **CSV or Excel:** open the run's **Spreadsheet** table and press **Download -> CSV** or **Excel**. Through the API, add `?view=spreadsheet&format=csv` to the dataset items address.
- **Google Sheets:** download the CSV and use **File -> Import**, or let each run fill the sheet: in Zapier use the Apify trigger "Actor Run Finished", then "Get Dataset Items", then Google Sheets "Create Spreadsheet Row"; in Make use "Watch Actor Runs", "Get Dataset Items" and Google Sheets "Add a Row".

### Run it every week, without paying twice

Schedule it (cron `0 7 * * 1`, Mondays 07:00) on the websites of this week's new leads; the tool reads only the list you send. Turn on `skipSeen` so a repeat is not charged. A website delivered before comes back as `skipped_seen`, is not read and is not charged. `recheckAfterDays: 90` reads each website again at most every 90 days. `resetSeen` empties the memory.

```json
{ "websites": ["zalando.de", "hetzner.com"], "skipSeen": true, "recheckAfterDays": 90 }
```

What is stored: a list of domains with the day each was last delivered, in a key-value store named `website-contact-finder-seen` in your own account. No addresses, no names, no page content. It is written only by runs with `skipSeen` on, and you can delete it at any time.

### Works well with

- [Website Technology Detector & Tech Stack Finder](https://apify.com/aurelmark/tech-stack-finder) (`aurelmark/tech-stack-finder`): the same list of websites, with the CMS, shop platform, analytics tags and payment providers each home page shows, each with its proof.
- [UK & EU Contract Awards: Tender Winners as Leads](https://apify.com/aurelmark/contract-winners) (`aurelmark/contract-winners`): companies that just won UK and EU public contracts, with the winner's website when the notice or its email domain gives one, ready to put in here.

### Your duties

**Your duties when using business contacts.** This tool returns contact details that a business has published about itself, with the page or notice each one came from. By default it returns role addresses such as info@ or sales@ and leaves out addresses that belong to a named person. What you do with the contacts is your responsibility. Before you write to anyone, check the rules that apply to you and to them: in the EU and the UK that means the GDPR and the national rules on marketing email, which differ by country and can be stricter for sole traders. Say who you are, say where you found the address, make it easy to say no, and stop when asked. If you switch on named-person contacts you are handling personal data and need your own lawful reason for it. This is not legal advice.

### Sources

Only pages a company publishes on its own website. No directories, no social networks, no bought lists. The mail check asks public DNS whether the address's domain accepts mail; the tool never sends mail and never probes a mailbox.

### FAQ

**Why is there no email for a site I know has one?** See `status` and `statusReason` on that row. The usual reasons: the site refused the request, the address is only shown after JavaScript runs, or it belongs to a named person and `includeNamedPeople` is off (the row then says how many were left out).

**Do I pay for blocked sites or errors?** No. Only rows with status `found` are charged, and each row says so in `charged`. A row whose only address is a security.txt desk is shown but not charged.

**Can I send 5,000 websites?** Yes, up to 10,000 in one run. One website gets about 20 seconds at most, and about 10 are read at the same time. A website that did not answer in time is tried once more at the end of the run.

**Why did I get a `role` address and not the owner's?** That is the default, on purpose: role addresses are published for business contact. Turn on `includeNamedPeople` if you have a lawful reason to use personal addresses.

**Many of my websites came back `blocked` or `needs_browser`. What can I do?** These rows are free. `blocked` means the site refuses automated visits, and the tool does not go around that. `needs_browser` means the site shows its text only with JavaScript, which version 1 does not run. Check a few of those sites by hand, or leave them out of your next list.

**Where do I get a list of companies to check?** Any list of websites works. If you sell to companies that work for the public sector, our Contract Winners tool (`aurelmark/contract-winners`) gives you the companies that just won UK and EU public contracts, many with their website: put those websites in here.

# Changelog

This Actor's version history is a separate document: https://apify.com/aurelmark/website-contact-finder/changelog.md

# Actor input Schema

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

Company websites or bare domains, one per line, for example example.com or https://www.example.com. Up to 10,000 in one run. Through the API each item may also be a row such as {"website": "example.com", "id": "A-17", "country": "GB"}: your other columns come back unchanged under input. The name startUrls is accepted for this field too. One output row per website; a website that appears twice is read once.

## `startUrls` (type: `array`):

For automations moving from another contact scraper: the same list under the name startUrls, as \[{"url": "https://example.com"}] or as plain strings. Send either websites or startUrls, not both. Not shown in the form.

## `includeNamedPeople` (type: `boolean`):

Off by default: only role addresses such as info@ or sales@ and other general business addresses are returned, and each row says how many addresses of named people were left out. Turn on to also return addresses that belong to a named person, such as jane.doe@, or that may be one person's mailbox, such as a role word beside a name. You are then handling personal data and need your own lawful reason to use it.

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

Return the company's phone numbers in international format. Numbers from phone links come first; numbers that cannot be confirmed as valid are listed apart and never chosen as the best phone. Turn off if you only need emails. The price is the same either way.

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

A two-letter country code such as GB, DE, IN or US. It is used to read phone numbers written without a country code when a row gives no country of its own. Leave empty to let the tool take the country from the domain ending or the page language. It has no effect on emails.

## `includeSocial` (type: `boolean`):

Return links to the company's own LinkedIn, Facebook, Instagram, X, YouTube and TikTok pages when its website links to them. The tool only copies the links from the company's website; it never visits or reads the social networks.

## `legalNotice` (type: `boolean`):

Off by default. Turn on to also return the company's legal form, register court, register number and VAT ID, read from its legal notice (Impressum) page when that page is read anyway. No extra page, no extra charge. Left empty when the notice does not state them, for sole traders, and when the legal form is unknown. Never a person's name.

## `skipSeen` (type: `boolean`):

Turn on to not read and not charge a website that an earlier run with this option already delivered. Such rows come back with status skipped_seen. The memory is a list of domains and dates kept in a key-value store named website-contact-finder-seen in your own account; nothing else is stored.

## `recheckAfterDays` (type: `integer`):

Only with skipSeen on. A website delivered this many days ago or longer is read again, and charged again if an email is found. Leave empty to never read a delivered website again. Example: 90 reads each website at most once every 90 days.

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

The most pages read on one website, from 1 to 10. The tool reads the home page first, then the contact, legal notice and about pages it links to, and stops early once an email is found. More pages can find a few more emails and make a run slower. The price does not depend on this number.

## `extraSources` (type: `boolean`):

Only when the site's pages give no address on its own domain: also read its security.txt. An address from it is a desk for security reports, so it is ranked last and given low confidence.

## `resetSeen` (type: `boolean`):

Turn on for one run to empty the memory used by skipSeen before the run starts, so every website is read again. Websites of this run are remembered again if skipSeen is also on. Turn it off afterwards.

## `maxComputeUsd` (type: `number`):

Optional. The run stops cleanly, keeping the rows it has, once its own compute passes this many US dollars; websites not read yet get a free not_checked row. Leave empty for the default: $0.05 per 1,000 websites x 3, at least $0.02, more with more memory (see Limits).

## Actor input object example

```json
{
  "websites": [
    "zalando.de",
    "innocentdrinks.co.uk",
    "kingarthurbaking.com"
  ],
  "includeNamedPeople": false,
  "includePhones": true,
  "includeSocial": true,
  "legalNotice": false,
  "skipSeen": false,
  "maxPagesPerSite": 5,
  "extraSources": true,
  "resetSeen": false
}
```

# Actor output Schema

## `spreadsheet` (type: `string`):

Eight flat columns per website (website, company, email, confidence, phone, proof page, contact page, status), ready for CSV, Excel or Google Sheets.

## `leads` (type: `string`):

One row per website with the best business email, phone and company name.

## `proof` (type: `string`):

The reason and the proof page for every email.

## `all` (type: `string`):

Every website with its status, the reason, the pages read, when it was checked and whether it was charged.

## `summary` (type: `string`):

Rows by status, the amount charged for results and the time taken.

# 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": [
        "zalando.de",
        "innocentdrinks.co.uk",
        "kingarthurbaking.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("aurelmark/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": [
        "zalando.de",
        "innocentdrinks.co.uk",
        "kingarthurbaking.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("aurelmark/website-contact-finder").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": [
    "zalando.de",
    "innocentdrinks.co.uk",
    "kingarthurbaking.com"
  ]
}' |
apify call aurelmark/website-contact-finder --silent --output-dataset

```

## MCP server setup

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

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/DvSmoyU35P6gss2ZU/builds/UPpEB0zle01WExP2L/openapi.json
