# Company Domain Finder (`lowlanddata/company-domain-finder`) Actor Turn a bulk list of company names into their website domains, each with a confidence score. GDPR-clean (no personal data) and honest: an unsure lookup returns null and its alternatives, never a wrong domain. - **URL**: https://apify.com/lowlanddata/company-domain-finder.md - **Developed by:** [Lowland Data](https://apify.com/lowlanddata) (community) - **Categories:** Lead generation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $5.00 / 1,000 resolved domains 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 You have a list of company names — event sign-ups, a conference exhibitor list, a column of messy CRM rows — and none of it is useful until each name has a website. The domain is the key that unlocks everything after it: the logo, the socials, the email pattern, the enrichment. Getting there by hand is an afternoon of typing names into a search bar. This turns a list of company names into their domains, in bulk, and tells you how sure it is about each one. A well-known company resolves cleanly; an ambiguous or generic name comes back marked as such, with the alternatives it found, instead of a confident guess that sends your outreach to the wrong company. **It never returns a domain it cannot stand behind** — when it is not sure, it says so. Every field it returns is about the *company*, not a person: a domain, a website, a confidence score. No personal names, no personal emails, no contact people — that is a deliberate, permanent property of the tool, the same GDPR-first line the rest of this account holds. **Live health record:** [lowlanddata.com/status/company-domain-finder](https://lowlanddata.com/status/company-domain-finder/) - 30-day success rate and daily canary results, failures included. Full input/output reference: [tool page](https://lowlanddata.com/tools/company-domain-finder/). ### Quick start (30 seconds) 1. Paste your company names into **companyNames**, one per line. 2. If they are all from one country, put its two-letter code in **country** (e.g. `DE`, `FR`, `BE`) — it makes European companies resolve far more reliably. 3. Click **Start**. Each name comes back with a domain, a confidence score, a status, and any alternative domains it saw. Filter your results to `status = confirmed` for the ones you can trust blindly, and eyeball the `ambiguous` and `unconfirmed` rows — they carry the alternatives so you can pick in a second. ### What you can build with it - **Prime a lead list before enrichment.** You exported 500 company names from a conference app or Sales Navigator. Resolve them to domains here, then feed the domains into an email-finder or your CRM — the domain is the join key everything else needs. - **Fill the blank "website" column in a CRM.** Run the accounts with a missing domain through in one batch and write the confident matches straight back; review only the handful marked `ambiguous`. - **Deduplicate a company list.** Two rows that resolve to the same domain are the same company however differently their names were typed. - **Resolve a European book of business.** Set the `country` code and the national TLDs (`colruyt.be`, `doctolib.fr`) resolve where a US-centric tool guesses `.com` and misses. - **Wire it into an automation.** A Make/Zapier/n8n step, or an AI agent, that turns each new company name into a domain the moment it lands. ### What you get Each company name is one row: ```json { "companyName": "Back Market", "country": "FR", "domain": "backmarket.com", "website": "https://backmarket.com", "confidence": 0.9, "status": "confirmed", "alternativeDomains": ["back-market.com"], "matchedTitle": "Back Market - The refurbished tech marketplace", "source": "dns-guess", "checkedAt": "2026-09-25T10:00:00.000Z" } ``` Field notes, so you know exactly how much to trust each row: - `domain` is the canonical registrable domain, or **`null` when there is no confident match**. Null is the honest answer: a wrong domain quietly poisons everything downstream, so this tool would rather return nothing than guess. - `confidence` is 0 to 1. `0.9` means the domain resolved and its own homepage confirmed the company name. `0.75` means the homepage loaded and the domain carries the name. `0.5` means the domain resolves and matches but the homepage could not be read to confirm it. `0` is a no-match. - `status` is `confirmed`, `unconfirmed` (resolves but unconfirmed homepage), `ambiguous` (more than one domain matches the name — `alternativeDomains` holds the rest), or `no-match`. - `alternativeDomains` are the other domains that matched the name. On an `ambiguous` or `unconfirmed` row, the right answer is usually in here. - `matchedTitle` is the homepage title that confirmed the match, kept as evidence. ### How it resolves a name It builds the likely domains from the name and a country-aware set of TLDs (`.com` first everywhere, then the national TLD for European companies), keeps the ones that actually resolve in DNS, and confirms each by reading its homepage and matching the company name — following redirects to the canonical site. When several domains match, it prefers the canonical one (`.com` over the national TLD over `.io`) and lists the rest as alternatives. A domain whose own site does not carry the company name is never returned, even if it resolves. Well-known companies resolve very reliably. Ambiguous or very generic names (single common words, companies that trade under a different name than their domain) are where the confidence score and `alternativeDomains` earn their keep — read them rather than trusting the top row blindly. ### What does a company domain lookup cost? $5.00 per 1,000 **resolved** domains, and a name that comes back `no-match` is free — you pay only for answers, never for the misses. A run that resolves nothing costs the $0.00005 actor start and nothing else. - **A 500-name list, ~85% resolving ≈ $2.15**, once. - **A daily 50-name feed from a form or CRM ≈ $0.19/month.** The price is all-inclusive: platform usage and DNS/homepage traffic are covered, there is no separate compute bill, and failed runs are free. The Apify free plan returns a 5-item sample per run, enough to see the output shape against your own list before scaling up. ### Not technical? Let your AI assistant set it up Copy this into ChatGPT, Claude or any AI assistant, fill in the one line, and follow the conversation: ```text Help me set up the "Company Domain Finder" actor on Apify (https://apify.com/lowlanddata/company-domain-finder). Guide me one step at a time. What I have: [E.G. "a spreadsheet column of 200 German company names I need website domains for"] Guide me to: 1. Create a free Apify account (apify.com), open the actor page, and paste my company names into the companyNames field, one per line. 2. Set the country code if my list is all from one country (e.g. DE for Germany), so European companies resolve more reliably. 3. Start a run, then export the results as CSV or Excel, or read them from the API if I write code. 4. Explain the confidence and status columns so I know which rows I can trust blindly and which to double-check. 5. If it works, remind me to leave a quick rating on the actor page and to report anything wrong on its Issues tab. ``` ### Input | Field | Description | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | | `companyNames` | The company names to resolve, one per line. A single name is a batch of one. Required. | | `country` | Optional ISO 3166-1 alpha-2 code (e.g. `DE`, `FR`, `BE`, `US`) applied to every name. Biases the domain guesses toward that country's TLD. | | `maxItems` | Stop after this many names. Default 1000; free-plan runs are capped at 5. | ### Use it from your code Run it synchronously and read the resolved domains straight back: ```bash curl -X POST "https://api.apify.com/v2/acts/lowlanddata~company-domain-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"companyNames": ["Adyen", "Personio"], "country": "DE"}' ``` Larger lists run better asynchronously: start the run, let the finished-run webhook fire, then fetch the dataset. Schedules, webhooks and the Make/Zapier/n8n integrations all apply. This is a standard Apify actor. ### Use it with AI agents (MCP) Through Apify's hosted MCP server, Claude, Cursor and other MCP-capable agents can call this as a tool: the agent hands over the company names and reads the domains back, no glue code involved. Claude Code: ```bash claude mcp add apify --transport http "https://mcp.apify.com?actors=lowlanddata/company-domain-finder" ``` Cursor or Claude Desktop (add a custom connector / MCP server with this URL): ```text https://mcp.apify.com?actors=lowlanddata/company-domain-finder ``` Runs bill to the Apify account you sign in with. Per-client setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp). Prompts that work once connected: - "Resolve these 40 company names to their website domains and flag any you're not sure about." - "Find the domain for 'Back Market', and if there's more than one candidate, show me the alternatives." ### Is it legal to look up company domains? A company's domain, website and homepage title are public commercial information — this reads the public DNS and the public homepage of a business, nothing gated, nothing personal. No personal data enters the output by construction: there are no name, email or phone fields to fill, with or without any setting. Traffic is a handful of ordinary requests per name; no login, no CAPTCHA, nothing bypassed. ### Is there a company name to domain API? This is one. Send a list of names to `run-sync-get-dataset-items` and read the domains straight back as JSON, or run it on a schedule, or drive it as an MCP tool. It replaces the name-to-domain lookups that vanished when the old free autocomplete APIs moved behind enterprise products — same job, pay-per-result, no contract. ### How accurate is it? Well-known companies resolve very reliably; the honest limit is on ambiguous and generic names. Rather than paper over that with a single "98% accurate" number, every row carries its own confidence and status: a `confirmed` row was checked against the company's own homepage, and an uncertain one says so and hands you the alternatives. You decide the bar — trust `confirmed` blindly, glance at the rest — instead of trusting one average that hides the misses. ### How do I enrich a whole list of companies? Paste the whole list into `companyNames` (thousands is fine), set the `country` if they share one, and run it once. Export the dataset as CSV/Excel, or read it from the API, then join the `domain` column back onto your list on the company name. For a recurring feed — new form fills, new CRM rows — put it on a Schedule with a Make/Zapier/n8n or webhook step so each new name is resolved as it arrives. ### FAQ **Why does it sometimes return `null` instead of a domain?** Because it could not find a domain it is confident about. For a bulk pipeline a wrong domain is worse than a blank — it sends real outreach to the wrong company — so an uncertain lookup returns `null`, and where it can, the candidates it saw in `alternativeDomains`. **Does it return emails, phone numbers or contact people?** No, and not via any setting. It resolves the company's domain and website only. Personal data is never collected — that is what makes the output safe to store and share. **What does `ambiguous` mean?** More than one domain matched the name about equally (a `.com` and a national TLD, or a hyphenated variant). The primary is the best guess by canonical preference; `alternativeDomains` holds the others so you can pick in a glance. **Why is `country` worth setting?** European companies frequently live on their national TLD (`colruyt.be`, `doctolib.fr`) and share generic names across countries. The country code guesses the right TLD and disambiguates. **Can I export the results to Excel?** Yes: any dataset exports as Excel, CSV, JSON or XML from the Apify Console or API, the domain already in its own column. **How big a list can I send?** Up to 100,000 names in one run. Each is an independent lookup, so a large list simply takes longer. **Why did I only get 5 results?** The Apify free plan caps this actor at a 5-item sample. Any paid plan lifts the cap to your `maxItems`. **Can ChatGPT or Claude use it?** Yes: connect it through Apify's MCP server (section above) and an agent can hand over the names and read the domains back in one conversation. ### The company-identity family This is the entry point of a family of small, composable, GDPR-clean enrichment tools — the domain is the key that unlocks the rest, and each sibling takes the domain this tool resolves and adds one organisation-level layer, never anything personal: - [Company Logo & Favicon Finder](https://apify.com/lowlanddata/company-logo-finder) — a domain's favicon, logo and social image. - [Company Socials Finder](https://apify.com/lowlanddata/company-socials-finder) — a domain's LinkedIn, X, Instagram and more. - [EU Company VAT Finder](https://apify.com/lowlanddata/company-vat-finder) — the official EU VAT id behind a domain, VIES-validated. - [Company Email Security Checker](https://apify.com/lowlanddata/company-email-security) — a domain's SPF, DMARC, DKIM and email-spoofing grade. ### Troubleshooting Failures are loud and named in the run's status message: - **"Provide at least one company name."** `companyNames` was empty; add at least one name. - **"country must be an ISO 3166-1 alpha-2 code..."** Use the two-letter code (`DE`, not `Germany`). - **A row came back `no-match` you expected to resolve.** Check the spelling and set the `country`; the `alternativeDomains` field often holds the domain it saw but could not confirm. - **5 results instead of your maxItems**: the free-plan sample cap; a paid Apify plan removes it. ### Support Resolved a company wrong, or missing something you need? Open a report on the actor's **Issues tab**; this tool is actively maintained and reports get acted on. If it earns its keep, a **rating on this page** takes ten seconds, helps the next buyer find the GDPR-clean option, and tells us which enrichment tool to build next. # Actor input Schema ## `companyNames` (type: `array`): The company names to resolve to domains, one per line. A single name is a batch of one. ## `country` (type: `string`): ISO 3166-1 alpha-2 code (e.g. DE, FR, BE, US) applied to every name. It biases the domain guesses toward that country's TLD, so European companies resolve more reliably. Leave empty to guess the common TLDs. ## `maxItems` (type: `integer`): Stop after this many company names. Default 1000; free-plan runs are capped at 5. ## Actor input object example ```json { "companyNames": [ "Adyen", "Personio", "Back Market" ], "maxItems": 1000 } ``` # Actor output Schema ## `results` (type: `string`): One JSON object per company name, with its resolved domain and confidence. # 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": [ "Adyen", "Personio", "Back Market" ] }; // Run the Actor and wait for it to finish const run = await client.actor("lowlanddata/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "companyNames": [ "Adyen", "Personio", "Back Market", ] } # Run the Actor and wait for it to finish run = client.actor("lowlanddata/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 '{ "companyNames": [ "Adyen", "Personio", "Back Market" ] }' | apify call lowlanddata/company-domain-finder --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,lowlanddata/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 ` 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/njF29tiXm4hgcITls/builds/PZHU6opnUIQKZD34a/openapi.json