# Official Website Finder: Bulk Company Name to Domain Lookup (`data-done-right/official-website-finder`) Actor

Official website finder and bulk domain finder: paste company names, get each official domain. Company name to domain and company name to website lookup: find company website from name using Wikidata plus a homepage check, with a confidence label and MX flag. Pay only for confident matches.

- **URL**: https://apify.com/data-done-right/official-website-finder.md
- **Developed by:** [Data Done Right](https://apify.com/data-done-right) (community)
- **Categories:** Lead generation, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 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.
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

## Official Website Finder: Bulk Company Name to Domain Lookup

**Official website finder** for lists of company names. Paste names, get back each company's official domain and website, a confidence label, and a short note when the match is weak. It is a **company name to domain** and **company name to website** lookup built on public sources only: Wikidata (open data, CC0) plus a DNS and homepage check. No search engine is scraped.

You are charged only for rows labelled **high** or **medium**. Names that are not found, or only found with low confidence, are free.

### What does the bulk domain finder return?

For every name you enter you get one row, in the same order:

| Field | Meaning |
|---|---|
| `inputName` | The name as you typed it |
| `matchedName` | The Wikidata label or the site name the match is based on |
| `domain` | Registered domain of the official site (no `www`, no subdomain) |
| `website` | Homepage URL after redirects |
| `confidence`, `confidenceScore` | `high`, `medium`, `low` or `none`, and the 0 to 1 score behind it |
| `method` | `wikidata`, `dns-homepage` or `none` |
| `verified` | The homepage was read and the company name appears in its title, site name or headings |
| `title` | Homepage title |
| `wikidataId` | Wikidata Q-number when the method is `wikidata` |
| `mxFound` | The domain has MX (mail) records: `true`, `false`, or `null` (not checked or DNS failed) |
| `contactPageUrl` | Contact page linked from the homepage (optional) |
| `country` | Country from Wikidata, or your country hint |
| `note`, `error` | Why a row is weak, ambiguous, blocked or unusable |
| `charged`, `checkedAt` | Whether the row was billed, and when it was checked |

### How to find a company website from a name

1. Open the Actor and enter one company name per line (legal suffixes such as Inc, LLC or GmbH are fine).
2. Leave the defaults on, or switch on **Find the contact page** if you also want `contactPageUrl`.
3. Run it. Export the dataset as JSON, CSV or Excel, or call it from your own code.

#### Input example

```json
{
  "companies": ["Stripe", "Notion Labs", "Basecamp", "Linear", "Patagonia", "Hims & Hers"],
  "country": "",
  "verify": true,
  "checkMail": true,
  "includeContactPage": false,
  "maxCompanies": 500,
  "concurrency": 6
}
```

#### Output example

```json
{
  "inputIndex": 0,
  "inputName": "Stripe",
  "matchedName": "Stripe",
  "domain": "stripe.com",
  "website": "https://stripe.com/",
  "confidence": "high",
  "confidenceScore": 1.0,
  "method": "wikidata",
  "verified": true,
  "title": "Stripe | Financial Infrastructure to Grow Your Revenue",
  "wikidataId": "Q7624104",
  "mxFound": true,
  "contactPageUrl": null,
  "country": "United States",
  "note": null,
  "error": null,
  "charged": true,
  "checkedAt": "2026-10-25T12:00:00Z"
}
```

### How it works

1. **Wikidata.** The name is searched in Wikidata. Candidates must be organisations (company, business, brand, enterprise and similar classes, or a company-like description), must have an official website, and their label or alias must match your name. Family names, places, songs and software "by" someone are rejected. The official website is the best "official website" (P856) statement, not ended and not deprecated.
2. **DNS and homepage fallback.** When Wikidata gives nothing confident, the Actor guesses domains from the name (for example `hims-and-hers`, `himshers` on `.com`, `.io`, `.co`, `.ai`, `.app`, `.org`, `.net`, plus your country's ending), keeps the ones that resolve in DNS, opens their homepage and scores how well the page matches the name. Parked or for-sale pages, and social or directory sites, are rejected.
3. **Verification.** The homepage of the chosen domain is read (robots.txt respected, one page per site) and the name is looked for in the site name, page title, headings and text.

### How accurate is it?

Honest numbers from a local test on 64 company names (famous brands, small businesses, non-US companies and deliberately ambiguous names). The thresholds were tuned on the first 32; the other 32 were written down before the first run and then used for three small rule changes, so treat the second set as a mostly clean check, not a guarantee.

| Confidence | First set (32, tuned) | Second set (32, mostly held out) |
|---|---|---|
| high | 24 of 24 correct | 19 of 21 correct |
| medium | 6 of 6 correct | 3 of 4 correct |
| low | not billed | not billed |

Across both sets, 52 of 55 high and medium rows were right (94 percent), and 52 of the 60 names that have a known answer came back as high or medium (87 percent). Your own list will differ, especially for small local businesses. What the numbers do not tell you:

- **Wikidata covers companies that have a Wikipedia-level footprint**: large companies, well-known brands, funded start-ups and many notable small brands. A neighbourhood plumber or a bakery is usually not in it.
- **Small businesses depend on the DNS and homepage fallback**, which only finds a company whose domain is close to its name and whose homepage shows the name in the title or headings. Expect many local businesses to come back `none` or `low`. That is intentional: a wrong domain is worse than no domain.
- **Ambiguous names return low confidence or the wrong company.** "Linear" (the product-management app) was found, but a name like "Mercury", "Apple Records" or "Intercom" can point to a different organisation with the same name. When two organisations tie, the best one is marked down and the note says so. Add a legal suffix, a city or a country hint if you can.
- **Some big sites block automated requests** (HTTP 403 or 429). Their Wikidata match is kept, `verified` stays false and the note says why. The Actor does not try to get around bot protection.
- Wikidata can be out of date or have a different domain from the one you expect (a brand site instead of the corporate site, or the other way round).

#### How confidence is computed

- **Wikidata match:** 0.45 for the name match (identical, or the same apart from words such as "Labs", "Group", "Inc"), plus 0.20 when Wikidata's instance-of class says organisation (0.10 when only the description does), plus up to 0.15 when the domain name equals the brand. A verified homepage adds 0.20 (0.15 for a weaker match in headings or the first word of the name). A homepage that does not mention the name takes 0.10 away. A name that only matches the start of the Wikidata label, or a tie between organisations with different domains, is capped below medium.
- **DNS and homepage match:** up to 0.40 when the site name or a title segment equals the company name (less for a partial match), plus 0.30 when the domain equals the name, plus small bonuses for the heading, meta tags and `.com` or your country ending. Parked pages score zero. If two guessed domains both match, the result is capped at low.
- **Labels:** `high` is 0.80 or more, `medium` 0.60 or more, `low` 0.35 or more, otherwise `none`. If the homepage cannot be read, a guessed domain is never medium or high.

### How much does it cost?

You pay **$0.70 per 1,000 domains found** (the `domain-found` event, only for rows with confidence high or medium). Rows with confidence low or none, rows with an input error, and duplicate names in the same list are free. Platform usage is small: a typical row needs about 2 Wikidata requests and 3 to 4 page requests (robots.txt plus the homepage). Set **Max companies** to cap spending.

### Use cases

- Add a website column to a CRM export or lead list that only has company names.
- Turn a list of names into domains before running an email or tech-stack lookup.
- Check that supplier or investor lists point to the real company sites, with an MX flag to see which domains receive email.

### FAQ

**Does it use Google, Bing or another search engine?** No. It uses the Wikidata API and the company's own homepage only.

**Is the data legal to use?** Wikidata is released under CC0. Homepages are read with a plain request, one page per site, with robots.txt honoured. No login or bot protection is bypassed.

**Why do I get `none` for a company I know exists?** It is probably not in Wikidata and its domain does not look like its name, or its homepage blocks automated requests. Those rows are free.

**What does `verified: false` mean on a high row?** Wikidata matched strongly but the homepage could not be read (blocked, robots.txt, timeout) or does not show the name. The `note` field gives the reason.

**Can I send a domain instead of a name?** The Actor is for names. If a name looks like a domain (`stripe.com`), only the brand part is used.

**Does the contact page option crawl the site?** No. It reads the homepage you already checked and returns the contact link it finds there; it is `null` when the homepage has none.

### Use with AI agents / MCP

Call the Actor from an AI agent through the Apify MCP server or the Apify API: pass `companies` as a list of names and read the dataset rows. An agent can trust `high` rows, ask a human to confirm `medium` rows, and treat `low` or `none` as "not found". The `confidence`, `method`, `verified` and `note` fields explain every decision, so an agent does not need to guess.

### Related tools

- **Contact Page Finder**: finds the contact page and form of a website in depth.
- **Work Email Finder: Find Email by Name & Domain (No SMTP)**: next step once you have the domain.
- **Company Enrichment Tool & API**: a fuller profile of a company from its domain.

# Actor input Schema

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

Company names to look up, one per line, for example Stripe, Notion Labs or Patagonia. Legal suffixes (Inc, LLC, GmbH) are fine. Every name gets a result row; names with no confident match are free.

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

Two-letter country code such as DE, GB or FR. Adds that country's domain ending (de, co.uk, fr) to the guessed domains and is returned as the country of rows found by guessing. Leave empty for global companies.

## `verify` (type: `boolean`):

Open the homepage of the found domain (robots.txt respected) and check that the company name appears in the title, site name, headings or text. Raises or lowers the confidence. Sites that block automated requests stay unverified, but are not dropped.

## `checkMail` (type: `boolean`):

Add mxFound: true when the domain has mail (MX) records, false when it has none, null when the DNS lookup failed. DNS only, no email is sent.

## `includeContactPage` (type: `boolean`):

Also return contactPageUrl, the contact page that the homepage links to (contact, contact us, kontakt, contacto and similar). Null when the homepage has no such link. Reads the homepage only.

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

Hard cap on how many names from the list are processed; extra names are skipped. Also caps your cost.

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

How many companies are looked up at the same time. Requests to Wikidata are always limited to 2 at a time to stay polite.

## Actor input object example

```json
{
  "companies": [
    "Stripe",
    "Notion Labs",
    "Basecamp",
    "Linear",
    "Patagonia",
    "Hims & Hers"
  ],
  "verify": true,
  "checkMail": true,
  "includeContactPage": false,
  "maxCompanies": 10,
  "concurrency": 6
}
```

# Actor output Schema

## `results` (type: `string`):

One row per company name you entered: official domain and website, confidence, method, verification, MX flag and notes (all result items of this run, as JSON, CSV, Excel and more).

## `records` (type: `string`):

Key-value store records: the run summary (SUMMARY: counts by confidence and method, charged results, spending-limit flag).

# 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",
        "Notion Labs",
        "Basecamp",
        "Linear",
        "Patagonia",
        "Hims & Hers"
    ],
    "maxCompanies": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-done-right/official-website-finder").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",
        "Notion Labs",
        "Basecamp",
        "Linear",
        "Patagonia",
        "Hims & Hers",
    ],
    "maxCompanies": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("data-done-right/official-website-finder").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",
    "Notion Labs",
    "Basecamp",
    "Linear",
    "Patagonia",
    "Hims & Hers"
  ],
  "maxCompanies": 10
}' |
apify call data-done-right/official-website-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data-done-right/official-website-finder"
        }
    }
}
```

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/EJUhfI8mqQN8Ue0pb/builds/LPc5SXYExi53HP3JZ/openapi.json