# Lookalike Companies Finder - Similar Companies by Domain (`b2bdata/company-lookalikes`) Actor

Moved to https://apify.com/b2bdata/similar-companies-by-domain (new price, same job). This older copy is deprecated and kept for reference.

- **URL**: https://apify.com/b2bdata/company-lookalikes.md
- **Developed by:** [Open Enrich](https://apify.com/b2bdata) (community)
- **Categories:** Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 lookalike companies

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Lookalike Companies from Seed Domains

Lookalike companies from seed domains: give the website domains of companies you already sell to, get back other companies with the same industry code, in the same country, within half to double the seed's headcount, closest size first. The rule is simple and printed on this page. It is a filter, not a similarity score, and we have not measured how well its output matches your own idea of a similar company. No login, no cookies, no start fee. You pay only for each lookalike row you receive.

**No login | Seed domains in, similar companies out | Same industry code, same country, similar size | Up to 500 seeds per run | Seeds with no match are free | JSON/CSV export**

> **Not a name or keyword search.** This actor starts from a domain. It does not find companies by name, keyword, funding or technology. For a keyword search use [linkedin-company-search](https://apify.com/b2bdata/linkedin-company-search).

[See all actors by b2bdata](https://apify.com/b2bdata)

***

### Pricing and plans

One event, `lookalike`, charged once per lookalike row delivered. Prices per 1,000 lookalikes (draft, set on the Pricing tab):

| Event | When it is charged | Free plan | Gold plan |
|---|---|---|---|
| `lookalike` | One lookalike company is delivered to your dataset | $0.963 | $0.696 |

Bronze and Silver prices are on the Pricing tab. Higher Apify plans only lower the price. Seeds with no usable company record, seeds with no lookalikes, empty runs, failed lookups, unreadable input lines and notices are free, and there is no start fee.

**Plan-credit math.** The free plan's $5 monthly credit covers about 5,190 lookalike rows at the Free price. With the default of 10 per seed that is about 519 seeds.

#### Success-only billing

You are charged only for a row you receive, one charge per row. A seed that cannot be used or has no lookalikes is listed in `MISSES` with a reason and costs nothing. Use `limit` to set how many rows each seed can cost, and `maxChargeUsd` (advanced input) to stop a run at a spend you choose.

#### The free plan

Free plan: 100 seed domains looked up per run, and as many runs as your Apify credit covers. Nothing is stored on our side. When a list is longer, the first 100 seeds are looked up and one free notice row (`reason: "free_plan_limit"`) says how many were not looked up; they are not charged. Run again with the rest, or use a paid Apify plan for no per-run limit.

#### Keep a run small while you test

Use `limit` to cap the lookalikes per seed. The default is 10, the maximum is 50. Try 1 to 3 seeds with `limit` 5, read the rows, then scale up.

***

### How a seed becomes lookalikes

1. **The seed.** The domain is looked up in the company data. The company that owns the domain is the seed. If several companies own it, the largest is used only when it has at least three times the headcount of the next one; otherwise the seed is `ambiguous_seed`. The seed needs an industry code, a country and a headcount on file; without them it is `seed_incomplete`.
2. **The candidates.** Companies with the same industry code, in the same country, with a headcount from 0.5 times to 2 times the seed's. The search reads the nearest-sized companies on both sides of the seed's headcount.
3. **The rules.** A candidate is kept only if it owns the domain it declares, is not a placeholder employer (such as a self-employed entry), is not the seed, and is not listed twice under the same domain or the same name.
4. **The order.** Closest headcount to the seed first. Companies with the same headcount are ordered by domain A to Z, so the same input gives the same rows.

#### What to know before you rely on it

- **The industry code is coarse.** Some codes are broad buckets, so companies with very different businesses can share one. A payments company and an insurer can sit in the same code. Check the first rows of a new seed before you scale.
- **The industry code is known for about half of all companies.** A company without one is never returned, and a seed without one returns no row.
- **Headcounts repeat.** Many companies share the exact same headcount, so among them the order is only alphabetical. `sizeRatio` shows how close each row is.
- **Same country means the country on file** for the company, usually where it is registered or headquartered.
- **Similar here means these rules.** We did not measure how well the rows match what you would call similar.

***

### Why this lookalike companies actor?

- **Rules you can read.** Same industry code, same country, half to double the size. Nothing hidden behind a score.
- **Seed context on every row.** `seedDomain`, `seedName`, `rank` and `sizeRatio` tell you why the row is there.
- **No guessing.** A seed with no clear owner, no industry, no country or no headcount returns nothing and costs nothing.
- **Success-only, no start fee.** Misses and notices are free.

***

### Use cases: find similar companies from a customer list

- **Lookalike account lists.** Take your best customers' domains and build a list of similar-sized companies in the same industry and country.
- **Territory expansion.** Seed with the accounts you won in one country and get peers to approach next.
- **Competitor-adjacent lists.** Seed with a company you track and see the same-size companies in its industry code.
- **Agent workflows.** An AI agent holds a seed domain and needs peer companies. One call, ranked rows.

***

### Pipeline guide: from customers to contacts

```
[1] Seed domains (your best customers)
        |
        v
[2] company-lookalikes               -> similar companies and their domains
        |
        v
[3] company-firmographics-by-domain  -> company record for each domain
        |
        v
[4] executive-email-finder-by-domain -> decision makers and emails
```

***

### Quick start: find similar companies from a domain

#### 1. One seed

```json
{ "items": ["stripe.com"], "limit": 5 }
```

#### 2. A customer list

```json
{
  "items": [
    "stripe.com",
    "https://www.notion.so/",
    "plausible.io"
  ],
  "limit": 10
}
```

#### 3. A capped run

```json
{ "items": ["stripe.com", "plausible.io"], "limit": 20, "maxChargeUsd": 0.5 }
```

***

### Inputs

| Key | Type | Default | What it does |
|---|---|---|---|
| `items` | array | required | One seed per entry: a company domain or website URL. A company name or an email address is not a seed. Duplicates are collapsed. Maximum 500 per run; more stops the run with a message before any lookup. |
| `limit` | integer | 10 | Lookalikes delivered per seed, closest headcount first. From 1 to 50. Each delivered row is one charge. |
| `maxChargeUsd` | number | none | Advanced. Stops the run once it has charged this much. |

Any other field stops the run before a lookup with `remove unsupported fields: ...`. Nothing is charged. An entry that is not a domain is listed in `MISSES` as `invalid_domain`.

***

### Output

One row per lookalike company. Rows are grouped by seed in input order, then by rank. Empty values are left out of the row.

| Key | Type | Meaning, and when it is missing |
|---|---|---|
| `seedDomain` | string | The seed domain the row belongs to |
| `seedName` | string | The seed company's name |
| `rank` | integer | 1 = closest headcount to the seed, within this seed |
| `name` | string | Lookalike company name |
| `domain` | string | Website domain of the lookalike, lower case, no `www.` |
| `website` | string | Website address on file, when present |
| `linkedinUrl` | string | The company's professional-network page, when on file |
| `country` | string | 2-letter country code (same as the seed's) |
| `industry` | string | Industry name (same code as the seed's) |
| `employeeCount` | integer | Employee count on file |
| `sizeRatio` | number | Lookalike headcount divided by the seed's, 0.5 to 2 |
| `founded` | integer | Founding year, when on file |
| `hq` | string | Headquarters locality, when on file |
| `scrapedAt` | string | ISO time the run produced the row |

```json
{
  "seedDomain": "seedco.example",
  "seedName": "Seedco",
  "rank": 1,
  "name": "Example Platforms",
  "domain": "exampleplatforms.example",
  "website": "https://exampleplatforms.example",
  "country": "US",
  "industry": "Software Development",
  "employeeCount": 1180,
  "sizeRatio": 0.98,
  "founded": 2012,
  "hq": "Austin, Texas",
  "scrapedAt": "2026-11-02T10:00:00.000Z"
}
```

*Illustrative row showing the shape. It is not a recorded run.*

#### Other records in the run

- **`MISSES`** (key-value store): `[{index, input, reason}]` for every entry that produced no row: `invalid_domain`, `duplicate_input`, `domain_not_found`, `seed_not_owner`, `ambiguous_seed`, `seed_incomplete`, `no_lookalikes`, or `Upstream HTTP <code>`.
- **`errors-company-lookalikes`** (key-value store): the seeds that failed for a technical reason, so you can re-run only those.
- **`RUN_SUMMARY`**: counts and stop reason.
- **Notice rows** (`type: "notice"`) are free and never carry a company. `no_lookalikes` appears once at the end of a run that left seeds without rows. `free_plan_limit` appears when a free-plan list is longer than 100. `charge_limit_reached` appears when your spend cap or the platform limit is reached; a capped run delivers the rows it already charged for.

#### What is NOT returned

- Companies found by name, keyword, funding or technology
- Contact details of people at the company
- A similarity score, or any claim that a row is a close match

***

### Reliable results

**Our data promise.** We work to keep every record current, and we stand behind it. If a record is outdated or a company does not belong in a lookalike list, open the Issues tab with your run link. We review every report and sort it out with you, case by case.

- **Misses are free and visible.** Every seed without rows is in `MISSES` with a reason and is never charged.
- **One row, one charge.** Each delivered lookalike is charged once, and a row is saved as it is delivered, so a run that stops keeps what it already produced.
- **Duplicates are collapsed.** The same company under one domain or one name is delivered once, and the seed itself is never returned.
- **Bounded pace.** Lookups run at 60 requests per minute, three per usable seed, so 100 seeds need roughly 5 minutes.
- **Typos fail early.** An unsupported input field, a limit outside 1 to 50 or more than 500 seeds stops the run before any charge. If the data source refuses a lookup, the run fails with `Upstream HTTP <code>` instead of returning an empty successful run.

***

### For AI agents (MCP)

This actor runs through the Apify MCP server. Prompt to copy:

> "Use b2bdata/company-lookalikes with items=\["stripe.com"] and limit=5. Return name, domain, employeeCount and sizeRatio for each row. If there are no rows, say the seed had no lookalikes and give the reason from MISSES."

**When to use it.** You hold the domain of a company and want other companies of the same industry code, country and similar size.
**When not to.** You hold a name or keyword (use linkedin-company-search), or you need the company record of a known domain (use company-firmographics-by-domain).
**Input contract.** `items` array of domains or website URLs; `limit` 1-50 lookalikes per seed.
**Output contract.** Rows with `seedDomain`, `rank`, `name`, `domain`, `country`, `industry`, `employeeCount`, `sizeRatio`. Output is deterministic: same input, same rows, closest headcount first. Seeds without lookalikes are absent from the dataset and listed in `MISSES`.
**Smoke test.** `limit: 1` on a well-known company domain returns one row.
**Error cases.** `No valid seed domains` means no entry was a domain. `remove unsupported fields` means a misspelled input key. Both end the run SUCCEEDED with one free `invalid-input` notice row and nothing charged.

***

### Integrations: send results anywhere

1. **API.** Fetch rows from the run's default dataset: `GET /v2/datasets/{datasetId}/items?format=csv`.
2. **Webhook** on run success to push rows to your own endpoint.
3. **n8n, Make, Zapier.** Use the native Apify nodes: run the actor, then read the dataset.
4. **Google Sheets, Airtable, HubSpot, Salesforce.** Map `domain` to the website field and `seedDomain` to a source-account column.

***

### Schedule examples

- **Monthly lookalike refresh.** A monthly schedule with a saved task that points at your latest customer domains.
- **New-customer intake.** A webhook from your CRM starts a run with the domain of each newly won account.

***

### Related actors

- `b2bdata/company-firmographics-by-domain`: you have a domain and need the company record. [Open](https://apify.com/b2bdata/company-firmographics-by-domain)
- `b2bdata/linkedin-company-search`: find companies by keyword and country. [Open](https://apify.com/b2bdata/linkedin-company-search)
- `b2bdata/executive-email-finder-by-domain`: get decision makers and emails at a domain. [Open](https://apify.com/b2bdata/executive-email-finder-by-domain)
- `b2bdata/email-finder`: you have a person and a domain and need a work email. [Open](https://apify.com/b2bdata/email-finder)

[See all actors by b2bdata](https://apify.com/b2bdata)

***

### FAQ

#### Data and matching

**How do I find companies similar to my customer?**
Add the customer's website domain as a seed and run. You get companies with the same industry code and country and a headcount from half to double the seed's, closest size first.

**Why did a seed return no rows?**
The domain has no company on file, no clear owner of the domain, or no industry code, country or headcount. Or no other company passed the rules. The reason is in `MISSES`.

**Is the similarity score reliable?**
There is no similarity score. The rows come from three fixed rules, and `sizeRatio` shows how close the headcount is. We did not measure how well they match your idea of similar, so read the first rows of a new seed before you scale.

**Can I use this as a lookalike companies API for AI agents?**
Yes. Call it through the Apify API or MCP with `limit: 1`. The output is deterministic and ranked.

**Do I need a LinkedIn account or cookies?**
No. It needs no login, cookies or account.

#### Pricing

**What do I pay when a seed has no lookalikes?**
Nothing. There is no start fee, and seeds with no usable record, seeds with no lookalikes, invalid lines and notices are free.

***

### Support

Use the **Issues** tab on this actor's Apify page for bugs, questions and feature requests. We answer within 48 hours on working days. Please include the run ID and the input you used.

Published on Apify by b2bdata as proprietary software. Not affiliated with, endorsed by, or sponsored by any company or person named in the examples above.

# Changelog

This Actor's version history is a separate document: https://apify.com/b2bdata/company-lookalikes/changelog.md

# Actor input Schema

## `items` (type: `array`):

Company website domains, one per line, such as "stripe.com". A full URL such as "https://www.stripe.com/pricing" is reduced to the domain. A company name or an email address is not a seed. Each seed gives its own lookalikes. Duplicates are collapsed. A seed with no company on file, no clear owner of the domain, or no industry, country or headcount on file returns no row and is listed in the MISSES record; it is never charged. Free plan: 100 seed domains per run. Maximum 500 per run.

## `limit` (type: `integer`):

Maximum lookalike companies delivered for each seed domain, closest headcount first. Each delivered lookalike is one charged row. A seed can return fewer when fewer companies pass the rules. From 1 to 50.

## `maxChargeUsd` (type: `number`):

Stop delivering rows once this run has charged this much. 0 or omitted = no cap beyond your Apify run limit.

## Actor input object example

```json
{
  "items": [
    "stripe.com"
  ],
  "limit": 10
}
```

# Actor output Schema

## `lookalikes` (type: `string`):

Seed domain, rank, company, domain, country, industry, headcount and size ratio

## `summary` (type: `string`):

Counts and stop reason for this run

# 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 = {
    "items": [
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2bdata/company-lookalikes").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 = { "items": ["stripe.com"] }

# Run the Actor and wait for it to finish
run = client.actor("b2bdata/company-lookalikes").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 '{
  "items": [
    "stripe.com"
  ]
}' |
apify call b2bdata/company-lookalikes --silent --output-dataset

```

## MCP server setup

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

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/ybv9UQ6aYlKoCRN1V/builds/PC5E8JCSHN3eRtYgh/openapi.json