# Company Enrichment by Domain: Socials, Emails, Tech Stack $5/1k (`transparent_meteorite/company-enrichment-by-domain`) Actor

Give it company domains; get company name, logo, description, socials, careers/ATS, business emails and phones, email provider (MX) and tech stack from the company's own public site. No login, no data brokers. $0.005 per domain.

- **URL**: https://apify.com/transparent_meteorite/company-enrichment-by-domain.md
- **Developed by:** [Open Data Actors](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Company Enrichment by Domain — Socials, Email Provider, $5/1k

![Company Enrichment by Domain on Apify](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/banner-company-enrichment-by-domain.png)

![Company Enrichment by Domain sample output table](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/output-company-enrichment-by-domain.png)

- **In short:** Company Enrichment by Domain (Apify actor `transparent_meteorite/company-enrichment-by-domain`) turns a list of company domains into firmographic rows built from each company's own public website and DNS.
- **Who it is for:** sales ops and RevOps teams, Clay and CRM users cleaning account lists, agencies qualifying prospects.
- **Input:** a list of domains, max pages per domain, include tech stack.
- **Output:** company name, logo, description, LinkedIn and other social URLs, role emails, phones, email provider from MX, careers/ATS URL, tech stack.
- **Price:** $0.005 per domain enriched plus $0.00005 per run start. Pay per result, no subscription; Apify's free plan credit covers a first test.
- **Limits:** uses only public pages and DNS, so private data such as revenue or headcount is not included.

**Key facts**

- Actor name: Company Enrichment by Domain
- Actor ID: `transparent_meteorite/company-enrichment-by-domain`
- Store page: https://apify.com/transparent_meteorite/company-enrichment-by-domain
- Data source: the company's own public website and public DNS records
- Pricing model: pay per event (`apify-actor-start` $0.00005, `domain-enriched` $0.005)
- Output formats: JSON, CSV, Excel, XML, HTML table, RSS (Apify dataset)
- Access: Apify Console, REST API, JavaScript/Python clients, schedules, webhooks, Apify MCP server
- Login or third-party API key needed: no, only an Apify account
- Also known as: company enrichment API, domain to company data, Clearbit alternative, firmographic enrichment, company LinkedIn from domain
- Maintainer: transparent_meteorite (independent developer)
- Last updated: 2026-10-07

Give it a list of company domains. Get back one clean firmographic row per domain: company name, description, logo, socials, careers page and ATS, published business emails and phones, email provider from MX records, and a tech-stack summary. It reads only the company's own public website and public DNS. No login, no data brokers, no browser.

### Sample output (real run)

| Domain | Company | LinkedIn | Email provider | Email published on site | ATS | Country hint |
|---|---|---|---|---|---|---|
| plausible.io | Plausible Analytics | /company/plausible-analytics | other | hello@plausible.io | - | - |
| buttondown.com | Buttondown | /company/buttondown | other | support@buttondown.com | - | - |
| gitlab.com | GitLab | /company/gitlab-com | Google Workspace | - | - | US (schema.org address) |
| zapier.com | Zapier | /company/zapier | Google Workspace | recruiting@zapier.com | - | US (schema.org address) |
| notion.so | Notion | - | other | - | ashby | - |

Full JSON for 12 domains (including one dead domain, which is reported but not charged) is in `samples/output.json`.

### What you get

Per domain: `domain`, `finalUrl`, `status` (`ok` / `unreachable` / `blocked` / `parked`), `companyName` (+ `companyNameSource`), `description`, `logoUrl`, `faviconUrl`, `language`, `countryHint` (+ `countryHintSource`: schema.org address, phone prefix or TLD), `address` (schema.org postal address, only if published), `emails` (each with `isGeneric` and `sameDomain`), `phones` (E.164), `linkedinCompanyUrl`, `x`, `facebook`, `instagram`, `youtube`, `github`, `tiktok`, `careersUrl`, `atsProvider` (greenhouse, lever, ashby, workable, smartrecruiters, recruitee, workday), `emailProvider` (Google Workspace, Microsoft 365, Zoho, other, none), `mxHosts`, `spfPresent`, `techStack` (top categories), `copyrightYear`, `pagesFetched`, `errors`.

Measured on 11 live company sites: company name 100%, email provider 100%, LinkedIn 64%, a published email 45%, a valid phone number 18%. Fields are `null` or empty when the site does not publish them. Nothing is guessed or constructed, including email addresses.

### Quick start

Zero config: press Start. The default input enriches three domains in a few seconds.

Example 1, a lead list:

```json
{ "domains": ["stripe.com", "linear.app", "acme-plumbing.co.uk"], "maxPagesPerDomain": 3 }
```

Example 2, fast and light (homepage only, no tech stack):

```json
{ "domains": ["example.com"], "maxPagesPerDomain": 1, "includeTechStack": false, "concurrency": 10 }
```

Input fields: `domains`, `maxPagesPerDomain` (default 3: the homepage plus up to two of /contact, /about, /careers found in its links), `includeTechStack` (default true), `timeoutSecs` per domain (default 30), `concurrency` (default 5).

### Pricing

Pay per event: **$0.005 per domain enriched** (status `ok`), plus a $0.00005 start fee per run. Unreachable, blocked, parked and robots-disallowed domains are never charged.

| Domains | Cost |
|---|---|
| 100 | $0.50 |
| 1,000 | $5.00 |
| 10,000 | $50.00 |

### Use with Clay, n8n, Make, Zapier and AI agents

- **Clay:** add an HTTP API column. Method POST to `https://api.apify.com/v2/acts/transparent_meteorite~company-enrichment-by-domain/run-sync-get-dataset-items?token=YOUR_TOKEN` with body `{"domains": ["{{Domain}}"], "maxPagesPerDomain": 2}`. Map `companyName`, `linkedinCompanyUrl`, `emailProvider` from the first item of the response.
- **n8n:** use the Apify node (Run actor and get dataset items) or an HTTP Request node with the same URL. Loop over a sheet of domains in batches of 50.
- **Make:** Apify module "Run an Actor", then "Get Dataset Items".
- **Zapier:** Apify app, "Run Actor", then "Fetch Dataset Items".
- **AI agents:** the Actor is available through the Apify MCP server at `https://mcp.apify.com`. Add it to Claude, Cursor or any MCP client and ask: "enrich these domains and tell me which use Google Workspace". The output is flat JSON with stable field names.

### Use from AI agents (MCP, ChatGPT, Claude, Perplexity)

Company Enrichment by Domain works as a tool for AI assistants through the official Apify MCP server. Add this server URL to any MCP client (Claude Desktop, Claude Code, Cursor, ChatGPT connectors, VS Code):

```
https://mcp.apify.com/?actors=transparent_meteorite/company-enrichment-by-domain
```

Claude Desktop / Cursor config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=transparent_meteorite/company-enrichment-by-domain",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Then ask in plain language, for example: "How do I get a company LinkedIn page and emails from a domain?"

Call it directly over HTTP (runs the actor and returns the dataset items in one request):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~company-enrichment-by-domain/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["basecamp.com", "plausible.io", "posthog.com"], "maxPagesPerDomain": 3, "includeTechStack": true}'
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("transparent_meteorite/company-enrichment-by-domain").call(run_input={"domains": ["basecamp.com", "plausible.io", "posthog.com"], "maxPagesPerDomain": 3, "includeTechStack": true})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

