# Company Name to Domain - Bulk Website Finder (`adyg/company-name-to-domain`) Actor

Find the official website domain for any list of company names. Bulk name-to-domain lookup with a confidence score, verified live homepage, LinkedIn URL, logo, favicon and alternatives. Clearbit Name-to-Domain alternative. Pay only for resolved companies.

- **URL**: https://apify.com/adyg/company-name-to-domain.md
- **Developed by:** [Adyanth Ganesh](https://apify.com/adyg) (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

from $1.00 / 1,000 company resolveds

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

## Company Name to Domain Finder - Bulk Website & Domain Lookup

**Turn a list of company names into official website domains.** Paste names (or a CSV export from your CRM) and get the best **official domain per company with a 0-100 confidence score**, a verified live homepage, the company's **LinkedIn URL**, **logo**, **favicon**, homepage title & description, redirects and alternative candidates.

A cheap, accurate **Clearbit Name-to-Domain API alternative** (Clearbit's free name-to-domain access was sunset in 2025). Built for lead generation, CRM cleanup, data enrichment, Clay / n8n / Make / Zapier workflows and AI agents.

- ✅ **Pay only for resolved companies** - companies without a confident match are free
- ✅ **Confidence score** on every result, plus alternatives so you can review edge cases
- ✅ **Verified**: the domain resolves, the homepage loads and mentions the company; parked and for-sale domains are rejected
- ✅ **Never returns directories**: LinkedIn, Crunchbase, Facebook, Wikipedia, Yelp, Bloomberg, ZoomInfo, etc. are filtered out
- ✅ **Hints for ambiguous names**: `Delta | airline`, `Bolt | Estonia`, `Joe's Pizza | Brooklyn`
- ✅ **Fast and cheap**: runs on 256 MB memory and resolves ~1,500 companies per hour by default (raise concurrency for more)

### How it works

For every company the Actor combines several independent signals and only returns a domain when they agree:

1. **Candidate sources** - free public company autocomplete (Clearbit), the official website recorded on **Wikidata** (property P856), and domain guesses from the name (e.g. `Warby Parker` → `warbyparker.com`).
2. **Web search fallback** - only when the free sources are not confident (Bing / DuckDuckGo via Apify Proxy, or Google via Apify's SERP proxy).
3. **Verification** - DNS lookup, homepage fetch with redirects, and fuzzy matching of the company name against the page title, `og:site_name`, schema.org Organization name and copyright line. Parked/for-sale pages, dead domains and aggregator sites are penalized; your country / city / industry hints are checked against the domain TLD and page text.
4. **Confidence score** - the signals are combined into a 0-100 score. Results below your `minConfidence` (default 60) are returned as `low_confidence` / `not_found` and are **not charged**.

No LinkedIn scraping and no login-protected data - only public sources and the companies' own homepages.

### Accuracy

Measured on hand-labelled test sets of company names with known domains (big brands, mid-size SaaS, non-US companies, ambiguous one-word names with a hint, small local businesses, and fake names that must return nothing):

| Test set | Companies | Returned at confidence ≥ 60 | Precision (correct / returned) |
|---|---|---|---|
| Development set | 68 | 66 (97%) | 100% |
| Hold-out set | 52 | 50 (96%) | 100% |
| Unseen final set | 41 | 39 (95%) | 97.4% |
| **All** | **161** | **155 (96%)** | **99.4%** |

At `minConfidence: 80` precision was 100% (152 of 161 returned). Measured on the Apify platform with default settings (Bing/DuckDuckGo fallback). The "not returned" rows are fake names (which must return nothing) and a few highly ambiguous one-word names.

Fake company names correctly returned nothing. Precision = share of returned domains that are the correct official domain. Raise `minConfidence` to 80 if you prefer fewer results with even fewer mistakes.

### Input

| Field | Description |
|---|---|
| `companies` | One company per line, optional hint after `|`: `Stripe`, `Delta | airline`, `Franklin Barbecue | Austin, TX` |
| `records` | JSON objects like `{"name": "Bolt", "country": "Estonia", "industry": "ride-hailing", "id": "crm-1"}` - returned in `inputRecord` |
| `csvData` | Paste CSV with a `name`/`company` column (plus optional `country`, `city`, `industry`) or headerless rows `name, hint...` |
| `country` | Default country for all rows, e.g. `Germany` or `DE` |
| `minConfidence` | 0-100, default 60 |
| `searchFallback` | `auto` (default), `always`, `never` |
| `searchEngine` | `bing` (Bing/DuckDuckGo, default) or `google` (Apify Google SERP proxy - best for small local businesses) |

Example input:

```json
{
    "companies": ["Stripe", "Spotify", "Delta | airline", "Mercury | banking for startups", "Franklin Barbecue | Austin, TX"],
    "records": [{ "name": "Bolt", "country": "Estonia", "industry": "ride-hailing", "id": "crm-123" }],
    "minConfidence": 60
}
```

### Output

One row per company. Example:

```json
{
    "input": "Mercury | banking for startups",
    "companyName": "Mercury",
    "status": "found",
    "domain": "mercury.com",
    "confidence": 97,
    "website": "https://mercury.com/",
    "companyNameFound": "Mercury",
    "title": "Online Business Banking For Startups, Small Businesses & Enterprises | Mercury",
    "description": "Mercury is banking built for startups ...",
    "linkedinUrl": "https://www.linkedin.com/company/mercuryhq",
    "logoUrl": "https://www.datocms-assets.com/.../mercury-logo.svg",
    "faviconUrl": "https://mercury.com/favicon.ico",
    "finalUrl": "https://mercury.com/",
    "redirectedFrom": null,
    "isLive": true,
    "httpStatus": 200,
    "sources": ["clearbit", "guess", "search"],
    "wikidataId": null,
    "alternatives": [
        { "domain": "mercuryinsurance.com", "confidence": 41, "sources": ["clearbit"], "title": "Mercury Insurance ...", "isLive": true, "isParked": false }
    ],
    "hint": { "text": "banking for startups" },
    "inputRecord": null,
    "error": null,
    "checkedAt": "2026-10-08T08:00:00Z"
}
```

`status` is one of:

- `found` - domain returned with confidence ≥ `minConfidence` (**charged**)
- `low_confidence` - a best guess exists but is below the threshold (see `bestGuess` and `alternatives`, **free**)
- `not_found` - nothing credible (**free**)
- `error` - the row failed after retries (**free**)

You can download the dataset as JSON, CSV, Excel or use the API. A run summary (counts, requests) is stored in the key-value store under `SUMMARY`.

### Pricing

This Actor uses **pay-per-event** pricing – you pay for successfully resolved companies, plus optional Google search charges when that fallback is enabled.

| Event | Price |
|---|---|
| Company resolved (`company-result`) | **$1.50 per 1,000 companies** ($0.0015 per company) |
| Actor start (`actor-start`) | $0.0001 per run |
| Google search (`google-search`) | $0.003 per search |

Companies that are not found, below your confidence threshold, or failed are **free**. Google search is billed only when you set the search fallback to Google (typically for less than half of companies). Platform usage (compute) is included. Set **Maximum cost per run** in the run options to cap your spend – the Actor stops cleanly at the limit.

### Tips

- **Add hints for short or common names.** `Square | payments`, `Front | customer service software`, `Joe's Pizza | New York`. A country hint also prefers that country's domain (`.de`, `.co.uk`).
- **Use records/CSV to keep your IDs.** Every output row carries your original record in `inputRecord`.
- **Small local businesses**: choose `searchEngine: google` for the best coverage.
- **Strict mode**: `minConfidence: 80` for near-zero false positives; `0` to get a best guess for everything.

### Related tools

Lead enrichment chain: company name → domain → contacts → tech stack → authority and traffic.

- [Website Contact Scraper](https://apify.com/adyg/website-contact-scraper): get emails, phone numbers and social links for each domain
- [Tech Stack Detector](https://apify.com/adyg/website-tech-stack-detector): see which CMS, ecommerce, analytics and CRM tools a site uses
- [Domain Authority & Traffic Checker](https://apify.com/adyg/domain-authority-traffic-checker): bulk domain authority, backlinks and organic traffic
- [ATS Jobs API (Greenhouse, Lever, Ashby, Workday)](https://apify.com/adyg/ats-jobs-api): pull every open job straight from company career sites

All of these are maintained by the same developer and export flat JSON, CSV or Excel, so you can feed one tool's dataset into the next.

### FAQ

**Is this a Clearbit Name to Domain / Autocomplete replacement?**
Yes - same job (company name in, domain out), plus a confidence score, verification of the live homepage, alternatives, LinkedIn URL and logo, and you can feed thousands of names in one run.

**How accurate is it?**
On our test sets 99.4% of returned domains were correct at the default threshold, and ~96% of companies were resolved. Big brands, funded startups and well-known local businesses resolve best; very small businesses with generic names need a city or industry hint.

**Do I pay for companies that are not found?**
No. Only rows with `status: found` are charged.

**Does it scrape LinkedIn?**
No. The LinkedIn URL is taken only from links on the company's own homepage.

**What about parked domains or companies that changed their domain?**
Parked/for-sale pages are rejected. Redirects are followed and the final domain is returned, with the original candidate in `redirectedFrom`.

**Can I call it from Clay, n8n, Make or Zapier?**
Yes - use the Apify integration or the Run Actor synchronously API endpoint and read the dataset items.

**Why is a well-known company returned with confidence below 100?**
Some corporate sites block automated visitors, so the homepage cannot be read. The domain is still returned when the other sources agree, with a slightly lower score.

# Actor input Schema

## `companies` (type: `array`):

One company per line. Optionally add a hint after a <code>|</code> to tell similar names apart: a city, country or industry, e.g. <code>Delta | airline</code>, <code>Franklin Barbecue | Austin, TX</code>, <code>Rossmann | Germany</code>. Legal suffixes like Inc, LLC or GmbH are handled automatically.

## `records` (type: `array`):

Optional. Company objects, e.g. <code>\[{"name": "Bolt", "country": "Estonia", "industry": "ride-hailing", "id": "crm-123"}]</code>. Recognized keys: <code>name</code>/<code>company</code>, <code>country</code>, <code>city</code>/<code>location</code>, <code>industry</code>/<code>category</code>, <code>hint</code>. The whole record is returned in <code>inputRecord</code> so you can join results back to your CRM.

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

Optional. Paste CSV (comma, semicolon or tab separated). With a header row, the column named <code>name</code>/<code>company</code> is used and <code>country</code>, <code>city</code>, <code>industry</code> columns become hints. Without a header, the first column is the company name and the other columns are used as hints.

## `country` (type: `string`):

Optional country applied to every company without its own country (name or 2-letter code, e.g. <code>Germany</code> or <code>DE</code>). Prefers that country's domains (e.g. .de) and companies registered there.

## `minConfidence` (type: `integer`):

A domain is returned (and charged) only when its confidence score is at least this value. Default 60 was ~98-100% precise on our test sets. Raise it to 80 for even fewer false positives; lower it to get more best guesses.

## `searchFallback` (type: `string`):

<b>Auto</b> (recommended): search the web only when the free sources are not confident enough. <b>Always</b>: search for every company (slower). <b>Never</b>: only Clearbit autocomplete, Wikidata and domain guesses.

## `searchEngine` (type: `string`):

<b>Bing / DuckDuckGo</b> via Apify Proxy. <b>Google</b> via Apify's Google SERP proxy gives the best results for small local businesses (only works on the Apify platform).

## `useClearbit` (type: `boolean`):

Use the free public Clearbit company autocomplete as one of the candidate sources.

## `useWikidata` (type: `boolean`):

Use the official website (P856) recorded on Wikidata as one of the candidate sources.

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

Also output a row (free of charge) for companies where no domain reached the minimum confidence, with the best guess and alternatives, so your output has one row per input.

## `maxAlternatives` (type: `integer`):

How many runner-up candidate domains to include (with their own confidence).

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

How many companies are resolved in parallel.

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

Proxy used for the web search fallback (Bing / DuckDuckGo). Homepages, Clearbit and Wikidata are fetched directly.

## Actor input object example

```json
{
  "companies": [
    "Stripe",
    "Spotify",
    "Shopify",
    "Siemens",
    "Patagonia",
    "Delta | airline",
    "Mercury | banking for startups"
  ],
  "minConfidence": 60,
  "searchFallback": "auto",
  "searchEngine": "bing",
  "useClearbit": true,
  "useWikidata": true,
  "includeUnresolved": true,
  "maxAlternatives": 3,
  "maxConcurrency": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `domains` (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 = {
    "companies": [
        "Stripe",
        "Spotify",
        "Shopify",
        "Siemens",
        "Patagonia",
        "Delta | airline",
        "Mercury | banking for startups"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("adyg/company-name-to-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 = {
    "companies": [
        "Stripe",
        "Spotify",
        "Shopify",
        "Siemens",
        "Patagonia",
        "Delta | airline",
        "Mercury | banking for startups",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("adyg/company-name-to-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 '{
  "companies": [
    "Stripe",
    "Spotify",
    "Shopify",
    "Siemens",
    "Patagonia",
    "Delta | airline",
    "Mercury | banking for startups"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call adyg/company-name-to-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,adyg/company-name-to-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/NrKgXtSEPqUot8Spf/builds/xvahid3zEi3Hdnvla/openapi.json