# Company Website Finder (`scrapers-hub/company-website-finder`) Actor

Company Website Finder resolves a company name to its official website domain and returns a clear lookup status. 🏢 Perfect for CRM data cleaning, lead enrichment, account research and building firmographic datasets from plain company lists.

- **URL**: https://apify.com/scrapers-hub/company-website-finder.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

### 🌐 Company Website Finder – Domain Lookup & Company Enrichment Tool

The **Company Website Finder** turns a plain company name into its official website domain, so you can enrich lead lists, clean up CRM records, and resolve messy company data at scale. Give it a company name — "google", "Stripe", "Siemens Healthineers" — and it returns the domain that belongs to that organisation, along with a status flag telling you whether the lookup succeeded.

This company website finder is deliberately narrow. It does one job: **company name to domain resolution**. That makes it a dependable building block inside a bigger enrichment pipeline, where you already have a spreadsheet of company names from a conference list, a trade directory, an invoice export, or a scraped set of business records, and what you are missing is the one field that unlocks everything else — the website. Once you have the domain, every other enrichment step becomes possible: email pattern discovery, tech-stack detection, traffic estimation, firmographic matching, and social profile lookup.

The Actor performs a web search for the company name and extracts the most likely official domain from the results. It runs without a headless browser, which keeps runs light and fast, and it returns a compact, predictable record shape that is trivial to join back onto your source data.

***

### 📊 What Data Can You Extract with This Company Website Finder Scraper?

The output schema is compact by design. Every record maps one input company name to one resolved website, plus the metadata you need to handle failures programmatically.

| Category | Fields | What it gives you |
| --- | --- | --- |
| 🏢 Company identity | `company_name` | The company name exactly as it was submitted, so records join cleanly back to your source list |
| 🌐 Domain result | `website` | The resolved website address for the company, e.g. `about.google` |
| ✅ Run outcome | `status` | Whether the lookup succeeded, so you can filter resolved rows from unresolved ones |
| ⚠️ Failure detail | `error` | An error message when a lookup could not be completed, for retry logic and debugging |

The most operationally useful field here is `status`. Because company name lookups are inherently probabilistic — some names are ambiguous, some companies are too small to rank in search, some have been acquired and redirect elsewhere — you need a machine-readable signal that separates confident results from misses. Filtering on `status` lets you route successful rows straight into your CRM and push the remainder into a manual review queue, rather than silently importing blanks.

***

### 🌟 Key Features of the Company Website Finder Scraper

| Feature | Description |
| --- | --- |
| 🔍 Name-to-domain resolution | Submit a company name as free text and receive the organisation's website domain back |
| 🧾 Join-friendly output | The submitted `company_name` is echoed in every record, so results merge back onto source rows without fuzzy matching |
| ✅ Explicit status flag | Every record carries a `status` value, making success and failure programmatically distinguishable |
| 🐞 Error surfacing | Failed lookups return an `error` message instead of disappearing, so nothing is lost silently |
| ⚡ Browser-free execution | No headless browser is launched, keeping memory footprint and run duration low |
| 🧩 Tiny input surface | A single required field, `company_name`, means no configuration overhead and no onboarding curve |
| 🔁 Pipeline-ready | Designed to be called repeatedly from a loop, a scheduler, or an orchestration step in a larger enrichment flow |
| 📤 Standard Apify dataset output | Results land in a dataset exportable as JSON, CSV, Excel, XML, or HTML |
| 🔌 Full API access | Callable from cURL, the Apify Python or JavaScript client, or any automation platform that speaks HTTP |

***

### 🚀 Why Choose This Company Website Finder Scraper?

**Purpose-built for the hardest step in lead enrichment.** Most enrichment vendors assume you already know the domain and charge you for everything downstream. The company website finder solves the upstream problem — you have a name, you need a domain — which is exactly the gap that breaks CRM imports and marketing list builds.

**Predictable, minimal output.** Four fields, consistent shape, no nested structures to flatten. That matters when you are pushing results into a spreadsheet, a SQL table, or a Zapier step where deeply nested JSON creates friction.

**Failure is a first-class outcome.** The combination of `status` and `error` means an unresolved company is an explicit, handleable event rather than a null you discover three steps later. You can build retry logic, fallback searches, and human review queues on top of that signal.

**Zero configuration to get started.** The only required input is `company_name`, and it ships with a prefilled default so you can press Start and see a real result within seconds of opening the Actor.

