# Domain to Company Lookup - Reverse Company Name Finder (`wrenfield-data/domain-to-company`) Actor

Turn domains, URLs or email addresses into company names with country, industry, employee count, founded year, LinkedIn URL, logo and live-site check. Bulk reverse domain lookup for lead lists and AI agents. Pay only for companies found.

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

## Pricing

from $1.50 / 1,000 company founds

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

## Domain to Company Lookup - Reverse Company Name Finder

Turn a list of **domains, URLs or work email addresses** into the **company behind them**: company name, country, industry, employee count, founded year, LinkedIn URL, logo, favicon, and whether the site is live, parked or redirects somewhere else.

It's built for lead lists, CRM cleanup, inbound-signup triage, and AI agents that need to know who owns a domain before acting on it. You pay only for companies found.

#### Sample output

| input | companyName | country | industry | employees | foundedYear | isLive |
|---|---|---|---|---|---|---|
| stripe.com | Stripe | US | mobile payment industry | 2500 | 2010 | true |
| jane@personio.de | Personio | DE | software industry | | 2015 | true |
| https://www.notion.so | Notion | | | | 2016 | true |
| delta.com | Delta Air Lines | US | air transport | | 1925 | true |

Blank cells mean the open data has no value for that field. The Actor never makes values up.

### How it works

1. **Normalize the input.** URLs, subdomains and email addresses are reduced to the registrable domain, so `https://blog.shop.example.co.uk/x` becomes `example.co.uk` and `jane@personio.de` becomes `personio.de`.
2. **Wrenfield Entity Index.** Each domain is looked up in a built-in index of 742,000+ organizations and their official domains, built from Wikidata's open CC0 data. The index ships inside the Actor, so there are no third-party API calls. A match adds the company facts and a Wikidata ID.
3. **Live homepage check** (optional, on by default). The Actor fetches the homepage, follows redirects, detects parked or for-sale pages, and reads the title, description, `og:site_name`, schema.org Organization name, logo, favicon and LinkedIn link. Companies that are not in the index still get a name from their own homepage. If a domain redirects to another domain, that domain is also checked against the index.
4. **Cross-check.** When a company comes from both sources, `nameMatchesHomepage` (0-1) shows how closely the indexed name matches the live site.

The Actor uses only public data and the companies' own homepages. There's no LinkedIn scraping and no login-protected data.

### Input

```json
{
  "domains": ["stripe.com", "https://www.notion.so", "jane@personio.de"],
  "checkHomepage": true,
  "includeUnresolved": true
}
```

- `domains`: domains, URLs or emails, one per line. Up to 100,000 per run; duplicates are removed.
- `csvData`: optional paste of CSV rows. The first column is used.
- `checkHomepage`: set it to `false` for a very fast index-only lookup.
- `includeUnresolved`: keeps the free not-found rows, so your output lines up with your input.

### Output

Each row includes:

- `input`, `domain`, `status` (`found` / `not_found` / `free_email_provider` / `invalid`), `isFreeEmailDomain`
- `companyName`, `wikidataId`, `country` (ISO code), `industry`, `employees`, `foundedYear`
- `linkedinUrl`, `entityLinkedinUrl`, `logoUrl`, `faviconUrl`
- `homepageTitle`, `homepageDescription`, `siteName`, `finalUrl`, `redirectsTo`
- `isLive`, `isParked`, `httpStatus`, `nameMatchesHomepage`
- `sources` (`entity-index`, `homepage`), `checkedAt`

You can download the dataset as JSON, CSV or Excel, or read it through the API. A run summary is stored in the key-value store under `SUMMARY`.

### Pricing

This Actor uses **pay-per-event** pricing.

| Event | Price |
|---|---|
| Company found (`company-found`) | **$1.50 per 1,000 companies** ($0.0015 per company) |
| Actor start (`actor-start`) | $0.0001 per run |

Domains with no company found, invalid inputs and failures are **free**. Platform usage is included. To cap your spend, set **Maximum cost per run**; the Actor stops cleanly when it reaches the limit.

### Related tools

These tools share the same entity data:

- [Company Name to Domain Finder](https://apify.com/wrenfield-data/company-name-to-domain): the forward lookup, from company names to official domains with a confidence score
- [Company Enrichment](https://apify.com/wrenfield-data/company-enrichment): one row per domain with company facts, contacts, tech stack and AI-crawler readiness ($4 / 1,000)
- [Website Contact Scraper](https://apify.com/wrenfield-data/website-contact-scraper): emails, phone numbers and social links for each domain
- [Tech Stack Detector](https://apify.com/wrenfield-data/website-tech-stack-detector): the CMS, ecommerce, analytics and CRM tools a site uses
- [Domain Authority & Traffic Checker](https://apify.com/wrenfield-data/domain-authority-traffic-checker): authority, backlinks and organic traffic

All of them export flat JSON, CSV or Excel, so one tool's dataset can feed the next.

### Use it from n8n, Make, Zapier or Clay

All of these call the same Apify endpoint. It runs the Actor and returns the result rows in one HTTP response, which suits one-row-at-a-time enrichment:

```
POST https://api.apify.com/v2/acts/wrenfield-data~domain-to-company/run-sync-get-dataset-items
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"domains": ["{{Website or Email}}"]}
```

- **Clay:** add an *HTTP API* enrichment column with the request above, and map `{{Company Name}}` (or your column) into the body. Then pick `companyName` and `country` from the response with *Map fields*. One row per call, and you pay only for rows that resolve.
- **n8n:** use the official **Apify** node (*Run Actor and get dataset*), or an *HTTP Request* node with the request above. Put a *Split In Batches* node in front to send a column of domains or work emails in chunks of up to 1,000 per run, which is cheaper and faster than one call per row.
- **Make:** the **Apify** app's *Run an Actor* module (turn on *Run synchronously*), then *Get Dataset Items*.
- **Zapier:** the **Apify** app's *Run Actor* action, or *Webhooks by Zapier* (POST) with the request above.
- **Batch jobs:** pass the whole list in one run, or paste a CSV into `csvData`, then export the dataset as CSV/Excel. Big lists are much faster as one run than as many single-row calls.

Tip: when the domain or work email is empty or invalid, the row comes back with a non-`found` status and is not charged, so a CRM-wide sync never bills for junk rows.

### Use it from an AI agent (MCP)

Add this Actor as a tool in Claude, Cursor, VS Code or any MCP client with one URL:

`https://mcp.apify.com?tools=wrenfield-data/domain-to-company`

- **Minimal input:** `{"domains": ["stripe.com"]}`
- **Fastest input for agents:** `{"domains": ["stripe.com"], "checkHomepage": false}` returns index facts in about a second.

### FAQ

**Can I look up email addresses?**
Yes. The part after `@` is used. Free-mail domains such as gmail.com, outlook.com or yahoo.com are flagged as `free_email_provider` and not charged, so you can separate personal sign-ups from company ones.

**Why are some facts blank?**
Facts come from open data. Large companies are well covered; small businesses often have only a name from their homepage.

**How fresh is the data?**
Homepage fields are fetched live on every run. The entity index is refreshed from Wikidata regularly.

### Feedback and support

Missing a field, hit an error, or need another option? Open an issue on the **Issues** tab and include the run ID. We read every issue and reply there.

# Actor input Schema

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

One per line. Accepts bare domains (<code>stripe.com</code>), full URLs (<code>https://www.notion.so/pricing</code>) or work email addresses (<code>jane@personio.de</code>). Subdomains are reduced to the registrable domain.

## `csvData` (type: `string`):

Optional. Paste one domain, URL or email per line (the first column is used).

## `checkHomepage` (type: `boolean`):

Fetch each homepage to confirm it is live, detect parked domains and redirects, and read the title, description, logo and LinkedIn link. Also names companies that are not in the entity index. Turn off for an index-only lookup that is much faster.

## `includeUnresolved` (type: `boolean`):

Also output rows for domains where no company was found (free, not charged).

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

How many domains to check in parallel.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "https://www.notion.so",
    "jane@personio.de",
    "rivian.com",
    "delta.com"
  ],
  "checkHomepage": true,
  "includeUnresolved": true,
  "maxConcurrency": 20
}
```

# Actor output Schema

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

No description

## `details` (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 = {
    "domains": [
        "stripe.com",
        "https://www.notion.so",
        "jane@personio.de",
        "rivian.com",
        "delta.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wrenfield-data/domain-to-company").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": [
        "stripe.com",
        "https://www.notion.so",
        "jane@personio.de",
        "rivian.com",
        "delta.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("wrenfield-data/domain-to-company").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": [
    "stripe.com",
    "https://www.notion.so",
    "jane@personio.de",
    "rivian.com",
    "delta.com"
  ]
}' |
apify call wrenfield-data/domain-to-company --silent --output-dataset

```

## MCP server setup

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

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/nVxdOdcEhlAF8eCSe/builds/fxXCuzWrVmn3cmRSz/openapi.json