# Domain Contact Enricher: Emails & Phones (`axiorasolutions/domain-contact-enricher`) Actor

Turn company domains into contactable records. Returns role emails, phones, social profiles, postal addresses, company name, 90+ technology signals, the ATS a company uses, and live MX/SPF/DMARC email infrastructure. One row per domain, and every value carries the page it came from.

- **URL**: https://apify.com/axiorasolutions/domain-contact-enricher.md
- **Developed by:** [Axiora Solutions](https://apify.com/axiorasolutions) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.30 / 1,000 enriched companies

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

Learn more: https://docs.apify.com/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

## Domain Contact Enricher — Email Finder & Company Enrichment

**Domain Contact Enricher** is an Apify **email finder** and **company enrichment** Actor that turns a plain list of company domains into a contactable lead list — **one row per domain** with e-mail addresses, phone numbers, social profiles, 90+ technology signals, the applicant tracking system the company uses, and live MX/SPF/DMARC e-mail infrastructure. Every value records the exact source page it was found on, alongside confidence labels and detection evidence, so you can audit a row instead of trusting it. No API key, no login, nothing to configure — paste your domains and click **Start**.

### What you get

- `emails[]` — published addresses with `confidence`, `isRoleAccount` and the exact `foundOn` page URL.
- `phones[]` — E.164-range numbers with `tel:` links ranked first, each with its source page.
- `socialProfiles` and `linkedinUrl` — LinkedIn, GitHub, YouTube, X and more, deduplicated.
- `company` — legal name, description, logo, founding date, employee count, VAT/tax ID and postal addresses.
- `technologyIds[]` / `technologies[]` — 90+ tech signals across 14 categories, each with the evidence that fired it.
- `atsProvider` / `emailInfrastructure` — the ATS in use plus a ready-to-paste scraper input, and live MX/provider/SPF/DMARC data with `contentHash` for change detection.

**Honest coverage note:** contact details are only returned when the site publishes them. Modern sites often route contact through forms, images or client-side JavaScript, so an e-mail per domain is **not guaranteed**. The `coverage` block in the run summary reports the real hit rate on your list before you scale.

### Quick start

1. Open the Actor on Apify and paste your domains into **Company domains**. A bare domain (`apify.com`), a full URL or an e-mail address all work; the input is prefilled with a working example.
2. Leave **Pages per domain** at `4` and **Find contact and imprint pages** enabled. Those defaults reach the contact, about and imprint pages on most sites.
3. Click **Start** — no API key or login is needed. When the run finishes, switch between the **Contacts**, **Every e-mail** and **Technology & hiring** dataset tabs, or export to JSON, CSV, Excel or Google Sheets.

Minimal input:

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

### Example output

One dataset row:

```json
{
  "ok": true,
  "errorCode": null,
  "requestedInput": "apify.com",
  "domain": "apify.com",
  "websiteUrl": "https://apify.com/",
  "redirectedToDomain": null,
  "httpStatus": 200,
  "companyName": "Apify",
  "company": {
    "name": "Apify",
    "legalName": "Apify Technologies s.r.o.",
    "description": "Full-stack web scraping and data extraction platform.",
    "logoUrl": "https://apify.com/og-image.png",
    "foundingDate": "2015",
    "employeeCount": null,
    "industry": null,
    "vatId": null,
    "addresses": [
      {
        "street": "Vodickova 704/36",
        "locality": "Prague",
        "region": null,
        "postalCode": "110 00",
        "country": "Czechia",
        "formatted": "Vodickova 704/36, Prague, 110 00, Czechia"
      }
    ],
    "sameAs": ["https://github.com/apify"]
  },
  "primaryEmail": "hello@apify.com",
  "emailCount": 2,
  "emails": [
    {
      "email": "hello@apify.com",
      "emailDomain": "apify.com",
      "isRoleAccount": true,
      "isOnSiteDomain": true,
      "confidence": "high",
      "foundOn": "https://apify.com/contact"
    }
  ],
  "primaryPhone": null,
  "phoneCount": 0,
  "phones": [],
  "linkedinUrl": "https://www.linkedin.com/company/apify",
  "socialProfiles": {
    "linkedin": "https://www.linkedin.com/company/apify",
    "github": "https://github.com/apify",
    "youtube": "https://www.youtube.com/@apify"
  },
  "socialProfileCount": 3,
  "technologyCount": 7,
  "technologyIds": ["cloudflare", "google-tag-manager", "hubspot", "intercom", "nextjs", "react", "sentry"],
  "technologies": [
    { "id": "nextjs", "name": "Next.js", "category": "framework", "evidence": "html: __NEXT_DATA__" },
    { "id": "cloudflare", "name": "Cloudflare", "category": "infrastructure", "evidence": "headers: cf-ray" }
  ],
  "atsDetected": [
    {
      "provider": "greenhouse",
      "name": "Greenhouse",
      "boardToken": "apify",
      "boardUrl": "https://boards.greenhouse.io/apify",
      "atsJobScraperInput": "greenhouse:apify"
    }
  ],
  "atsProvider": "greenhouse",
  "atsJobScraperInput": "greenhouse:apify",
  "emailInfrastructure": {
    "mxHosts": ["aspmx.l.google.com", "alt1.aspmx.l.google.com"],
    "mailProvider": "Google Workspace",
    "hasSpf": true,
    "hasDmarc": true,
    "spfIncludes": ["_spf.google.com"],
    "resolved": true
  },
  "pagesCrawled": [
    { "url": "https://apify.com/", "kind": "homepage", "status": 200, "bytes": 142331, "title": "Apify" },
    { "url": "https://apify.com/contact", "kind": "discovered", "status": 200, "bytes": 51220, "title": "Contact us" }
  ],
  "pageCount": 2,
  "contentHash": "5b1f7c2e9a3d4061",
  "scrapedAt": "2026-10-02T12:00:00.000Z"
}
```

### What this contact enricher returns

- 📧 **E-mails with provenance, not guesses** — `confidence: high` means a `mailto:` link or a role account (`info@`, `sales@`, `careers@`) on the company's own domain. `medium` is a plain-text match on the company domain. `low` is a third-party address (agency, CDN, partner). You decide what to trust. **No address is ever generated from a name pattern.**
- ☎️ **Phones that survive validation** — only 8–15 digit numbers inside the ITU E.164 range, with `tel:` links ranked first. Dates, version strings and asset hashes are rejected.
- 🏢 **Company identity from structured data** — legal name, description, logo, founding date, employee count, VAT/tax ID and postal addresses, read from the site's own JSON-LD and OpenGraph markup.
- 🧱 **90+ technology signals in 14 categories** — e-commerce, CMS, framework, hosting, analytics, marketing, support, payments, security, privacy, reviews and more. Each hit ships its evidence string.
- 🎯 **Hiring-platform detection** — finds Greenhouse, Ashby, Lever, Workable, SmartRecruiters, Recruitee, Personio, Teamtailor, BambooHR or Rippling and returns the board URL **plus a ready-to-paste input for the ATS Job Scraper**.
- 📬 **E-mail infrastructure via live DNS** — MX records in priority order, the resolved mail provider (Google Workspace, Microsoft 365, Zoho, Proofpoint, Mimecast…), and whether SPF and DMARC are published. A missing DMARC record is both a security finding and a sales trigger.
- 🧾 **Full audit trail** — `pagesCrawled` lists every URL read with status, bytes and title. `contentHash` lets a scheduled run detect website changes without storing any HTML.
- 🤖 **Agent-ready** — the main input is an array, no field is a credential, and the output schema is fully documented, so an autonomous agent can call this without a human.

Running on Apify adds scheduling, run history, webhooks, monitoring, the API and SDKs, and one-click export to JSON, CSV, Excel, Google Sheets and 20+ integrations.

### How to use it

1. Put your domains in **Company domains**. A bare domain, a full URL or an e-mail address all work.
2. Set **Pages per domain**. `1` reads only the homepage; `4` is the default and usually enough; `8–12` digs into deep imprint pages.
3. Leave **Find contact and imprint pages** on. The Actor scores homepage links by URL and anchor text and visits the best candidates — `/contact`, `/about`, `/team`, `/impressum`, `/legal`, `/support`.
4. Toggle the enrichment blocks you need. They are independent and **do not change the price**, which is per company.
5. Click **Start**, then switch between the **Contacts**, **Every e-mail** and **Technology & hiring** dataset tabs.

#### How do I get more e-mails per company?

Raise **Pages per domain** to 8 and add known paths to **Always try these paths** (for example `/contact-us`, `/en/imprint`, `/company/contact`). German, Austrian and Swiss sites are legally required to publish an imprint, so `/impressum` has a very high hit rate there.

### Example input

```json
{
  "domains": ["apify.com", "stripe.com", "https://www.ramp.com"],
  "maxPagesPerDomain": 4,
  "discoverContactPages": true,
  "extraPaths": ["/contact", "/impressum"],
  "includeCompanyProfile": true,
  "includeTechnologies": true,
  "includeAtsDetection": true,
  "includeDnsSignals": true,
  "maxEmailsPerDomain": 15,
  "respectRobotsTxt": true
}
```

### How much does it cost to enrich company domains?

Pricing is **pay per event** with a single event:

| Event | What triggers it | Billed |
|---|---|---|
| Enriched company | A domain was fetched and a company row was written | per company |
| Actor start | Once per run, platform fee | per run |

**Domains that cannot be fetched are free.** A dead domain, a 403, a DNS failure or a timeout produces an `ok: false` row and is **never charged** — you only pay for companies you actually received data for.

The price is per company, not per page, so turning on every enrichment block costs exactly the same as turning them all off. 1,000 domains is 1,000 billed events. Compute, bandwidth and storage are included; there is no separate platform-usage charge on top.

Set **Max cost per run** in the run options for a hard ceiling. Higher Apify plans receive progressively lower per-company pricing through Apify Store tier discounts.

Evaluating? Run 5 domains first and look at the `coverage` block in the run summary — it reports how many companies yielded an e-mail, a phone and an ATS. That tells you the real hit rate on **your** list before you scale it.

### Use cases

- **Outbound lead enrichment** — take a domain list from any source and make it contactable in one run.
- **ICP and segmentation** — filter by `technologyIds` to find every prospect on Shopify, HubSpot, Next.js or Stripe.
- **Hiring-signal prospecting** — `atsProvider` tells you who is hiring and on which platform; chain into the ATS Job Scraper for the actual roles.
- **E-mail deliverability audits** — list every domain in a portfolio without DMARC.
- **CRM hygiene** — re-run monthly and diff `contentHash` to catch rebrands, acquisitions (`redirectedToDomain`) and dead sites.
- **Agent tool** — a clean, credential-free tool call for an autonomous research agent.

### Related Actors by Axiora Solutions

| Actor | Use it for |
|---|---|
| **ATS Job Scraper** | Paste `atsJobScraperInput` and get every open role at the companies you just enriched |
| **Shopify Product & Variant Scraper** | For every prospect detected as Shopify, pull their full catalogue and pricing |
| **Sitemap & Indexability Audit** | Technical SEO state of the same domains, for agency pitches |

### Frequently asked questions

#### Does this find personal e-mail addresses of employees?

No, and that is deliberate. This Actor reads only what a company publishes on its own website, which in practice means role accounts and office numbers. It does not guess `firstname.lastname@` patterns, does not query third-party people databases, and does not scrape social networks for individuals. If a site publishes a named person's address on its own contact page, that address will appear — flagged by confidence — because the company chose to publish it.

#### Is scraping company contact details from websites legal?

The Actor fetches publicly served pages and honours `robots.txt` by default. Business contact details published by a company on its own website are the least sensitive category of this data, but you remain responsible for your lawful basis for processing and for your outreach — GDPR, CAN-SPAM, PECR and equivalents apply to **how you use** the output. Nothing here is legal advice.

#### Why does a company have no e-mail at all?

Common and expected. Many companies route all contact through a form, put the address in an image, or render it only after JavaScript runs. This Actor uses plain HTTP and does not execute JavaScript, which is what makes it fast and cheap. Check `pagesCrawled` to confirm the contact page was actually read, then raise **Pages per domain** or add the exact path.

#### Does it run JavaScript or use a browser?

No. Every request is plain HTTP, which is why a run costs a fraction of a browser-based crawl. For sites that only render contacts client-side, expect lower coverage — the `coverage` block in the run summary quantifies it honestly rather than hiding it.

#### What does `confidence` actually mean?

`high` — the address was in a `mailto:` link, or it is a role account on the company's own domain. `medium` — plain-text match on the company's own domain. `low` — a different domain entirely, so it may belong to an agency, a hosting provider or a partner. Filter to `high` and `medium` for outbound.

#### Why is `emailInfrastructure` useful?

`mailProvider` is a reliable company-size and stack signal. `hasDmarc: false` means the domain is spoofable, which is a genuine finding for security vendors and a credible opening line for outbound. These come from live DNS, not from the page.

#### Should I enable the proxy?

Usually not. Most sites answer plain requests fine, and running without a proxy is faster and costs you nothing extra. Turn on datacenter proxy rotation if you hit `ACCESS_DENIED` on many domains. Residential groups also work but Apify bills them per gigabyte, so only use them when you must.

#### Can I run this on a schedule?

Yes. Add a **Schedule**, then diff `contentHash` to find changed sites, `redirectedToDomain` to catch acquisitions, and `atsProvider` to spot companies that just started hiring.

#### Something looks wrong — how do I report it?

Open the **Issues** tab on this Actor page with the domain and the field you expected. A false-positive e-mail or technology detection is treated as a bug and gets a narrower rule.

***

Runnable examples and how-to guides for these Actors: [github.com/batow133/axiora-apify-actors](https://github.com/batow133/axiora-apify-actors)

# Actor input Schema

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

One company per entry. A bare domain, a full URL or an e-mail address all work: apify.com, https://www.stripe.com/about, hello@example.org. www is stripped and the registrable domain is used as the row key.

## `maxPagesPerDomain` (type: `integer`):

How many pages to fetch for each company, homepage included. Contact details usually appear within the first 3-5. Higher values find more but cost more time and bandwidth.

## `discoverContactPages` (type: `boolean`):

Follow links on the homepage whose text or URL looks like contact, about, team, support, imprint, impressum or legal. Turn off to read only the homepage.

## `extraPaths` (type: `array`):

Extra paths appended to every domain, for example /contact-us or /en/imprint. Useful when you already know the site structure.

## `includeCompanyProfile` (type: `boolean`):

Extract company name, legal name, description, logo, founding date, employee count and postal addresses from JSON-LD, OpenGraph and meta tags.

## `includeTechnologies` (type: `boolean`):

Detect e-commerce, CMS, analytics, CRM, chat, payment, hosting and framework technologies from markup, script URLs and response headers. Every hit records the evidence that produced it.

## `includeAtsDetection` (type: `boolean`):

Find which applicant tracking system the company uses (Greenhouse, Ashby, Lever, Workable, SmartRecruiters) and return the board URL. Feed that straight into the ATS Job Scraper.

## `includeDnsSignals` (type: `boolean`):

Resolve MX records to identify the mail provider (Google Workspace, Microsoft 365, Zoho, Proofpoint and others) and check whether SPF and DMARC are published. Strong signal for deliverability and for company size.

## `maxEmailsPerDomain` (type: `integer`):

Keep at most this many e-mail addresses per company, highest confidence first. Role accounts on the company's own domain rank above third-party addresses.

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

Skip paths the site disallows for automated clients. Leave this on unless you own the sites or have permission; it is the safer and more polite default.

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

Give up on a single page after this many seconds.

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

Optional. Datacenter proxy rotation helps when a site blocks repeated requests from one address. Residential groups work too but are billed per gigabyte by Apify, so only enable them if you need them.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "stripe.com",
    "https://www.ramp.com"
  ],
  "maxPagesPerDomain": 4,
  "discoverContactPages": true,
  "extraPaths": [
    "/contact",
    "/imprint"
  ],
  "includeCompanyProfile": true,
  "includeTechnologies": true,
  "includeAtsDetection": true,
  "includeDnsSignals": true,
  "maxEmailsPerDomain": 15,
  "respectRobotsTxt": true,
  "requestTimeoutSecs": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

One row per domain: company identity, e-mails, phones, social profiles, postal addresses, technology signals, detected ATS and e-mail infrastructure.

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

Domains requested, pages fetched, how many companies yielded an e-mail, a phone or an ATS, robots.txt blocks, billing and network totals.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "apify.com",
        "https://www.ramp.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiorasolutions/domain-contact-enricher").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "apify.com",
        "https://www.ramp.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("axiorasolutions/domain-contact-enricher").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 '{
  "domains": [
    "apify.com",
    "https://www.ramp.com"
  ]
}' |
apify call axiorasolutions/domain-contact-enricher --silent --output-dataset

```

## MCP server setup

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

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/bSH6xP5dZ2X42Ckof/builds/7SVzQTXDvcrN2FNfH/openapi.json