***

### 📥 Input

```json
{
  "company_name": "google"
}
```

#### 🔧 Company Website Finder Input Fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `company_name` | string | ✅ Yes | `google` | Name of the company whose website you want to resolve |

That is the complete input schema. There are no proxy settings, concurrency knobs, or output filters to configure — the Actor is intentionally single-purpose.

#### 💡 Input Examples

**Look up a well-known technology company**

```json
{
  "company_name": "Stripe"
}
```

**Resolve a longer, more specific legal entity name**

```json
{
  "company_name": "Siemens Healthineers AG"
}
```

**Check a smaller regional business**

```json
{
  "company_name": "Bakers Delight Franchising"
}
```

To process a list of companies, call the Actor once per company name — from a loop in your own script, from a scheduled task, or from an automation platform that iterates over spreadsheet rows.

***

### 📤 Output

```json
{
  "status": "success",
  "company_name": "google",
  "website": "about.google"
}
```

#### 🧾 Company Website Finder Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `status` | string | null | Status of the lookup, indicating whether the company website was resolved |
| `company_name` | string | null | The company name that was submitted, echoed back for joining |
| `website` | string | null | The resolved website address for the company |
| `error` | string | null | Error message, present when the item failed to process |

Note that `website` is returned as a domain string rather than a fully qualified URL with a scheme. If your downstream system requires `https://` prefixes, normalise the value after export — a one-line transformation in most tools.

***

### 💻 How to Use the Company Website Finder Scraper (Step by Step)

#### Step 1: Open the Company Website Finder Actor

Sign in to your Apify account and open the Actor page. You will land on the Input tab, which shows a single text field labelled **Company Name**. Because the field is prefilled with a working default, the Actor is immediately runnable — useful for confirming that everything works before you wire it into anything more complex.

#### Step 2: Enter the company name you want to resolve

Type the company name into the field. Accuracy of the input matters more than length: a distinctive, correctly spelled name resolves far more reliably than an abbreviation or an internal shorthand. If your source data contains suffixes like "Ltd", "GmbH", "Inc", or "Pty Ltd", try the name with the suffix first — for larger corporate entities the legal suffix often improves precision, while for small businesses it can sometimes reduce it.

#### Step 3: Run the Actor and watch the log

Press **Start**. The run log streams progress as the lookup executes. Because no browser is launched and only a single company is processed per run, runs complete quickly. Keep an eye on the log if a company fails — it usually indicates that the name was too generic or too obscure to produce a confident match.

#### Step 4: Review the dataset output

Open the **Dataset** tab when the run finishes. You will see one record containing `status`, `company_name`, and `website`. Confirm that the returned domain is genuinely the company you meant — for ambiguous names, several unrelated organisations may share a brand, and a visual check is worthwhile before bulk-importing results.

#### Step 5: Export the resolved website data

Use the Export button to download results as JSON, CSV, Excel, XML, or HTML, or pull them straight from the Apify dataset API. CSV is the natural choice when you are merging results back into a spreadsheet of company names; JSON is better when the data feeds an application.

#### Step 6: Batch the lookups for a full company list

For list enrichment, drive the Actor from code. Loop over your company names, call the Actor once per name, and collect the resulting items into a single table. Because `company_name` is echoed in every record, you can safely run the calls concurrently and reassemble the results afterwards without losing track of which row belongs to which company.

#### Step 7: Handle failures and schedule refreshes

Filter your combined results on `status`, route unresolved companies into a review queue, and inspect their `error` values for patterns. Company websites change — through rebrands, acquisitions, and domain migrations — so schedule a periodic re-run of your company website finder job to keep domains current rather than treating the enrichment as a one-off.

***

### 🔌 API Access & Integrations

Run the company website finder synchronously and receive dataset items directly in the HTTP response:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~company-website-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "company_name": "Stripe"
  }'
```

Enrich a whole list of company names with the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

companies = ["Stripe", "Siemens Healthineers", "Basecamp"]
resolved = []

for name in companies:
    run = client.actor("scrapers-hub/company-website-finder").call(
        run_input={"company_name": name}
    )
    for item in client.dataset(run["defaultDatasetId"]).iterate_items():
        resolved.append(item)

for row in resolved:
    print(row.get("company_name"), "->", row.get("website"), row.get("status"))
```

The Actor also connects to Zapier, Make, Google Sheets, and Slack, and can fire webhooks on run completion so downstream systems pick up newly resolved company websites automatically.

