# 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
- **Features:** Limited permissions
- **Stats:** 202 total users, 48 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars
## 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?
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
Bulk Company Name to Domain Finder — Website, Logo & DNS Match
Turn messy lists of company names into verified website domains, canonical brand names, logos, favicons, and alternative domain matches in bulk — 1,000+ companies in seconds, keyless and no coding required.
***
### ⚡ At a glance
| Feature | Details |
|---|---|
| **Primary Function** | Bulk Company Name → Website Domain (`domain`), Canonical Name (`resolvedName`), Logo & Favicon Resolver |
| **Resolution Engine** | Two-stage lookup: Global Company Directory Matching + Smart Legal-Suffix Stripping & Live DNS Fallback |
| **DNS Verification** | Optional live `A` / `AAAA` DNS resolution check (`verifyDns: true`) reported in `dnsResolves` |
| **Brand Assets** | Ready-to-use `logo` URL and 64px `faviconUrl` for every resolved domain |
| **Throughput & Scale** | Parallel worker pool (`maxConcurrency` up to `30`) — resolves **500+ companies in ~4 seconds** and scales to **1,000–1,000,000+ names** |
| **Zero-Input Ready** | Empty run `{}` automatically resolves a built-in benchmark list of **100 global companies** |
| **Export & Sync** | Dataset (JSON, CSV, Excel, HTML) + automatic `OUTPUT` Key-Value Store mirror for `run-sync` API calls |
***
**Turn a messy list of company names into clean, verified website domains — in bulk, keyless, and with no coding.** This **company name to domain finder** takes any list of raw company names and resolves each one to its primary **website domain**, canonical matched company name, **logo URL**, **favicon URL**, likely **alternative domains**, and a **live DNS check** confirming that the domain is active. It is the foundational first step in any **B2B data enrichment**, CRM deduplication, or outbound sales pipeline.
Whether you need to **find company domains** for 20 target accounts from a conference badge scan or resolve **10,000+ company names** for an enterprise data warehouse, this **bulk company domain scraper** processes your list in parallel and outputs one flat, join-ready record per company.
Export results directly to **JSON, CSV, Excel, HTML, or the Apify API**.
> Built for **RevOps and CRM administrators, SDR and outbound sales teams, B2B growth marketers, data engineers, lead-enrichment pipelines, M\&A analysts, and recruiters** who have company names and need the exact domains behind them.
***
### 🔎 Why resolve company names to website domains?
A spreadsheet containing only **company names** is nearly impossible to enrich or automate reliably. In modern B2B intelligence, **the website domain is the universal primary key**:
- Email finders and pattern generators require `domain` (`@stripe.com`) to discover decision-maker addresses.
- Firmographic, technographic, and traffic tools index accounts by root domain, not free-text company name.
- CRMs like Salesforce, HubSpot, and Pipedrive rely on the company domain to prevent duplicate account records when reps type `"Stripe"`, `"Stripe, Inc."`, or `"Stripe Payments"`.
Doing company-to-domain lookups manually is slow and error-prone, while traditional enterprise enrichment APIs charge steep per-credit fees and require paid API keys. Worse, raw company lists from trade shows, government registries, LinkedIn exports, or procurement tables are full of legal suffixes (`Inc.`, `LLC`, `GmbH`, `Ltd.`, `S.A.`, `B.V.`, `Holdings`, `Group`), diacritics, and inconsistent casing.
This **bulk company domain resolver** solves all of those challenges automatically:
1. **Directory Matching (`source: "directory"`):** Queries a global business directory to match the company name to its primary corporate domain, canonical display name, logo, and up to 4 alternative candidate domains.
2. **Smart DNS-Guess Fallback (`source: "dns-guess"`):** When a niche, regional, or newly launched company isn't in the directory, the Actor strips legal suffixes (`Inc`, `GmbH`, `Ltd`, `Corp`, etc.), normalizes diacritics, tests candidate domains across `.com`, `.io`, `.co`, and `.net`, and keeps a match **only if it resolves live in DNS**.
3. **Live DNS Verification (`verifyDns: true`):** Confirms via IPv4 (`A`) and IPv6 (`AAAA`) DNS lookups that the resolved domain is live on the internet, flagging dead or unconfigured domains in the `dnsResolves` column.
#### Common reasons teams use this company-to-domain finder
- **B2B lead & CRM enrichment** — convert raw company names from webinar sign-ups, badge scans, or scraped directories into verified domains ready for email discovery.
- **Salesforce & HubSpot deduplication** — map variations like `"Airbnb Inc"`, `"Airbnb"`, and `"Airbnb UK Ltd"` to `airbnb.com` so account hierarchies merge cleanly.
- **Outbound sales & ABM prospecting** — chain this Actor with an Email Finder or Website Contact Scraper to turn a list of target employers into verified decision-maker emails.
- **Procurement, KYB & vendor master cleaning** — attach live domains and DNS status to ERP vendor lists and financial counterparty tables.
- **Competitor & portfolio intelligence** — turn VC portfolio lists, conference exhibitor lists, or chamber-of-commerce directories into structured website tables.
- **Internal dashboards & UI enrichment** — pull instant `logo` and `faviconUrl` assets for hundreds of customer or competitor brands in one batch call.
***
### ✨ What this bulk company domain finder does
- ✅ **Unlimited batch scale (1 to 1,000,000+ names)** — paste a handful of companies or pass thousands via API; `maxItems: 0` (default) processes your entire de-duplicated input list with zero artificial caps.
- ✅ **Two-stage resolution (`directory` + `dns-guess`)** — combines high-precision company directory matching with a DNS-verified slug fallback so smaller and newer companies still resolve accurately.
- ✅ **Live DNS resolution check (`verifyDns`)** — verifies every matched domain against real DNS (`A` and `AAAA` records with a 5-second timeout) and reports `"true"` or `"false"` in `dnsResolves`.
- ✅ **Alternative domain candidates (`alternativeDomains`)** — when a brand name is shared by multiple entities or regional subsidiaries, the Actor returns up to 4 additional domains so you can inspect or disambiguate matches.
- ✅ **Automatic legal-entity normalization** — strips corporate suffixes (`Inc`, `LLC`, `Ltd`, `Limited`, `GmbH`, `Corp`, `Corporation`, `Company`, `Group`, `Holdings`, `PLC`, `SA`, `SE`, `AG`, `BV`, `NV`, `SRL`) and folds accented characters during fallback resolution.
- ✅ **Live brand imagery (`logo` & `faviconUrl`)** — returns a live icon/logo URL and a 64px Google Favicon URL for every resolved domain.
- ✅ **High-speed parallel execution** — configurable `maxConcurrency` (1–30, default `10`) with automatic exponential backoff on rate limits (`HTTP 429`).
- ✅ **100-company zero-input benchmark** — run with empty input `{}` to immediately test a built-in list of 100 global enterprises across tech, finance, retail, and industrials.
***
### 🎯 High-value use cases
| Team / Role | Workflow | Key fields used |
|---|---|---|
| **RevOps & CRM Admins** | Standardize messy account names into a canonical `domain` join key to eliminate duplicate CRM accounts. | `companyName`, `domain`, `resolvedName`, `dnsResolves` |
| **SDRs & Outbound Agencies** | Resolve conference attendee company names into domains, then pipe `domain` into an Email Extractor. | `companyName`, `domain`, `alternativeDomains`, `source` |
| **Data & Analytics Engineers** | Run automated batch domain resolution inside ETL pipelines before firmographic enrichment. | `companyName`, `domain`, `source`, `dnsResolves`, `error` |
| **Product & Frontend Teams** | Populate customer/partner directory UIs with verified domains, logos, and favicons. | `resolvedName`, `domain`, `logo`, `faviconUrl` |
| **VC, PE & Market Researchers** | Turn lists of private startups or acquisition targets into live URLs and check which domains are active. | `companyName`, `domain`, `dnsResolves`, `alternativeDomains` |
***
### 📥 Input configuration
All input fields are optional. Paste one company name per line in the Console UI or pass a JSON array via the Apify API.
| Field | Type | Default / Prefill | Description |
|---|---|---|---|
| `companyNames` | `array` | 20 prefilled companies | List of company names to resolve (one per line). Supports from 1 to 1,000,000+ names. Leave empty to run a 100-company global benchmark sample. |
| `verifyDns` | `boolean` | `true` | Perform a live DNS lookup (`A`/`AAAA`) on each matched domain and report the result in `dnsResolves` (`"true"` / `"false"`). |
| `dnsGuessFallback` | `boolean` | `true` | When no directory match is found, normalize the company name and test `.com`, `.io`, `.co`, and `.net` in DNS, keeping the first live domain. |
| `maxItems` | `integer` | `0` (prefill `100`) | Cap the total number of companies resolved. Set `0` (default) for unlimited — processes your entire `companyNames` list. |
| `maxConcurrency` | `integer` | `10` | Number of companies resolved in parallel (`1`–`30`). Increase to `20`–`30` for 1,000+ company lists. |
| `proxyConfiguration` | `object` | `{ "useApifyProxy": false }` | Optional Apify Proxy configuration. Off by default; enable IP rotation only for massive multi-thousand-row batches. |
#### Example 1 — Standard company-to-domain lookup
```json
{
"companyNames": [
"Stripe",
"OpenAI",
"Shopify",
"Airbnb",
"Deutsche Bank",
"Snowflake",
"Atlassian"
],
"verifyDns": true,
"dnsGuessFallback": true
}
```
#### Example 2 — High-throughput 1,000+ company batch run (`maxItems: 0`)
```json
{
"companyNames": [
"Stripe, Inc.",
"Datadog",
"Cloudflare",
"Siemens AG",
"MercadoLibre"
],
"verifyDns": true,
"dnsGuessFallback": true,
"maxItems": 0,
"maxConcurrency": 25
}
```
#### Example 3 — Strict directory-only matching (disable DNS guessing)
```json
{
"companyNames": [
"Toyota",
"Unilever",
"Salesforce"
],
"verifyDns": true,
"dnsGuessFallback": false
}
```
***
### 📤 Output schema & field reference
The Actor pushes **one flat JSON record per unique input company name** to the Apify Dataset and mirrors `{ count, companies }` to the `OUTPUT` Key-Value Store record.
#### Sample output — Directory match (`source: "directory"`)
```json
{
"companyName": "Stripe",
"domain": "stripe.com",
"resolvedName": "Stripe",
"logo": "https://icons.duckduckgo.com/ip3/stripe.com.ico",
"faviconUrl": "https://www.google.com/s2/favicons?domain=stripe.com&sz=64",
"source": "directory",
"alternativeDomains": "stripersonline.com, stripes.com, stripes.co, stripesgroup.com",
"dnsResolves": "true",
"error": "",
"scrapedAt": "2026-11-08T15:20:12.455Z"
}
```
#### Sample output — Smart DNS-guess fallback (`source: "dns-guess"`)
```json
{
"companyName": "Ernst & Young LLP",
"domain": "ernstyoung.com",
"resolvedName": "",
"logo": "https://icons.duckduckgo.com/ip3/ernstyoung.com.ico",
"faviconUrl": "https://www.google.com/s2/favicons?domain=ernstyoung.com&sz=64",
"source": "dns-guess",
"alternativeDomains": "",
"dnsResolves": "true",
"error": "",
"scrapedAt": "2026-11-08T15:20:12.455Z"
}
```
#### 🏢 Output Fields & Coverage
| Field | Type | Coverage | Description |
|---|---|---|---|
| `companyName` | `string` | 🟢 High (100%) | Exact input company name provided (trimmed) — use as your primary join key back to your source table. |
| `domain` | `string` | 🟢 High (~99%) | Resolved primary website domain in lowercase (e.g., `"stripe.com"`). |
| `resolvedName` | `string` | 🟢 High (~98% of directory hits) | Canonical company display name returned by the directory (`""` on `dns-guess` rows). |
| `logo` | `string` | 🟢 High (~99%) | Brand logo / icon URL for the resolved domain. |
| `faviconUrl` | `string` | 🟢 High (~99%) | 64×64 pixel favicon image URL for the resolved domain. |
| `source` | `string` | 🟢 High (100%) | Resolution method: `"directory"`, `"dns-guess"`, or `"none"` (if unresolved). |
| `alternativeDomains` | `string` | 🟡 Conditional (~85–95%) | Up to 4 comma-separated alternative domains returned by the directory when multiple entities match. |
| `dnsResolves` | `string` | 🟢 High (~99%) | `"true"` or `"false"` indicating whether the domain resolved in live DNS (`""` if `verifyDns: false`). |
| `error` | `string` | 🟢 High (100%) | Empty string `""` when resolved; `"no domain found"` if neither directory nor DNS fallback matched. |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO 8601 timestamp of the batch run. |
***
### 🔁 Batch pagination, deduplication & 1,000+ scale
Because this is a **bulk company name resolver**, scale is governed directly by your `companyNames` input list:
1. **Automatic input deduplication:** Duplicate company names in `companyNames` are automatically collapsed before resolution so you never pay twice for the same company.
2. **No hidden result limits (`maxItems: 0`):** By default, `maxItems` is `0` (unlimited), meaning whether you pass **100, 1,000, 10,000, or 100,000+ company names**, the Actor iterates through the entire list until every company is processed.
3. **High-speed concurrency pool:** Up to `30` workers resolve names and verify DNS records in parallel. A 500-company run completes in ~3.5–5 seconds, and a **1,000-company run finishes in ~8–12 seconds**.
4. **Built-in rate-limit resilience:** Each lookup includes automatic retry and backoff on `HTTP 429` responses, and optional `proxyConfiguration` support for massive enterprise jobs.
***
### ⚙️ How to use & automate
1. Open **Bulk Company Name to Domain Finder** in the Apify Console.
2. Paste your list of **Company names** (`companyNames`), one per line.
3. Keep `verifyDns: true` and `dnsGuessFallback: true` enabled for maximum accuracy and coverage.
4. Set `maxItems: 0` to process your entire list (or set a small number to test), and click **Start**.
5. Export your enriched table as **CSV, Excel, or JSON**, or connect the Actor to **Make, Zapier, n8n, Clay, HubSpot, Salesforce, or Google Sheets**.
#### Call via Apify API (cURL)
```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~bulk-company-domain/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"companyNames": ["Stripe", "OpenAI", "Shopify", "Airbnb", "Datadog"],
"verifyDns": true,
"dnsGuessFallback": true,
"maxItems": 0
}'
```
#### Python (`apify-client`) example
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("haketa/bulk-company-domain").call(run_input={
"companyNames": ["Stripe", "OpenAI", "Shopify", "Cloudflare", "Snowflake"],
"verifyDns": True,
"dnsGuessFallback": True,
"maxConcurrency": 20,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
print(f"{row['companyName']} -> {row['domain']} (source={row['source']}, dns={row['dnsResolves']})")
```
#### Node.js (`apify-client`) example
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('haketa/bulk-company-domain').call({
companyNames: [
'Stripe, Inc.',
'OpenAI',
'Shopify',
'Deutsche Bank AG',
'Atlassian',
'Datadog',
],
verifyDns: true,
dnsGuessFallback: true,
maxItems: 0,
maxConcurrency: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map(({ companyName, domain, resolvedName, source, dnsResolves }) => ({
companyName,
domain,
resolvedName,
source,
dnsResolves,
})));
```
#### Synchronous `run-sync` HTTP call (instant JSON response)
Because the Actor mirrors `{ count, companies }` to the `OUTPUT` Key-Value Store record, you can call `/run-sync` from Clay, n8n, Make, or any backend microservice and receive the resolved domains in a single HTTP request:
```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~bulk-company-domain/run-sync?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"companyNames": ["Stripe", "OpenAI", "Figma", "Notion", "Linear"],
"verifyDns": true
}'
```
***
### 🧩 How resolution works under the hood
| Step | Stage | What happens | Resulting `source` |
|---|---|---|---|
| **1. Input Normalization** | Deduplication | Trims whitespace, removes empty lines, and collapses exact duplicate strings in `companyNames`. | — |
| **2. Directory Lookup** | Primary Match | Queries the business directory for the company name, extracting the primary `domain`, `resolvedName`, `logo`, and up to 4 `alternativeDomains`. | `"directory"` |
| **3. Legal-Entity Slug Fallback** | Smart Fallback | If no directory match exists and `dnsGuessFallback: true`, strips legal suffixes (`Inc`, `LLC`, `GmbH`, `Ltd`, `PLC`, `SA`, `AG`, `BV`, `Corp`, etc.), folds accents, and tests `.com`, `.io`, `.co`, and `.net` in live DNS. | `"dns-guess"` |
| **4. Live DNS Check** | Verification | When `verifyDns: true`, verifies IPv4 (`A`) and IPv6 (`AAAA`) DNS records for the resolved domain and sets `dnsResolves` to `"true"` or `"false"`. | `"directory"` / `"dns-guess"` |
| **5. Brand Asset Attachment** | Enrichment | Populates `faviconUrl` (64px Google Favicon service) and ensures `logo` has a valid brand icon URL. | — |
***
### 🔌 B2B enrichment & CRM pipeline recipes
1. **Conference / Webinar Lead Enrichment (Google Sheets + Make/Zapier):**
- Trigger: New attendee row in Google Sheets with only `Full Name` and `Company Name`.
- Step 1: Call **Bulk Company Name to Domain Finder** to get `domain` (e.g., `datadoghq.com`).
- Step 2: Pass `Full Name` + `domain` into **Email Finder & Verifier** to get the verified work email.
2. **Salesforce / HubSpot Account Deduplication:**
- Export all CRM accounts missing a Website/Domain field.
- Run 5,000+ company names in one batch (`maxItems: 0`, `maxConcurrency: 25`).
- Group rows by the returned `domain` to merge duplicate CRM accounts and enrich logos.
3. **Clay / n8n Waterfall Enrichment:**
- Use `/run-sync` with batches of 50–200 company names as the first, lowest-cost step in your domain resolution waterfall before calling paid firmographic APIs.
***
### 💡 Pro tips for maximum match accuracy
- **Provide the clearest brand name available:** While the Actor strips legal suffixes (`Inc.`, `GmbH`, `Ltd.`) automatically during fallback, passing `"Deutsche Bank"` or `"Deutsche Bank AG"` is always much more specific than an ambiguous acronym like `"DB"`.
- **Inspect `alternativeDomains` for ambiguous names:** When a short company name (e.g., `"Delta"` or `"Mercury"`) belongs to multiple businesses across industries, the directory returns the top 4 alternative domains in `alternativeDomains`.
- **Use `dnsGuessFallback: false` for strict CRM matching:** If you prefer an empty `domain` over a heuristic slug guess when a small company is absent from the directory, set `dnsGuessFallback: false`.
- **Chain into downstream contact enrichment:** Once you have the `domain` column, pass those domains straight into **Email & Contact Extractor** or **Email Pattern Finder** to complete your B2B lead list.
***
### ⚠️ Honest limitations
- **Apex DNS vs. `www.`-only corporate domains:** A tiny fraction of legacy corporate domains (such as certain `.co.jp` or regional enterprises) configure DNS `A` records only on `www.domain` and not on the bare apex `domain`. In those rare cases, `domain` is still resolved accurately from the directory, while `dnsResolves` honestly reports `"false"` for the bare apex.
- **Highly generic or local DBA names:** A local unincorporated shop name (e.g., `"Main Street Pizza"`) may match a national brand or a guessed `.com` domain; use `source` and `resolvedName` to verify confidence.
***
### ❓ Frequently Asked Questions (FAQ)
#### Do I need an API key or paid subscription to Clearbit / ZoomInfo?
No. This Actor is completely **keyless** and self-contained. You only need your Apify account.
#### How many company names can I resolve in one run?
There is no upper limit when `maxItems` is set to `0` (the default). You can resolve **20, 1,000, 50,000, or 1,000,000+ company names** in a single batch run.
#### What happens if I run the Actor with empty input `{}`?
When `companyNames` is left empty, the Actor automatically runs a built-in benchmark of **100 well-known global companies** (or up to your `maxItems` limit) so you can inspect the exact output structure immediately.
#### How fast is a 1,000-company run?
At `maxConcurrency: 25`, resolving 1,000 company names with live DNS verification takes roughly **7 to 12 seconds**.
#### Does it support international (non-US) companies?
Yes. Directory matching covers global country-code TLDs (`.de`, `.co.uk`, `.fr`, `.nl`, `.se`, `.ch`, `.jp`, `.com.br`, `.in`, `.au`, etc.), and the slug normalizer handles European diacritics (`ä`, `ö`, `ü`, `ß`, `é`, `è`, `ñ`, etc.).
***
### 🔗 Related B2B enrichment & contact scrapers
Build a complete, end-to-end B2B outbound engine by combining this Actor with our contact and firmographic suite:
- [Email & Contact Extractor — Emails, Phones, Socials](https://apify.com/haketa/email-extractor) — crawl your resolved `domain` list to extract business emails, phone numbers, and social links.
- [Email Pattern Finder — Name + Domain to Business Email](https://apify.com/haketa/email-pattern-finder) — discover a company's email naming convention (`{first}.{last}@domain.com`).
- [Email Finder & Verifier — B2B Email Lookup API](https://apify.com/haketa/email-finder-verifier) — find and verify decision-maker email addresses from name + domain.
- [Bulk Email Verifier — MX, Disposable & Deliverability](https://apify.com/haketa/bulk-email-verifier) — validate email lists at scale before sending cold outreach.
- [Bulk Phone Number Validator — E.164, Carrier & Line Type](https://apify.com/haketa/bulk-phone-validator) — normalize and validate B2B phone numbers worldwide.
- [YCombinator Companies Scraper](https://apify.com/haketa/ycombinator-companies-scraper) — extract 5,900+ funded YC startups with domains, batch, stage, team size, and hiring status.
***
### 📋 Changelog
- **v1.2 (2026-11)** — Expanded prefill to 20 global companies for richer instant test runs, expanded zero-input `DEMO_COMPANY_NAMES` benchmark to **100 global companies**, added `OUTPUT` Key-Value Store mirroring (`{ count, companies }`) for `run-sync` API consumers, and verified 1,000+ batch resolution with zero artificial caps.
- **v1.1 (2026-10)** — Replaced deprecated logo endpoint with live high-availability brand icon resolution (`icons.duckduckgo.com` + Google 64px favicons) and added IPv6 (`AAAA`) DNS verification fallback.
- **v1.0 (2026-09)** — Initial release with parallel directory matching, legal-suffix slug normalization, `.com`/`.io`/`.co`/`.net` DNS-guess fallback, and live DNS verification.
# Changelog
This Actor's version history is a separate document: https://apify.com/haketa/bulk-company-domain/changelog.md
# 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",
"Toyota",
"Nestle",
"Spotify",
"Salesforce",
"Unilever",
"Datadog",
"Cloudflare",
"Snowflake",
"Atlassian",
"Figma",
"Notion",
"Canva",
"HubSpot",
"Twilio",
"Adyen"
],
"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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"companyNames": [
"Stripe",
"OpenAI",
"Shopify",
"Airbnb",
"Deutsche Bank",
"Toyota",
"Nestle",
"Spotify",
"Salesforce",
"Unilever",
"Datadog",
"Cloudflare",
"Snowflake",
"Atlassian",
"Figma",
"Notion",
"Canva",
"HubSpot",
"Twilio",
"Adyen"
],
"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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"companyNames": [
"Stripe",
"OpenAI",
"Shopify",
"Airbnb",
"Deutsche Bank",
"Toyota",
"Nestle",
"Spotify",
"Salesforce",
"Unilever",
"Datadog",
"Cloudflare",
"Snowflake",
"Atlassian",
"Figma",
"Notion",
"Canva",
"HubSpot",
"Twilio",
"Adyen",
],
"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",
"Toyota",
"Nestle",
"Spotify",
"Salesforce",
"Unilever",
"Datadog",
"Cloudflare",
"Snowflake",
"Atlassian",
"Figma",
"Notion",
"Canva",
"HubSpot",
"Twilio",
"Adyen"
],
"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 ` 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/3jyjGdSBz3UoUDUNF/openapi.json