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

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<string>	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

{
  "companyNames": [
    "Stripe",
    "OpenAI",
    "Shopify",
    "Airbnb",
    "Deutsche Bank",
    "Snowflake",
    "Atlassian"
  ],
  "verifyDns": true,
  "dnsGuessFallback": true
}

Example 2 — High-throughput 1,000+ company batch run (maxItems: 0)

{
  "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)

{
  "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")

{
  "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")

{
  "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)

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

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

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:

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 <slug>.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 — crawl your resolved domain list to extract business emails, phone numbers, and social links.
• Email Pattern Finder — Name + Domain to Business Email — discover a company's email naming convention ({first}.{last}@domain.com).
• Email Finder & Verifier — B2B Email Lookup API — find and verify decision-maker email addresses from name + domain.
• Bulk Email Verifier — MX, Disposable & Deliverability — validate email lists at scale before sending cold outreach.
• Bulk Phone Number Validator — E.164, Carrier & Line Type — normalize and validate B2B phone numbers worldwide.
• 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.