***

### 💡 Best Use Cases for Company Website Data

#### 🎯 Lead list enrichment for outbound sales

Conference attendee lists, trade-show exports, and scraped directories almost always contain a company name and almost never contain a domain. Running each name through the company website finder populates the `website` field that your sales engagement platform needs to look up email patterns and firmographics. Use `status` to split the list into ready-to-import and needs-review segments before uploading.

#### 🗃️ CRM data hygiene and deduplication

Duplicate CRM accounts usually differ by spelling — "Acme Corp", "ACME Corporation", "Acme Corp." — but resolve to the same domain. Resolving `company_name` to `website` gives you a canonical key to deduplicate on, which is far more reliable than fuzzy string matching on names alone.

#### 📈 Market and competitor mapping

When you compile a list of every vendor in a category from analyst reports or industry associations, you get names, not domains. Resolving all of them at once produces a domain list you can feed into traffic estimation, tech-stack detection, or job-posting analysis to size and rank the competitive landscape.

#### 🧾 Supplier and vendor verification

Procurement and finance teams routinely hold supplier names in ERP records with no linked web presence. Populating `website` for each supplier gives auditors a fast path to confirm the entity exists, is trading, and matches the name on the invoice — with `error` flagging the suppliers that could not be found at all.

#### 🤝 Partner and investment pipeline research

Business development and venture teams track long lists of candidate companies sourced from newsletters, pitch decks, and referrals. Batch-resolving those names into domains lets you deduplicate against companies already in your pipeline and gives every new entry a working link the moment it is added.

#### 📊 Dataset joining and entity resolution

Public datasets — grant registers, tender awards, regulatory filings — identify organisations by name in inconsistent formats. Passing each name through the company website finder produces a domain that acts as a shared join key across otherwise incompatible datasets, turning several disconnected sources into one linked table.

#### 🧭 Recruitment and employer research

Talent teams and job-market researchers frequently work from employer name lists with no career-site links attached. Resolving `company_name` to `website` gives you the domain needed to locate careers pages, ATS instances, and company profiles, which is the first step in any employer-mapping or hiring-signal project.

***

### ⚙️ Tips for Better Company Website Finding Results

- **Use the fullest distinctive name you have.** "Anthropic" resolves cleanly; "AI Labs" does not. Where your data contains both a trading name and a legal name, try the trading name first — it is what the public web indexes.
- **Strip internal noise from names before submitting.** Account codes, region suffixes like "— EMEA", and department names appended to the company reduce match quality. Clean the string in your spreadsheet before it reaches the Actor.
- **Always check `status` before importing.** Treat unresolved rows as unknown rather than empty. A blank `website` imported into a CRM is much harder to correct later than a row you never imported.
- **Verify ambiguous brands manually.** Shared brand names across industries and countries are the most common source of a plausible-but-wrong domain. Spot-check a sample of results before a bulk import.
- **Re-run periodically for long-lived lists.** Acquisitions and rebrands change domains. A quarterly refresh of your company website finder job keeps enrichment fields from quietly going stale.
- **Batch with modest concurrency.** When looping over hundreds of companies, keep parallelism reasonable and add short pauses between calls. Steady throughput beats aggressive bursts that trigger upstream rate limits.

***

### 🛠️ Troubleshooting

**The Actor returned a `status` that is not success and an `error` message — what should I do?**
Read the `error` value first; it describes what went wrong for that specific company. Most failures come from names that are too generic or too obscure to produce a confident match. Retry with a more specific version of the name, including a legal suffix or a country qualifier.

**The returned website is not the company I meant.**
This happens with ambiguous brand names shared by multiple organisations. Add a disambiguating token to the input — an industry word, a country, or the legal entity suffix — and run the lookup again. Verifying a sample of results before bulk import is good practice for any name-based resolution.

**The `website` field has no `https://` prefix.**
That is expected. The Actor returns a domain string such as `about.google`. Normalise it downstream by prepending the scheme if your destination system requires a fully qualified URL.

**I need to resolve hundreds of companies and the Actor only accepts one name.**
The input schema takes a single `company_name` per run by design. Drive it from a loop using the Apify API or Python client, as shown in the API section, and collect the dataset items from each run into one table.

**The run finished but the dataset looks empty.**
Check that `company_name` was actually populated in the input rather than left blank or whitespace. Then check the run log, which records what the Actor attempted, and confirm the run status on the Runs tab.

