Company Domain Finder

Give it a list of company names and it returns the official website for each one, the social profiles that website publishes, a confidence score, and the candidate domains it rejected along with the reason.

🔍 What does Company Domain Finder do?

Company name in, official domain out. For every name you supply, Company Domain Finder builds candidate domains from the name itself, reads each candidate homepage, and accepts one only when the page proves it belongs to the company you asked for. Names that route cannot settle go to Wikidata, and then to a search engine. The winner comes back with a confidence between 0 and 1, a matchedOn list saying exactly which signals fired, and resolutionMethod and resolutionEvidence saying which route found it and what the page proved.

The easiest way to try it is to click Try for free and run it on the two names already in the input box. Paste your own list in and it will work the same way.

Matching a company name to a domain is a judgement, not a lookup, so this Actor never returns a guess dressed up as a certainty. A weak match comes back marked ambiguous with the runners up attached. A name with no findable website comes back not_found rather than as a plausible looking wrong answer.

Four statuses, and the difference between the last two is the one that saves you money:

Status	What it means
found	One domain won clearly, and its own homepage was fetched and read
ambiguous	A domain is proposed but not confirmed: a close runner up, a score under your bar, or a homepage that did not respond
not_found	The lookup ran in full and no candidate survived. Either this company has no findable website, or every candidate found refused to answer, which sourcesUnavailable and error tell apart
unavailable	The lookup could not be completed: Wikidata could not be reached after the name candidates found nothing, the run deadline cut the lookup short, or the domain already belongs to another company in your list. error says which. Worth running again, and not charged

📊 What data can I extract?

One row per company, whatever the outcome:

Field	Type	What it is
query	string	The entry exactly as you supplied it, so rows line back up with your list
companyName	string	The name that was looked up
domain	string	The registrable domain judged to be the company's own website
websiteUrl	string	The homepage that was fetched and scored, after redirects
confidence	number	0 to 1, how strongly the evidence supports the match
matchedOn	array	The signals that fired, such as registry-match or name-is-domain
homepageVerified	boolean	Whether the returned domain's own homepage was fetched and read, rather than the domain resting on a registry claim alone
resolutionMethod	string	Which route found the domain: slug-exact, slug-corroborated, wikidata, wikidata-unverified, search, website-verified or website-unverified. Null when there is no domain
resolutionEvidence	string	What the page proved, as plus separated tokens such as name-legal+town. Null when there is no domain
resolvedTitle	string	The title tag of the page that was matched
description	string	The meta or Open Graph description the homepage publishes
logoUrl	string	The Open Graph image or touch icon, as an absolute URL
country	string	ISO 3166 alpha-2, from your request or inferred from the domain ending
registeredAt	string	When the domain was first registered, from RDAP
domainAgeDays	number	Whole days since registration. A three week old domain is not the company you asked for
nameServers	array	Nameservers the domain resolves through, lowercased and sorted
registrar	string	The registrar holding the domain. Not the owner, which every registry redacts
socials	object	linkedin, x, facebook, instagram, youtube, tiktok, github
alternates	array	Rejected candidates, each with its score and the reason it lost
status	string	found, ambiguous, not_found or unavailable
sourcesUnavailable	array	Which of registry, search and homepages failed to answer for this company, plus deadline when the run timeout cut the lookup short. Empty when everything answered, and also empty when a route was never needed
checkedAt	string	When the lookup ran, ISO 8601
error	string	Why a row without a confirmed answer is worth running again. Null on a confirmed row

💡 Why find company domains?

Name only lists. A column of company names from a form, a badge scan or an old spreadsheet becomes a column of domains, with the ones that could not be resolved marked rather than dropped.

The first field everything else asks for. Contact address tools, technology lookups, headcount data and news feeds all take a domain as their input. This produces that field from a name.

Deduplication. "Apex Engineering Ltd" and "Apex Engineering" are two rows until both resolve to apexengineering.co.uk, at which point they are one account.

Filings, directories and shortlists. Paste the company names out of a document and get the website and social profiles for the whole set in one run.

Agent tooling. The output schema, the confidence score and homepageVerified are there so an AI agent can decide whether to trust a row or ask a human, rather than acting on a guess.

🚀 How do I use Company Domain Finder?

