# Company Domain Finder: Company Name to Website, Logo, LinkedIn (`datagleaner/company-domain-finder`) Actor

Turn company names into official websites and domains, each checked on the company's own home page, with a confidence score, the method that found it, logo URL and LinkedIn page. $0.80 per 1,000 domains found; names not found are free.

- **URL**: https://apify.com/datagleaner/company-domain-finder.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Lead generation, Integrations, Automation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.80 / 1,000 website 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 Domain Finder: Company Name to Website, Logo & LinkedIn

**Turn a list of company names into official websites and domains.** Paste names (with a country or city if you have one), and get back each company's domain, website URL, a confidence score, the method that found it, its logo URL and its LinkedIn company page. Every website is checked on the company's own home page before it is returned, so directories, news articles and parked domains do not slip through.

**$0.80 per 1,000 domains found. Names that are not found are free.**

### What it does

For each company name, the Actor:

1. **Looks it up in open data.** Wikidata's "official website" record (CC0 open data) for companies with a public profile, matched on the name and checked against your country hint.
2. **Tries the domains the name spells.** `Blue Bottle Coffee` → `bluebottlecoffee.com`, `Joe's Pizza, New York` → `joespizzanyc.com`, plus your country's domain (`.de`, `.co.uk`, `.com.tw` and so on) and the `get…`/`use…`/`…hq` shapes. A guessed domain counts only when its own home page carries the company's name.
3. **Reads the top web results** when the first two leave the company unresolved or unsure, skipping directories, social networks, job boards and news sites.
4. **Verifies on the home page.** It opens each candidate, follows redirects to the final domain (`buttondown.email` → `buttondown.com`), rejects parked and for-sale pages, and checks that the site's title, `og:site_name` or structured data names the company.
5. **Scores and picks.** Sources that agree raise the score; a page that does not carry the name lowers it. You get the best match, a 0 to 0.99 confidence, a level (high, medium, low) and up to 3 alternatives.

From the chosen home page it also reads the company's **logo URL** (structured data, header logo or touch icon), its **LinkedIn company page** and its X/Twitter, Facebook, Instagram and YouTube links.

### Use cases

- **Lead lists that only have names.** Trade-show exhibitors, award lists, investor portfolios, CRM exports and spreadsheets of accounts: get the domain first, then the emails (see the pipeline below).
- **CRM hygiene.** Fill the missing `website` and `domain` fields on company records, with a confidence you can filter on.
- **Enrichment input.** Most enrichment tools key on a domain, not a name. This turns names into the key.
- **Logos and LinkedIn pages** for account lists, dashboards and pitch decks.
- **AI agents and automations** that need "the website of company X" as one clean API call.

### Measured hit rate

On a fixed set of 50 known companies of mixed size and country (15 large, 20 mid-size, 15 small, from 20 countries including Germany, Japan, Taiwan, Brazil, India, Poland, Indonesia and Hong Kong), run on the Apify platform on 22 October 2026:

| Company size | Companies | Correct website | Wrong website | Not found (free) |
|---|---|---|---|---|
| Large (Siemens, Toyota, Petrobras...) | 15 | 15 (100%) | 0 | 0 |
| Mid-size (Personio, KKday, Allegro...) | 20 | 20 (100%) | 0 | 0 |
| Small (Buttondown, Monmouth Coffee, Tim Ho Wan...) | 15 | 13 (87%) | 0 | 2 |
| **All** | **50** | **48 (96%)** | **0** | **2** |

All 48 returned websites were right (100% precision at the default floor of 0.5). 47 of the 48 rows carried a logo URL and 33 a LinkedIn company page. The run took 36 seconds for the 50 names. The two misses were companies listed under a legal name that differs from their brand (a `GmbH` and an `Inc` whose products go by another name); search them by brand name instead.

Most of these companies have a public open-data profile. Small local businesses without one depend on the name-based domains and web results, so expect a lower hit rate on long-tail lists; misses are free.

Correct means the returned domain is the company's own site (any of its official domains, such as `bosch.de` or `bosch.com`).

### Input

```json
{
  "companies": [
    "Stripe",
    "Robert Bosch, Germany",
    "Plausible Analytics",
    "Gogoro, Taiwan",
    "Joe's Pizza, New York"
  ],
  "country": "",
  "industry": "",
  "minConfidence": 0.5
}
```

