# Company Name to Domain: $1.50/1K Found, No Login (`conserving_celerytop/company-name-to-domain`) Actor

$1.50 per 1,000 domains found. Enter company names, get each company's official website domain, checked on the company's own homepage, with confidence, matched signals and rejected candidates. No search engine, no login. Misses are free.

- **URL**: https://apify.com/conserving\_celerytop/company-name-to-domain.md
- **Developed by:** [Don Mangu](https://apify.com/conserving_celerytop) (community)
- **Categories:** Lead generation, Business, 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 domain 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

## Company Name to Domain

Company Name to Domain turns a list of company names into each company's official website domain. For every name it checks the company's own homepage and returns the domain only when that homepage names the company. Each row comes with a confidence level, the signals that matched, and the domains that were looked at and turned down, so you can see why an answer was given. There is no search engine and no third-party company database behind it, and no login.

### What you can use a company domain finder for

- Clean a CRM or a spreadsheet where accounts have names but no websites.
- Add a website column to a list of trade show exhibitors, grant recipients or suppliers.
- Get a domain before you run other domain-based tools, such as a tech stack check or a site audit.
- Check that a domain you already have really belongs to the company.

### How to find company domains from names

1. Open the Actor and enter company names in **Company names**, one per line, for example `Acme Widgets Inc`.
2. If your companies are mostly in one country, enter its two-letter code in **Country** (for example `de` or `uk`). You can also set it per line: `Globex GmbH | de`.
3. Keep **Minimum confidence** at Medium for a clean list, or choose Low to see more partial matches.
4. Click **Start**. Download the results as CSV, Excel or JSON, or read them through the API.

### How much does it cost to find a company's domain?

You pay $1.50 per 1,000 domains found (the `domain-found` event). Companies with no match, invalid entries and errors are free. Platform usage is included.

Example: you enter 2,000 company names and 1,300 get a domain at Medium confidence or above. The run costs 1,300 x $0.0015 = $1.95. The 700 misses cost nothing. You can set a spending limit on the run, and the Actor stops cleanly when it is reached.

### Input example

```json
{
    "companies": ["Apify", "Stripe", "Hugging Face", "Globex GmbH | de"],
    "minConfidence": "medium"
}
```

Advanced options set the domain endings to try (default com, io, co, ai, net, org), how many domains to try and homepages to read per company, and how many companies run in parallel.

### Output example

```json
{
    "inputName": "Acme Widgets Inc.",
    "domain": "acmewidgets.com",
    "website": "https://acmewidgets.com/",
    "confidence": "high",
    "score": 100,
    "siteName": "Acme Widgets Inc.",
    "matchedSignals": [
        { "signal": "schemaOrg", "match": "exact", "value": "Acme Widgets Inc." },
        { "signal": "siteName", "match": "exact", "value": "Acme Widgets" },
        { "signal": "title", "match": "exact", "value": "Acme Widgets | Industrial widgets since 1990" }
    ],
    "otherMatches": [],
    "rejectedCandidates": [{ "domain": "acmewidgets.io", "reason": "parked_or_for_sale" }],
    "status": "found",
    "charged": true
}
```

The company above is a made-up example that shows the format; your results depend on the live sites. Other fields: `pageTitle`, `triedDomain`, `domainAliases`, `weakerMatchSkipped`, `domainsTried`, `homepagesRead`, `noDnsCandidates`, `checkedAt` and `error`. The `STATS` record in the key-value store has the run totals.

### Confidence levels

- **High**: the homepage names the company in its structured data, site name or title, usually in more than one place.
- **Medium**: the name appears clearly but in fewer places, or inside a longer name.
- **Low**: a partial match. Returned only when you choose Low.

Parked and for-sale domains, pages that redirect to a social network or a directory, and sites that do not mention the company are never returned.

### Related Actors

- Domain to LinkedIn Company Page: find the LinkedIn page a company links from its own website.
- Website Tech Stack Detector: see which tools a website uses.
- RDAP Domain Whois Lookup: registration dates and registrar for a domain.

### FAQ

**Is it legal?** The Actor reads only public homepages, one request per live candidate, with a user agent that names the tool and a contact address. It reads robots.txt first and skips any site that does not allow it. It does not collect email addresses, phone numbers or names of people.

**Why was my company not found?** The Actor finds domains that follow from the company name. A company whose domain has nothing to do with its name, or whose site blocks automated visits, will come back as not found, and you are not charged. Adding the country code often helps.

**Why is a well-known brand on a different domain?** If a domain redirects, the Actor follows the redirect and returns the final domain, and shows the domain it started from in `triedDomain`.

**Limits?** Up to 10,000 companies per run. Large lists run faster with more parallel companies.

Built by Don Mangu. Questions or a missing company: open an issue on the Actor page.

# Actor input Schema

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

Enter one company name per line, for example Acme Widgets Inc. Add a country code after a bar to try that country's domains first, for example Globex GmbH | de.

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

Enter a two-letter country code (de, uk, br) to try that country's domain endings first for every company.

## `tlds` (type: `array`):

Domain endings to try, in order. The default covers most company sites.

## `minConfidence` (type: `string`):

Return a domain only at this confidence or above. High: the homepage names the company in its structured data, site name or title. Low: a partial match.

## `maxCompanies` (type: `integer`):

Check at most this many companies in one run.

## `maxCandidates` (type: `integer`):

Check DNS for at most this many name-based domains per company.

## `maxHomepages` (type: `integer`):

Read at most this many live homepages per company.

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

Check this many companies at the same time.

## Actor input object example

```json
{
  "companies": [
    "Apify",
    "Stripe",
    "Hugging Face"
  ],
  "tlds": [
    "com",
    "io",
    "co",
    "ai",
    "net",
    "org"
  ],
  "minConfidence": "medium",
  "maxCompanies": 100,
  "maxCandidates": 12,
  "maxHomepages": 5,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

inputName, domain, website, confidence, score, siteName and status. The dataset also has matchedSignals, otherMatches, rejectedCandidates and more.

## `details` (type: `string`):

Every field per company.

## `stats` (type: `string`):

Companies checked, domains found by confidence, homepages read, statuses, and whether the spending limit stopped the run.

# 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": [
        "Apify",
        "Stripe",
        "Hugging Face"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/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": [
        "Apify",
        "Stripe",
        "Hugging Face",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/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": [
    "Apify",
    "Stripe",
    "Hugging Face"
  ]
}' |
apify call conserving_celerytop/company-name-to-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/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/M6UcTinFgioSPtGrL/builds/9rp0BlxQuMEojPzwf/openapi.json