# Bulk Company Name to Domain Finder — Website, Logo & Match (`haketa/bulk-company-domain`) Actor

Turn a list of company names into their website domains in bulk. For each company get the domain, resolved name, logo, favicon and alternative matches — with a DNS fallback so it resolves companies others miss. Fast, keyless company-to-domain resolver for lead enrichment and CRM.

- **URL**: https://apify.com/haketa/bulk-company-domain.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 71 total users, 33 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Bulk Company Name to Domain Finder — Website, Logo & Match

Turn a list of **company names into their website domains** — in bulk. Paste a list and get, for each company: the **domain, the matched company name, a logo, a favicon and alternative matches**, with a **DNS fallback** so it still resolves companies most tools miss.

Fast, **keyless** and built for scale — the missing link that turns a plain company list into something you can actually reach and enrich.

***

### Why this Actor?

A spreadsheet full of company names is hard to work with — you can't visit them, enrich them or match them to a CRM until you know their **domain**. Looking each one up by hand is slow, and most tools need an API key and a subscription. This Actor resolves them in **bulk**, keyless, and returns a clean table:

- **Domain** — the company's primary website.
- **Matched name** — the canonical company name behind the match.
- **Logo & favicon** — ready‑to‑use brand images.
- **Alternative domains** — other likely matches when a name is ambiguous.
- **DNS check** — confirmation that the domain actually resolves.

And when a small or local company isn't in any directory, a **DNS‑guess fallback** tries sensible domains and keeps one only if it really resolves — so you get answers others don't.

***

### What you can do with it

- **Lead & CRM enrichment** — turn company names from a form, event or list into domains you can enrich further.
- **Sales prospecting** — get the website for every account on your target list.
- **Data cleaning & matching** — attach a canonical domain to messy company‑name data for deduplication and joins.
- **Firmographic pipelines** — the first step before pulling contacts, tech stack, DNS or metadata by domain.
- **Brand assets** — grab logos and favicons for a set of companies.

***

### What you get — output fields

One record per company:

| Field | Description |
| --- | --- |
| `companyName` | The name you supplied |
| `domain` | The resolved website domain |
| `resolvedName` | The matched (canonical) company name |
| `logo` | Company logo URL |
| `faviconUrl` | Favicon URL |
| `source` | How the domain was found (`directory` or `dns-guess`) |
| `alternativeDomains` | Other likely matches |
| `dnsResolves` | Whether the domain resolves in DNS |
| `error` | Populated if no domain could be found |
| `scrapedAt` | ISO timestamp |

***

### Example output

```json
{
  "companyName": "Stripe",
  "domain": "stripe.com",
  "resolvedName": "Stripe",
  "logo": "https://logo.example/stripe.com",
  "faviconUrl": "https://www.google.com/s2/favicons?domain=stripe.com&sz=64",
  "source": "directory",
  "alternativeDomains": "stripes.com, stripes.co",
  "dnsResolves": "true",
  "scrapedAt": "2026-07-10T15:00:00.000Z"
}
```

```json
{
  "companyName": "Acme Plumbing Chicago",
  "domain": "acmeplumbingchicago.com",
  "source": "dns-guess",
  "dnsResolves": "true",
  "faviconUrl": "https://www.google.com/s2/favicons?domain=acmeplumbingchicago.com&sz=64"
}
```

***

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `companyNames` | array | — | **Required.** Company names to resolve. |
| `verifyDns` | boolean | `true` | Check that the matched domain resolves. |
| `dnsGuessFallback` | boolean | `true` | Guess a domain when no match is found (kept only if it resolves). |
| `maxConcurrency` | integer | `10` | Companies resolved in parallel. |
| `proxyConfiguration` | object | off | Apify Proxy for very large lists. |

#### Basic run

```json
{
  "companyNames": ["Stripe", "OpenAI", "Shopify", "Airbnb"]
}
```

#### Strict (matches only, no guessing)

```json
{
  "companyNames": ["Some Company", "Another Company"],
  "dnsGuessFallback": false
}
```

***

### Use cases in detail

#### 1. Enrich a lead list

You have company names but no websites. Run them through and get a domain per company — the key you need to pull contacts, tech stack, DNS records or metadata next.

#### 2. Match to your CRM

Attach a canonical domain to each company name so you can dedupe and join records reliably, even when names are written inconsistently.

#### 3. Sales prospecting

Get the website for every account on your list, plus a logo and favicon for a polished view.

#### 4. Handle small & local businesses

The DNS‑guess fallback finds domains for smaller companies that directories don't cover — and only keeps a guess if it actually resolves, so you're not left with dead links.

#### 5. Feed downstream enrichment

Use the resolved domain as input to contact, tech‑stack, DNS or metadata tools to build a full company profile.