- **companies**: one per line. A location after a comma or pipe tells same-named companies apart: `Bosch, Germany`, `Acme | Austin, US`. Legal forms (Inc, GmbH, Ltd, S.A., K.K.) are fine.
- **country** / **city**: optional hints for every name without its own.
- **industry**: optional, e.g. `software` or `coffee roaster`, to prefer the right match among same-named companies.
- **minConfidence**: a row is returned as found (and billed) only at or above this. Default 0.5; use 0.8 for high precision.
- **useWebSearch**: on by default; off is faster and finds fewer small companies.
- **datasetId**: read names from another Actor's dataset (fields `companyName`, `company`, `organization`, `businessName`, `name` or `title`).

Leave the input empty to run a built-in 3-company example.

### Output

One row per company, in the order they finish:

```json
{
  "input": "Gogoro, Taiwan",
  "companyName": "Gogoro",
  "found": true,
  "domain": "gogoro.com",
  "website": "https://www.gogoro.com/",
  "confidence": 0.99,
  "confidenceLevel": "high",
  "method": "wikidata+instant-answer+guess",
  "evidence": [
    "Wikidata Q19880591 (Gogoro: Taiwanese manufacturer of electric scooters and battery swapping infrastructure) lists it as the official website",
    "DuckDuckGo instant answer for 'Gogoro' gives it as the official site",
    "gogoro.com is registered and resolves",
    "home page names it ('Gogoro')"
  ],
  "homepageTitle": "Gogoro Global",
  "logoUrl": "https://cdn.gogoro.com/resources/pages/knowledge_graph_logo.png",
  "linkedinUrl": "https://www.linkedin.com/company/gogoro/",
  "socialLinks": {
    "twitter": "https://x.com/WeAreGogoro",
    "facebook": "https://www.facebook.com/gogoro",
    "instagram": "https://www.instagram.com/gogoro_taiwan/",
    "youtube": "https://www.youtube.com/channel/UChbmd1freKXd0VY0Qi-ibZg"
  },
  "wikidataId": "Q19880591",
  "description": "Taiwanese manufacturer of electric scooters and battery swapping infrastructure",
  "alternatives": [
    {
      "domain": "oddin.gg",
      "confidence": 0.29,
      "method": "wikidata"
    },
    {
      "domain": "gogoro.io",
      "confidence": 0.25,
      "method": "guess"
    },
    {
      "domain": "getgogoro.com",
      "confidence": 0.18,
      "method": "guess"
    }
  ],
  "country": "TW",
  "city": null,
  "industry": null,
  "webSearchUsed": false,
  "scrapedAt": "2026-10-22T01:11:49Z"
}
```

A company that is not found (or is below your confidence floor) gets a free row with `found: false`, `domain: null` and its best guesses in `alternatives`, so you can see why.

| Field | Meaning |
|---|---|
| `domain` | Registered domain, e.g. `bosch.de` (no `www`) |
| `website` | Home page URL after redirects |
| `confidence` | 0 to 0.99. 0.8+ high, 0.6+ medium, below that low |
| `method` | Which sources named this domain: `wikidata`, `instant-answer`, `search`, `guess`, joined with `+` |
| `evidence` | Plain-English reasons, including the home-page check |
| `logoUrl` | Logo from the company's own site, else its open-data logo |
| `linkedinUrl` | LinkedIn company page linked from the site, else from open data |
| `alternatives` | Up to 3 other candidate domains with their scores |

### Pricing

Pay per event: **$0.0008 per company whose website is found** ($0.80 per 1,000). Rows with `found: false` cost nothing, and there is no start fee. Apify platform usage is included.

Worked example: 2,000 names, 1,700 matched at the default confidence floor: 1,700 × $0.0008 = **$1.36**. The 300 misses are free.

Set **Max total charge** in the run options to cap any run.

### From company names to emails: run it with Website Email Finder

Most buyers want the people's emails, not just the domain. Run the two Actors back to back, all on Apify:

1. Run **Company Domain Finder** on your names.
2. Run Data Gleaner's **Website Email Finder & Contact Details Scraper** (`datagleaner/website-contact-details-scraper`) with this run's dataset as input:

```json
{ "datasetId": "<this run's default dataset ID>" }
```

It reads the `website` field of every found row and returns emails, phone numbers, social profiles and contact forms per site; rows with `found: false` have no website and are skipped. When a run finds at least one website, its status message and the `NEXT_STEP` record in its key-value store carry that input ready to paste.

To chain it automatically, open this Actor's **Integrations** tab, add "Run Actor" → `datagleaner/website-contact-details-scraper`, and set its input to `{"datasetId": "{{resource.defaultDatasetId}}"}`.