1. Click Try for free.
2. Put your company names into companies. Plain strings are fine, and objects with name, country, city, postcode and hint disambiguate the common names. Add website to an entry when you already have a domain and want it checked rather than guessed.
3. Set country to an ISO 3166 alpha-2 code such as GB if your whole list is from one market.
4. Leave minConfidence at 0.4 unless you want a stricter bar for a row to count as confirmed.
5. Click Start, then download the results as JSON, CSV or Excel, or read them from the API.

⬇️ Input

{
  "companies": [
    "Monzo Bank",
    { "name": "Apex Engineering", "country": "GB", "city": "Manchester" },
    { "name": "Alfie Marketing Ltd", "postcode": "HP14 3GA", "website": "alfiemarketing.com" }
  ],
  "country": "GB",
  "minConfidence": 0.4,
  "includeSocials": true,
  "maxCandidates": 8,
  "useSearchFallback": false
}

Field	Type	Default	What it does
companies	array	required, prefilled with ["Monzo Bank", "Patagonia"]	Names as strings, or objects with name plus optional country, city, postcode, hint and website. A run with no names fails rather than finishing empty, so a broken integration is visible instead of silent
country	string	none	ISO 3166 alpha-2 code applied to every entry without its own country
minConfidence	number	0.4	Below this a row is flagged ambiguous rather than found. Nothing is ever hidden
includeSocials	boolean	true	Read social profile links from the matched homepage markup
maxCandidates	integer	8	How many slug domains, the ones built from the name itself, are fetched and checked per company before Wikidata is asked. Counts only those, not the Wikidata claims checked afterwards. 1 to 8, and 8 is the maximum
useSearchFallback	boolean	false	Send one paced DuckDuckGo query for a company neither its name nor Wikidata resolved. Off by default because from the Apify platform that endpoint challenges the request within seconds, so it resolves nothing there and only costs time

⬆️ Output

Table view

Results arrive as a Companies table you can sort and filter in the Console, with the company, the domain, the confidence, the status, whether the homepage was read, any source that did not answer, the signals that matched, the page title, the country, the socials and the rejected candidates lined up per row.

JSON

Two real rows, copied out of a run of the code that is in this Actor today, on 25 August 2026. Nothing here is tidied up: country is null because the request did not state one and .com implies nothing, two of the seven social slots are empty because the Monzo homepage does not link them, and the rejected candidates are the four slug domains that were tried before Wikidata was asked, each with the reason it lost. Monzo's domain is not its name, so the name route found nothing and the registry claim, confirmed by the name on the homepage, is what resolved it.