***

### How to use it

1. Click **Try for free**.
2. Paste your company names.
3. (Optional) Toggle the DNS options or concurrency.
4. Click **Start**.
5. Export as **JSON, CSV, Excel** or **HTML table**, or via the Apify API.

***

### Calling from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "companyNames": ["Stripe", "OpenAI", "Shopify"] }'
```

Fetch the results (JSON or CSV):

```bash
curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs/last/dataset/items?token=YOUR_APIFY_TOKEN&format=csv"
```

***

### Tips for the best results

- **Use the fullest name you have** — "Deutsche Bank AG" resolves better than "DB".
- **Keep `verifyDns` on** to filter out matches that don't actually resolve.
- **Turn `dnsGuessFallback` off** if you only want confident directory matches.
- **Check `alternativeDomains`** when a name is common — the right domain may be there.
- **Feed the `domain` output** into a contact, tech‑stack or metadata tool for full enrichment.

***

### Frequently asked questions

**How accurate is it?**
Well‑known companies resolve very reliably. Ambiguous or very generic names can match the wrong entity — `alternativeDomains` and `dnsResolves` help you verify.

**What is the DNS‑guess fallback?**
When a company isn't found in the directory, the Actor builds a likely domain from the name and keeps it **only if it resolves in DNS** — so guesses are always live domains, never dead links.

**Does it work for non‑US companies?**
Yes — it resolves country domains too (e.g. `.de`, `.co.uk`, `.se`).

**How many companies can it handle?**
From a handful to millions, processed in parallel.

**Do I need an API key?**
No. Just paste your company names and run.

**In which format can I export?**
JSON, CSV, Excel, HTML table, or via the Apify API.

***

### Notes

This Actor resolves publicly known company‑to‑website associations. Matches are best‑effort; verify important ones with the `dnsResolves` and `alternativeDomains` fields. Use the results in line with applicable terms and laws.

***

### Support

Need extra fields (e.g. industry, size, social links) or higher throughput? Open an issue from the Actor's page and describe what you need.

# Actor input Schema

## `companyNames` (type: `array`):

Paste your list of company names — one per line. Each name is resolved to its website domain, logo and best match. Handles anything from a handful to millions. Leave empty to run a quick sample of well-known companies so you can preview the output.

## `verifyDns` (type: `boolean`):

Double-check that each matched domain is actually live in DNS, and report it in the DNS OK column. Great for filtering out dead or parked domains.

## `dnsGuessFallback` (type: `boolean`):

When no match is found, intelligently guess the domain from the company name and keep it only if it is live. Boosts coverage for smaller or newer companies.

## `maxItems` (type: `integer`):

Cap the total number of companies to resolve. Set to 0 for no limit (process your entire list). Handy for a quick test run.

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

How many companies to resolve in parallel. Higher is faster; lower is gentler.

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

Apify Proxy. Off by default. Enable to rotate IPs on very large lists.

## Actor input object example

```json
{
  "companyNames": [
    "Stripe",
    "OpenAI",
    "Shopify",
    "Airbnb",
    "Deutsche Bank"
  ],
  "verifyDns": true,
  "dnsGuessFallback": true,
  "maxItems": 100,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Download all resolved company records (company name, domain, logo, matches).

## `companyName` (type: `string`):

The input company name

## `domain` (type: `string`):

Resolved website domain

## `resolvedName` (type: `string`):

Matched company name

## `logo` (type: `string`):

Company logo URL

## `faviconUrl` (type: `string`):

Favicon URL

## `source` (type: `string`):

How the domain was found (directory or dns-guess)

## `alternativeDomains` (type: `string`):

Other possible matches

## `dnsResolves` (type: `string`):

Whether the domain resolves in DNS

## `error` (type: `string`):

Error, if any

## `scrapedAt` (type: `string`):

Timestamp

# 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 = {
    "companyNames": [
        "Stripe",
        "OpenAI",
        "Shopify",
        "Airbnb",
        "Deutsche Bank"
    ],
    "maxItems": 100,
    "maxConcurrency": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/bulk-company-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 = {
    "companyNames": [
        "Stripe",
        "OpenAI",
        "Shopify",
        "Airbnb",
        "Deutsche Bank",
    ],
    "maxItems": 100,
    "maxConcurrency": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/bulk-company-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 '{
  "companyNames": [
    "Stripe",
    "OpenAI",
    "Shopify",
    "Airbnb",
    "Deutsche Bank"
  ],
  "maxItems": 100,
  "maxConcurrency": 10
}' |
apify call haketa/bulk-company-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/bulk-company-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/tMPUyIxvSchXghUFC/builds/nsShCDF90yCNE1KIc/openapi.json