The same actor works in n8n, Make, Zapier, LangChain, LlamaIndex and CrewAI through their Apify integrations.

#### Questions people ask

**How do I get a company LinkedIn page and emails from a domain?**
Give the domains to this actor; it reads the public site and returns the LinkedIn URL, role emails and phones it finds.

**Is this a Clearbit alternative?**
For public firmographics (socials, emails, email provider, tech stack) yes, at $0.005 per domain. It does not provide revenue or employee counts.

**Does it use data brokers?**
No. Only the public website and DNS.

### Use cases

- Fill missing company name, logo and LinkedIn URL in a CRM or Clay table that only has domains.
- Segment accounts by email provider (Google Workspace vs Microsoft 365) for outbound and deliverability planning.
- Find which accounts hire through Greenhouse, Lever or Ashby, and link straight to the careers page.
- Pre-qualify a scraped domain list: drop parked and dead domains before paid enrichment.
- Give an AI sales agent a cheap, factual company profile as grounding.

### FAQ

**How do I get the LinkedIn company page from a domain?**
The Actor reads the links and schema.org `sameAs` data on the homepage, /about and /contact pages. If the site links to its LinkedIn company page, you get `linkedinCompanyUrl`. If it does not, the field is null. It does not search LinkedIn.

**How do I tell whether a company uses Google Workspace or Microsoft 365?**
The Actor looks up the domain's MX records over public DNS and classifies them. `emailProvider` is one of Google Workspace, Microsoft 365, Zoho, other or none. `mxHosts` shows the raw hosts and `spfPresent` tells you whether an SPF record exists.

