# Company Name to Domain Finder: Wikidata Lookup (`steadyline/company-name-to-domain`) Actor

Resolve a company or brand name to its official website using Wikidata P856, plus domain heuristics and a DNS/MX sanity check. No Google scraping, no unofficial autocomplete APIs. $2 per 1,000 confident matches; not-found is free. By Steadyline Data.

- **URL**: https://apify.com/steadyline/company-name-to-domain.md
- **Developed by:** [Steadyline Data](https://apify.com/steadyline) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 domain resolveds

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 Name to Domain Finder: official websites from a list of company names

Give it company or brand names. For each one it looks up Wikidata's official website property (P856), then — if Wikidata has no confident match — tries a few obvious domain spellings and confirms them with DNS (and, when robots.txt allows, the company's own homepage title). You get a domain, a confidence score and a `source` of `wikidata` or `heuristic`.

- **No Google scraping, no unofficial autocomplete APIs, no paid data.** Wikidata is CC0 and queried through its official API with a named user agent.
- **Not-found is free.** Low-confidence rows are returned so you can review them, but they are not billed.

This is the feeder for [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor) when your list is names rather than domains, including [SEC Form D funded companies](https://apify.com/steadyline/sec-form-d-funded-companies).

### Use cases

- **Form D and registry lists:** [SEC Form D funded companies](https://apify.com/steadyline/sec-form-d-funded-companies) returns legal names, not domains. This Actor turns those names into websites you can enrich.
- **CRM clean-up:** fill the website field on accounts that only have a company name.
- **Lead-list prep:** resolve names, then run [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor) or [Website Company Profiler](https://apify.com/steadyline/website-company-profiler).

### Input

```json
{ "companies": ["Stripe", "Python Software Foundation", "Wikimedia Foundation"] }
```

### Output sample

```json
{
  "input": "Stripe",
  "companyName": "Stripe",
  "domain": "stripe.com",
  "website": "https://stripe.com",
  "confidence": 95,
  "source": "wikidata",
  "wikidataId": "Q7628770",
  "status": "ok",
  "charged": true
}
```

`status` is `ok`, `low-confidence`, `not-found`, `empty` or `duplicate`. `source` is `wikidata` or `heuristic`.

Confidence 70 or higher (the default `minConfidence`) is treated as a confident match and billed. Matches below that threshold stay in the dataset with `charged: false`.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `domain-resolved` | $0.002 | One company name confidently matched to a domain |

Not-found, low-confidence, empty and duplicate rows are **never charged**.

**Cost example:** 1,000 confident matches = **$2.00**.

### Use it from AI agents (MCP), Zapier, Make, n8n or the API

**AI agents (Claude, Cursor, VS Code, ChatGPT and other MCP clients).** Add Apify's hosted MCP server with just this Actor as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=steadyline/company-name-to-domain"
    }
  }
}
```

Sign in with Apify (OAuth) on first connect, or add an `Authorization: Bearer <APIFY_TOKEN>` header. Then ask your agent, for example:

> Use steadyline/company-name-to-domain to find official websites for these company names and return domain, confidence and source.

The agent sees this Actor's input schema and output fields, so it can call it without extra prompting. Agents that use the general Apify MCP server can also find it with `search-actors`.

This Actor uses pay-per-event pricing with limited permissions, so it can also be run through Apify's agentic payments (no Apify account needed for the agent). See the [Apify docs](https://docs.apify.com/platform/integrations/mcp#agentic-payments).

**Zapier, Make and n8n.** Use the official Apify app: Zapier "Run Actor" action, Make "Run an Actor" module, or the n8n Apify node. Choose `steadyline/company-name-to-domain`, paste the input below, then use "Get dataset items" (or the run's dataset) to send results to Google Sheets, Slack, a CRM or a database.

**API (any language).** Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyline~company-name-to-domain/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["Stripe", "Python Software Foundation", "Wikimedia Foundation"]}'
```

Or with the Python client (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("steadyline/company-name-to-domain").call(run_input={"companies": ["Stripe", "Python Software Foundation", "Wikimedia Foundation"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Works well with other Steadyline Data tools

- **New funded companies:** [SEC Form D funded companies](https://apify.com/steadyline/sec-form-d-funded-companies) -> this Actor -> [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor) and [Email Deliverability Checker](https://apify.com/steadyline/email-deliverability-checker).
- **Profile the company next:** this Actor -> [Website Company Profiler](https://apify.com/steadyline/website-company-profiler) for name, address, logo and optional Wikidata firmographics.
- Related: [SEC Form D Funded Companies](https://apify.com/steadyline/sec-form-d-funded-companies), [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor), [Website Company Profiler](https://apify.com/steadyline/website-company-profiler), [Email Pattern Finder](https://apify.com/steadyline/email-pattern-finder), [Domain Intel (WHOIS/RDAP, DNS, SSL)](https://apify.com/steadyline/domain-intel).

### FAQ

**Where does the data come from?**
First the official Wikidata API (property P856, official website). If there is no confident Wikidata match, a few obvious domain spellings are tried, checked with DNS, and optionally confirmed against the company's own homepage (robots.txt is respected). There is no Google scrape and no unofficial autocomplete API.

**What is a confident match?**
A score of 70 or higher by default (`minConfidence`). Wikidata official websites with a close label match score in the 80s and 90s. Heuristic domains only reach that bar when the homepage title or JSON-LD name also looks like the company. Lower-scoring candidates are returned uncharged.

**What if the name is generic or unknown?**
The row comes back as `not-found` or `low-confidence` and is **not charged**. Review low-confidence rows before you write them to a CRM.

**Can I run it on a schedule?** Yes. Create an Apify Schedule (or a saved Task with a schedule) and connect a webhook or integration to receive results.

**Need a feature or found a bug?** Open an issue on the Issues tab of this page or email steadylinedata@proton.me. Built and maintained by **Steadyline Data**.

### Acceptable use

Use the results for lawful research and business workflows. Domain guesses can be wrong, especially for generic names; check low-confidence rows before you write to a CRM or send mail. Follow each website's terms when you continue with another tool.

Steadyline Data provides this tool as is and does not give legal advice.

# Actor input Schema

## `companies` (type: `array`):

Company or brand names, one per row. Legal suffixes (Inc, LLC, Ltd, GmbH, …) are stripped automatically. Duplicates are skipped for free.

## `minConfidence` (type: `integer`):

Only matches at or above this score are treated as confident and billed. Lower-scoring candidates are still returned, uncharged.

## `maxConcurrency` (type: `integer`):

Lookups in parallel. Kept modest to respect Wikidata rate guidance.

## Actor input object example

```json
{
  "companies": [
    "Stripe",
    "Python Software Foundation",
    "Wikimedia Foundation"
  ],
  "minConfidence": 70,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per company name.

# 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 = {
    "companies": [
        "Stripe",
        "Python Software Foundation",
        "Wikimedia Foundation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyline/company-name-to-domain").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "companies": [
        "Stripe",
        "Python Software Foundation",
        "Wikimedia Foundation",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steadyline/company-name-to-domain").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "Stripe",
    "Python Software Foundation",
    "Wikimedia Foundation"
  ]
}' |
apify call steadyline/company-name-to-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyline/company-name-to-domain"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <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/XG0QuAA2iSiZtmKz9/builds/awAeqQllRcHuiy03M/openapi.json