***

### ❓ Frequently Asked Questions About Company Website Finding

**What does the Company Website Finder Actor do?**
It takes a company name as input and returns that company's website domain, along with a `status` flag and, on failure, an `error` message. It is a company name to domain resolution tool.

**What input does the company website finder need?**
A single field: `company_name`. It is required and comes prefilled with a default value so the Actor can be run immediately without configuration.

**What fields does the output contain?**
Four: `status`, `company_name`, `website`, and `error`. Nothing is nested, so the output flattens cleanly into CSV or a database table.

**Can I look up several companies in one run?**
The input accepts one company name per run. To process a list, call the Actor once per name from a script, scheduler, or automation platform and combine the resulting items.

**How do I know whether a lookup succeeded?**
Check the `status` field. Records that did not resolve also carry an `error` message explaining what went wrong.

**Does the returned website include the protocol?**
No. The `website` value is a domain string, as shown in the sample output (`about.google`). Add `https://` downstream if you need a full URL.

**Does this Actor use a proxy?**
No proxy is used and there are no proxy settings to configure. The input schema contains only `company_name`.

**Does it launch a headless browser?**
No. The company website finder runs without a browser, which keeps runs lightweight.

**Will it find the website of a very small or local business?**
Sometimes. Resolution depends on the business having a discoverable web presence under a recognisable name. Small businesses with generic names are the most likely to return an error.

**How accurate is company name to domain matching?**
Accuracy is high for distinctive, well-known names and lower for generic or ambiguous ones. This is why `status` exists — treat it as the confidence signal and review anything that did not resolve.

**Can I use the results for cold outreach lists?**
You can use the domains as firmographic data for legitimate business research and outreach, subject to the marketing and privacy laws that apply in your jurisdiction. The Actor itself returns company-level information, not personal contact details.

**What export formats are supported?**
Apify datasets export to JSON, CSV, Excel, XML, and HTML, and are also readable directly through the dataset API.

**Can I connect the company website finder to Google Sheets or Zapier?**
Yes. The Actor works with Zapier, Make, Google Sheets, and Slack integrations, and can trigger webhooks when a run completes.

**How often should I refresh resolved company websites?**
For long-lived CRM or supplier lists, a periodic refresh — quarterly is a common cadence — catches rebrands, acquisitions, and domain migrations that would otherwise leave stale domains in your records.

**Is there a way to get help or request a custom version?**
Yes. Use the Issues tab on the Actor page, or email `scraperhubapi@gmail.com` for custom scraping and enrichment work.

***

### 🆘 Support & Feedback

If the company website finder returns unexpected results or a run fails, open a report on the **Issues** tab of the Actor page. Including the company name you submitted and the run ID makes diagnosis much faster.

For custom scraping work — bulk enrichment pipelines, additional company data fields, or a tailored version of this Actor built around your own data schema — email `scraperhubapi@gmail.com`.

If this company website finder saves you time, please leave a review on the Apify Store. Ratings and written feedback directly shape which improvements get prioritised.

***

### ⚖️ Disclaimer

The Company Website Finder retrieves publicly available information about organisations and returns the website domain associated with a company name. It does not access private systems, bypass authentication, or collect content behind logins.

You are responsible for how you use the data this company website finder produces. Ensure your use complies with applicable laws and with the terms of service of any platform involved in your workflow. Where any information you process alongside these results relates to identifiable individuals, data protection law — including the GDPR in the EU and UK, and comparable regimes elsewhere — applies to you as the data controller, and you must establish a lawful basis, honour data subject rights, and apply appropriate retention limits.

Results are produced from public web sources and are provided as-is. Domain resolution for company names is inherently probabilistic; verify results before relying on them for contractual, financial, or compliance decisions.

If you believe data returned by this Actor should be removed or corrected, email `scraperhubapi@gmail.com` with the details and the request will be reviewed.

# Actor input Schema

## `company_name` (type: `string`):

Name of the company

## Actor input object example

```json
{
  "company_name": "google"
}
```

# Actor output Schema

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

Records scraped by Company Website Finder, stored in the run's default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "company_name": "google"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/company-website-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "company_name": "google" }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/company-website-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 '{
  "company_name": "google"
}' |
apify call scrapers-hub/company-website-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/company-website-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 <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/waUX4LdxtAg0Egopq/builds/a17GH54Lf6tUaOZXD/openapi.json