{
  "query": "Monzo Bank",
  "companyName": "Monzo Bank",
  "domain": "monzo.com",
  "websiteUrl": "https://monzo.com/",
  "confidence": 1,
  "matchedOn": ["evidence-gate","registry-match","name-in-domain","name-on-homepage","social-handle-match"],
  "homepageVerified": true,
  "resolvedTitle": "Monzo | Open a Free Account",
  "description": "Your salary sorted into Pots. Your spare change turned into savings. Your money, doing what it should with Monzo.",
  "logoUrl": "https://images.ctfassets.net/ro61k101ee59/2TTYm6n3SCsWCaZnIT3Vo1/dd3379fae4c09ed2c86a4e7effafaace/Open_Graph_monzo.com__50_.jpg",
  "country": null,
  "registeredAt": "1998-01-19T05:00:00Z",
  "domainAgeDays": 10445,
  "nameServers": ["curt.ns.cloudflare.com","kara.ns.cloudflare.com"],
  "registrar": "Amazon Registrar, Inc.",
  "socials": {
    "linkedin": "https://www.linkedin.com/company/monzo-bank",
    "x": "https://twitter.com/monzo",
    "facebook": "https://www.facebook.com/monzobank",
    "instagram": "https://www.instagram.com/monzo",
    "youtube": "https://www.youtube.com/monzobank",
    "tiktok": null,
    "github": null
  },
  "alternates": [
    { "domain": "monzobank.com", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" },
    { "domain": "monzobank.co.uk", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" },
    { "domain": "monzo-bank.com", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" },
    { "domain": "monzo-bank.co.uk", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" }
  ],
  "status": "found",
  "sourcesUnavailable": [],
  "checkedAt": "2026-08-25T09:30:10.281Z",
  "error": null,
  "resolutionMethod": "wikidata",
  "resolutionEvidence": "name-legal+registry"
}

And the second row from the same run, for a company name that was invented so there would be nothing to find. Every promised field is present, the ones with no answer are null, and the candidates that were tried are listed with the reason each one lost. Every slug domain failed to resolve at all, so the row carries homepages in sourcesUnavailable and is charged, because the lookup ran in full.

{
  "query": "Zzqxwv Fabrication Holdings",
  "companyName": "Zzqxwv Fabrication Holdings",
  "domain": null,
  "websiteUrl": null,
  "confidence": 0,
  "matchedOn": [],
  "homepageVerified": false,
  "resolvedTitle": null,
  "description": null,
  "logoUrl": null,
  "country": null,
  "registeredAt": null,
  "domainAgeDays": null,
  "nameServers": null,
  "registrar": null,
  "socials": {
    "linkedin": null,
    "x": null,
    "facebook": null,
    "instagram": null,
    "youtube": null,
    "tiktok": null,
    "github": null
  },
  "alternates": [
    { "domain": "zzqxwvfabrication.com", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" },
    { "domain": "zzqxwvfabrication.co.uk", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" },
    { "domain": "zzqxwv-fabrication.com", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" },
    { "domain": "zzqxwv-fabrication.co.uk", "confidence": 0, "reason": "homepage could not be fetched: fetch failed" }
  ],
  "status": "not_found",
  "sourcesUnavailable": ["homepages"],
  "checkedAt": "2026-08-25T09:30:10.282Z",
  "error": "every candidate homepage failed to respond, so this row may improve on a retry",
  "resolutionMethod": null,
  "resolutionEvidence": null
}

Where the candidates come from

Three routes, tried in order, and each one only for the companies the route before did not settle.

1. The name itself, through the evidence gate. apexengineering.co.uk, apexengineering.com, apex-engineering.co.uk and so on, up to maxCandidates of them, the requested market's endings first. Each homepage is read and accepted only when it proves the company: the name exactly as you gave it, including any Ltd or Limited, on the page, or the name without its legal form plus something you passed that the page also carries, a postcode, a town, a country or a hint. A page that is parked, for sale, or a business directory listing is refused before the name is even read. This is how most small businesses are resolved, in one or two fetches, with nothing else contacted.
2. Wikidata. For the well known brands whose domain is not their name. It states official websites as a claim on the company itself. Two calls to wikidata.org/w/api.php, a name search and then the claims. Only entities whose label agrees with your name and that are an organisation rather than a place or a person are used, so the town of Dawlish does not answer for Dawlish Limited and the Arizona town does not answer for Patagonia. The claimed homepage is then read through the same gate, with the registry claim standing in as corroboration.
3. DuckDuckGo, only when you turn it on. One paced query per company that is still unresolved, sent to html.duckduckgo.com unauthenticated. Aggregators are stripped out, and a hit only counts when the site's own homepage passes the gate. It is off by default: from the Apify platform the endpoint challenges the request within seconds, so on there it resolves nothing and costs every unresolved name a wait. Set useSearchFallback to true if you run somewhere it answers. It is switched off for the rest of the run at the first sign of a block either way.

Then RDAP for the winning domain's registration date and nameservers, which is free, keyless and standardised.

Everything is plain HTTP. No browser, no paid API, no key of yours or ours. Every fetch is capped at 2 MB, with six seconds for a site to start answering and ten more to send its page, and at most eight pages are streaming at once so a large brand homepage is read to the end rather than cut off. A candidate whose page is cut off is reported as timed out in alternates, never as a page with nothing on it. A run keeps a 45 second margin before its own timeout, so a long list finishes successfully with everything resolved so far and the status message says how many names were reached.

A website you supply is verified, never guessed past. Give an entry website and the Actor reads that homepage and reports whether the page proves the company, as website-verified when it does and website-unverified, marked ambiguous, when it does not. It never goes looking for a different domain when you have already named one.

One domain, one company. A domain that comes up for a second company in the same run is either a site that publishes company data or a group trading from one website, and in neither case can the second row be answered on its own. The first company's row stands, the domain is blocked for the rest of the run, and the second company comes back unavailable with the reason in error, unbilled, never not_found. If the two really are one group, pass website on the second entry and it is verified directly.

Two names for one site are one answer. A brand whose registry entry states more than one domain, greggs.co.uk and greggs.com say, that both answer from the same site is judged once. The duplicate goes into alternates as the same site reached through a redirect, rather than tying with itself and demoting a confirmed match to ambiguous.

Worth knowing before you buy. The DuckDuckGo endpoint is the least stable part of this Actor. It is a public HTML page rather than an API, nobody promises it to us, and from the Apify platform it refuses within seconds, which is why it is off by default and last in line. The name itself and Wikidata resolve most companies without it, a lookup that loses a source says so in sourcesUnavailable rather than pretending, and a lookup that never got its candidates gathered is not charged for.

Resolution methods and evidence

Every row with a domain carries resolutionMethod and resolutionEvidence, so you can filter on how the answer was reached and how strong the proof is.

resolutionMethod	What it means
slug-exact	A domain built from the name, whose homepage prints the name exactly as you gave it
slug-corroborated	A domain built from the name, whose homepage prints the name without its legal form plus something you passed
wikidata	An official website claim on Wikidata, confirmed by the name on that homepage
wikidata-unverified	An official website claim on Wikidata whose homepage did not respond. Always ambiguous
search	A search hit whose own homepage passed the gate
website-verified	The website you supplied, and its homepage proves the company
website-unverified	The website you supplied, read, but the page does not prove the company. Always ambiguous

resolutionEvidence lists the tokens that fired, joined with +. The first is the name match: name-legal for the strict form, name-core for the name without its legal suffix, name-trimmed for the name with trailing words such as Solutions or Services dropped. The rest are the corroboration found: registry, postcode, town, country when the page names your country, country-domain when only the domain ending matches it, and hint.

A core name backed by nothing but the country is delivered as ambiguous, not found, with the reason in error. Hand checked on the day this shipped: a Leeds company asked for by name resolved to a same name company in London on exactly that evidence. Pass city or postcode and the same lookup either confirms or refuses.

How the confidence score is worked out

Each candidate homepage is fetched and checked for the signals below. They add up, and the total is capped at 1.

Signal	What it means
evidence-gate	The homepage itself proved the company, see resolutionEvidence
registry-match	An open registry states this domain is the company's official website
established-domain	Registered more than two years ago, so it is not a fresh lookalike
name-is-domain	The domain label is exactly the company name with the spaces closed up
name-in-domain	The company name is contained in the domain label
exact-name-in-title	The full company name appears in the page title
name-in-title	Every word of the name appears in the page title
name-on-homepage	The full company name appears in the homepage text
social-handle-match	A social profile the homepage links to carries the company's handle
top-search-result	The domain was the first non directory result
in-search-results	The domain appeared further down the results
country-match	The domain ending matches the country you asked for

Two rules stop a plausible wrong answer getting through. A candidate with no name signal is never returned, however well it ranked in a search, so a nonsense name comes back not_found instead of resolving to whatever happened to be first. And a domain ending that contradicts your requested country is penalised, so asking for a UK company and being handed the Italian arm of a group at full confidence cannot happen.

Where the best and second candidate finish within 0.1 of each other, the row is ambiguous even if the score is high. Two candidates that close means the Actor cannot tell them apart, and saying so is worth more than a coin toss.

A score is not a confirmation. A registry claim scores well on its own, and some sites answer a plain homepage request with a 403 or a 404 while being perfectly real. When the winning domain's own homepage never responded, the row carries homepageVerified: false and comes back ambiguous rather than found, however high the score, with the reason in error. The domain is still there and still probably right. It just has nothing behind it that this Actor saw with its own eyes, and a row that cannot tell you that is asking you to trust it blindly.

The aggregator trap

Search results for any company name fill up with pages about the company rather than pages by it: LinkedIn, Crunchbase, Bloomberg, Companies House mirrors, Yell, Glassdoor, Trustpilot. None of those is the company's own website, and returning one is the most damaging mistake this Actor could make, because it is only caught after somebody has acted on it.

Company Domain Finder keeps a denylist of those hosts and never returns one as domain. They appear in alternates with the reason, so you can see they were considered and thrown out rather than missed.

The denylist has one deliberate exception. Someone looking up "LinkedIn" wants linkedin.com, so a host stops counting as an aggregator when the name being searched is that aggregator's own brand. Country versions are covered too, which matters more than it sounds: google.com being on a list that google.co.uk was missing from is exactly how a made up company name once resolved to a search engine.

Limits

• Social profiles are read from the matched homepage's own markup. That means a company whose footer does not link its accounts returns nulls, and it also means this Actor never contacts a social platform, so nothing here is affected by their blocking.
• A homepage that requires JavaScript to render its text may score lower on the page signals, because no browser is used. The domain and registry signals are unaffected.
• Only the first candidate homepage per domain is read. This finds the website, it does not crawl it.
• maxCandidates caps how many slug domains built from the name are checked, 1 to 8. Every domain tried and refused is listed in alternates with the reason.
• A run stops early if five companies in a row come back unavailable because Wikidata refused them, since that means a source is down rather than the list being unusual. The rows already resolved are kept and the status message says how many names were reached.
• A run that reaches its own timeout finishes successfully with every company resolved so far, and the status message says how many names were not reached. Nothing that was charged is lost. A company the deadline caught mid lookup, before its candidates were gathered, is delivered as unavailable with deadline in sourcesUnavailable, is not charged, and is counted among the names not reached.
• A run with no company names in it fails rather than finishing green with an empty dataset, so a broken integration is visible on the run list instead of looking like a list nobody could resolve.

⏱️ How long does a run take?

Measured on real runs, so you know what normal looks like and can tell it apart from a run that has stalled.

Companies in the list	Typical run time
2	7 to 30 seconds
12	about 10 seconds
50	70 to 80 seconds

The spread on that first row is the honest shape of this Actor rather than noise. A well known name is settled by the first candidate domain the resolver tries, and that is one page load. A name that no candidate proves has to fall through to Wikidata and then to a search engine, and each of those is another round trip before the row can be written. A list of fifty obscure limited companies has therefore been measured at both 76 seconds and, on a batch where almost every name needed the fallback route, over four minutes. The first few seconds of any run are the container starting rather than the work.

Two settings move the figure directly. maxCandidates sets how many domains are built and read per name, and useSearchFallback adds the last and slowest route for names nothing else settles. Turning the fallback off makes a run faster and returns fewer resolved domains, which is the trade rather than a bug.

A run is never silently stuck. Every company is logged as it is resolved, with the route that settled it, and if a run reaches its time limit it stops early, keeps every domain already found and says how many names were left in the status message.

💰 How much does it cost?

Charged once per company name. A name that resolves cleanly, one that comes back ambiguous and one with no findable website all cost the same, because proving a company has no website costs the same fetches as finding one.

Company resolved, per lookup:

Free	Bronze	Silver	Gold	Platinum	Diamond
$0.001	$0.00085	$0.0007	$0.0006	$0.0005	$0.0004

Free is the list price and each paid plan steps down from it, to 40 percent on Diamond. A thousand company names is $1.00 on the Free plan, $0.85 on Bronze, and $0.40 on Diamond. Apify's own Actor start event is charged on top at $0.00005 a run, once, because this Actor caps its memory at 256 MB, so that thousand name run is $1.00005 on Free. The Apify listing always shows the current rates.

A company that was never looked up is not charged. If the name candidates find nothing and Wikidata refuses the request, if the run deadline arrives before the candidates were gathered, or if the domain already belongs to another company in your list, the row comes back unavailable, error says why, and no company-resolved event fires for it. You pay for answers, including the answer "this company has no website", and not for a lookup that never happened.

That is about the source, not about the company. A name whose candidate homepages were all found and all refused to respond is charged, because the lookup ran in full: every candidate was fetched and "no reachable website" is the answer. Those rows come back not_found carrying homepages in sourcesUnavailable and an error saying they may improve on a retry, so you can tell them apart from a company that genuinely publishes nothing.

If five companies in a row come back unavailable, a source is down rather than the list being unusual, and the run stops there and says so in the log. You keep the rows already resolved, and the rest of the list is left for a later run rather than burned against a source that is not answering.

The price does not move with maxCandidates, how many sources answered, or how many social profiles were found.

You can cap what a run is allowed to spend before you start it. Keep the cap above $0.00105, the start event plus one lookup, because a cap below that could not pay for a single result and would stop the run without returning anything.

🔌 Integrations

Send results straight to Google Sheets, Slack, Airtable, Zapier, Make or your own webhook using Apify integrations. Runs can be scheduled, monitored, and triggered by an event in another tool, so a weekly list of new accounts can be resolved without anyone opening the Console.

🔗 Using Company Domain Finder with the Apify API

curl -X POST "https://api.apify.com/v2/acts/spookyweb~company-domain-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["Monzo Bank", "Patagonia"], "country": "GB"}'

Or with the Apify client:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('spookyweb/company-domain-finder').call({
  companies: ['Monzo Bank', { name: 'Apex Engineering', country: 'GB', city: 'Manchester' }],
  minConfidence: 0.4,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

Full detail is in the Apify API reference, and every run is also callable from the Python and JavaScript clients.

❓ FAQ

What does the confidence score actually mean?

It is the weighted sum of the signals listed above, capped at 1. A domain stated by an open registry, matching the name exactly, and carrying the company's name in its page title will sit near 1. A domain that only looks right will sit near 0.3. Read matchedOn alongside it, because the same score can be reached different ways and the list tells you which.

Why did I get a row marked ambiguous with a high confidence?

Because a second candidate scored within 0.1 of it. That usually means a group runs more than one legitimate domain, or two real businesses share a name. Both are in alternates, so you can pick.

Will it ever return a LinkedIn or Crunchbase page as the website?

No. Directory, registry and social profile hosts are on a denylist and are never returned as domain. They show up in alternates with the reason. The one exception is when you are actually searching for that company, so looking up "LinkedIn" does return linkedin.com.

What happens to a company with no website at all?

You get a row with status set to not_found and domain set to null. That is a real finding rather than a failure, and the run finishes successfully. The candidates that were tried are in alternates with the reason each one lost.

How do I tell "no website" apart from "the site was down"?

Read status alongside sourcesUnavailable and error. unavailable means nothing was really checked: the name candidates found nothing and Wikidata refused the request, or the run deadline cut the lookup short, or the domain already belongs to another company in your list. not_found with an empty sourcesUnavailable means the lookup ran in full and this company has no findable website, which is a real result you can act on. not_found carrying homepages is the middle case: candidates were found, every one of them was fetched, and none of them answered. error says which of the three happened in a sentence, and all three are worth a second run except the middle one, which usually means the sites are genuinely down or refusing automated requests.

Why is a row ambiguous when the confidence is high?

Either a second candidate finished within 0.1 of the winner, or homepageVerified is false, or the only corroboration was the country and error says so. The homepage case is the interesting one: the domain was claimed by the registry and matches the name, but its homepage answered with an error or a timeout when the Actor tried to read it, so there is nothing confirming the claim. Some perfectly real sites do this to a plain HTTP request. Treat the domain as a strong lead and check it yourself, rather than as a verified answer.

Can I look up companies outside the UK and the US?

Yes. The country hint is optional and the Actor works on any market. Setting country adds that market's domain endings to the candidates tried and puts the country into the search, which improves the answer for common names.

How do I disambiguate two companies with the same name?

Pass an object instead of a string: { "name": "Apex", "country": "GB", "city": "Manchester", "postcode": "M1 1AE", "hint": "structural steel" }. The city, postcode and hint are what the evidence gate looks for on the page alongside the name, and they go into the search query too, which is usually the difference between the right company and a coin toss. If you already know the domain, add website and it is verified instead.

Does it use my API keys, or anyone else's?

No. Every source is public and keyless, which is why the price is what it is.

⚖️ Is it legal to find company domains?

Yes. This reads publicly available information: an open knowledge base, a public search index and the homepages companies publish themselves. It handles business information rather than personal data, it does not log in anywhere, and it does not use breach data or scraped private databases.

Social profile URLs are read from a company's own website markup, so no social platform is ever contacted and their terms of service do not come into it. What you do with the results afterwards is yours to get right: if you go on to contact named people, UK GDPR and its equivalents make you the data controller for that. Apify's ethical scraping guide covers the wider picture.

👍 Your feedback

Found a bug, or want a field that is not here yet? Open an issue on the Actor's Issues tab. Requests that make the data more useful get built, and problems get fixed quickly.

🔎 You might also like

Actor	What it does
Company Email Finder	Contact addresses, the email naming convention behind them, and MX validation
Website Contact Scraper	Emails, phones, socials and addresses from company websites, one record per domain