**Does it find people's emails or guess info@ addresses?**
No. It only returns addresses the site itself publishes, including ones hidden by Cloudflare email protection. Each is flagged `isGeneric` (info@, sales@, hello@, support@ and similar). Only business role addresses are returned; addresses that look like a named person are dropped, so the output contains no personal email addresses. It never constructs or verifies addresses.

**Is it allowed? Does it respect robots.txt?**
It fetches at most a few ordinary public pages per domain with an identifying user agent, checks robots.txt for each path, and does not log in or bypass anything. Domains that disallow the homepage come back as `blocked` and are not charged. You are responsible for how you use the data under GDPR and local rules.

**Why is a field empty for a company I know has it?**
The Actor only reads what the site publishes in its HTML. A LinkedIn link added by JavaScript, or a phone number in an image, will not be seen.

**What does `status` mean and what is charged?**
`ok` means a real website was reached and read. That is the only status charged. `unreachable` (DNS or connection failure, error page, empty JS-only page), `blocked` (403, 429, bot challenge or robots.txt) and `parked` (domain for sale) are returned free so your table stays complete.

**How fast is it?**
Roughly 1 to 5 seconds per domain at the default concurrency of 5, so 1,000 domains take a few minutes.

### Limitations

- Only what the company's own site and DNS publish. No headcount, revenue, funding or employee data.
- JavaScript-only sites that render content in the browser may return less (name and description often still come from meta tags).
- Country is a hint with a labeled source, not a verified headquarters.
- Phone numbers are only returned when published in a valid international or locally parseable format.
- The `techStack` is detected from the homepage response only.

### Changelog

- 2026-10-07: added plain-language summary, key facts, AI-agent (MCP) section and question-style FAQ; refreshed Store SEO metadata.

# Actor input Schema

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

Company domains (example.com) or URLs. One output row per domain.

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

Homepage plus up to N-1 of /contact, /about, /careers found in the homepage links.

## `includeTechStack` (type: `boolean`):

Summarize CMS, analytics, CDN, ecommerce and framework detected on the homepage.

## `timeoutSecs` (type: `integer`):

Total time budget for one domain.

## `concurrency` (type: `integer`):

Domains processed in parallel.

## Actor input object example

```json
{
  "domains": [
    "basecamp.com",
    "plausible.io",
    "posthog.com"
  ],
  "maxPagesPerDomain": 3,
  "includeTechStack": true,
  "timeoutSecs": 30,
  "concurrency": 5
}
```

# Actor output Schema

## `overview` (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 = {
    "domains": [
        "basecamp.com",
        "plausible.io",
        "posthog.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/company-enrichment-by-domain").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": [
        "basecamp.com",
        "plausible.io",
        "posthog.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/company-enrichment-by-domain").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": [
    "basecamp.com",
    "plausible.io",
    "posthog.com"
  ]
}' |
apify call transparent_meteorite/company-enrichment-by-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/company-enrichment-by-domain"
        }
    }
}
```

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/R87qiQPotD16ppa9B/builds/ShxxYkpDn9s4ZccmM/openapi.json