Cost for 1,000 names, 850 found, 600 with an email: 850 × $0.0008 + 600 × $0.002 = **$1.88**.

### Limits

- Companies with very common names and no location hint can match a same-named company; add a country or city, or raise `minConfidence`.
- Some sites block automated visits; those are checked by name and domain only and score lower.
- Brand-new companies with no web presence yet are not found (and not billed).
- It returns one main site per company; subsidiaries and country sites can appear in `alternatives`.

### FAQ

**Does it need an API key or a login?** No. It uses public open data, public web pages and the company's own home page.

**What does "verified" mean?** The candidate's own home page names the company (title, `og:site_name` or organisation structured data), it is not parked or for sale, and redirects are followed to the final domain.

**Can I feed it a spreadsheet?** Paste the name column into `companies`, or upload it as a dataset and pass `datasetId`.

**How fast is it?** 50 companies took 36 seconds on Apify with the default 10 in parallel, so 1,000 companies take roughly 10 to 15 minutes. Companies that need web search are slower, since search is paced politely.

**Why was a well-known company not found?** Usually a name shared by many companies with no hint. Add a country, city or industry and rerun just those rows; misses cost nothing.

### Responsible use

This Actor reads public web pages and open data about companies. It does not log in anywhere or collect personal data. You are responsible for how you use the results, including any obligations under data-protection and marketing laws where you operate.

### Feedback

If this Actor saved you time, a rating on its Store page helps others find it. Problems or requests: open an issue on the Issues tab.

# Actor input Schema

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

One company per line. Add a location after a comma or a pipe to tell same-named companies apart: `Bosch, Germany`, `Joe's Pizza, New York`, `Acme | Austin, US`. Legal forms like Inc, GmbH, Ltd or S.A. are fine. Leave empty to run a 3-company example.

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

Optional. A country name or ISO code (`DE`, `Japan`, `United Kingdom`) used for every name that has none of its own. It picks the right local site (bosch.de over bosch.com) and drops same-named companies from other countries.

## `city` (type: `string`):

Optional. A city used for every name that has none of its own. Helps with local businesses.

## `industry` (type: `string`):

Optional. A word or two about what the companies do (`software`, `coffee roaster`, `law firm`). Used to prefer the right match among same-named companies.

## `minConfidence` (type: `number`):

A website is returned (and billed) only when its confidence is at least this. 0.8 and above is high: an open-data record or a web result agrees with the company's own home page. Raise to 0.8 for precision, lower to 0.3 to see more guesses. Below the floor, the row is free and its best guesses are in `alternatives`.

## `useWebSearch` (type: `boolean`):

When open data and the name-based domains leave a company unresolved or only medium-confidence, read the top web results for it. Off makes runs faster and finds fewer small companies.

## `datasetId` (type: `string`):

Optional. Read company names from this dataset and add them to the list above. The first present field of `companyName`, `company`, `organization`, `businessName`, `name`, `title` is used, with `country` and `city` when present. In an integration use `{{resource.defaultDatasetId}}`.

## `datasetNameField` (type: `string`):

Optional. The dataset field that holds the company name, when it is not one of the usual ones. Tried first.

## `maxDatasetItems` (type: `integer`):

Stops reading the dataset after this many names.

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

How many companies are looked up at the same time.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each page or API answer.

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

Optional. Leave empty: requests go direct, and a home page or search that refuses the run is retried through Apify Proxy automatically. Set a proxy here only to send every request through it.

## Actor input object example

```json
{
  "companies": [
    "Stripe",
    "Robert Bosch, Germany",
    "Plausible Analytics",
    "Gogoro, Taiwan",
    "Blue Bottle Coffee"
  ],
  "minConfidence": 0.5,
  "useWebSearch": true,
  "maxDatasetItems": 1000,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 15
}
```

# Actor output Schema

## `results` (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",
        "Robert Bosch, Germany",
        "Plausible Analytics",
        "Gogoro, Taiwan",
        "Blue Bottle Coffee"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/company-domain-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",
        "Robert Bosch, Germany",
        "Plausible Analytics",
        "Gogoro, Taiwan",
        "Blue Bottle Coffee",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/company-domain-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",
    "Robert Bosch, Germany",
    "Plausible Analytics",
    "Gogoro, Taiwan",
    "Blue Bottle Coffee"
  ]
}' |
apify call datagleaner/company-domain-finder --silent --output-dataset

```

## MCP server setup

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