# LinkedIn Lookalike Companies — Similar Companies Finder (`northbell/linkedin-lookalike-companies`) Actor

Find companies similar to the ones you give. Reads the public LinkedIn company page and returns the lookalikes LinkedIn lists for it, ranked by how many pages list each one (2 levels deep for a wider net), with new-since-last-run flags. Optional headcount, followers and website. No login.

- **URL**: https://apify.com/northbell/linkedin-lookalike-companies.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 lookalike companies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## LinkedIn Lookalike Companies — Similar Companies Finder

Give it LinkedIn companies — `linkedin.com/company/…` URLs or just the handle — and get back the **lookalike companies** LinkedIn lists for them: name, industry, location, URL, and a **closeness score** (`timesListed`: how many of the pages it read list that company). Add `depth: 2` to read the pages of the lookalikes too, and the companies that many neighbours point at rise to the top. **$1 per 1,000 lookalike companies** ($4 per 1,000 with company details switched on), no login, no cookies.

Run it again — or put it on a schedule — and every row also tells you **what changed since the last run**: `isNewSinceLastRun` (LinkedIn did not list this company last time), `previousRank` and `rankChange` (positive = moved up). On the first run these are `null`.

### What you get

One row per lookalike company (`type: "lookalike"`), closest first.

| Field | What it is |
|---|---|
| `name`, `slug`, `url`, `kind` | the company; `kind` is `company`, or `showcase` for a product or brand page |
| `industry`, `location` | as shown on the similar-page card (`location` is missing on some cards) |
| `timesListed`, `listedBy` | **closeness**: how many of the pages read list this company, and the handles of those pages |
| `rank` | position in the list (1 = closest), by `timesListed`, then `depth`, then the order LinkedIn shows them (`null` on the companies you gave) |
| `seed`, `depth` | the first company you gave that led to it, and how many steps away it is (`1` = on a page you gave, `2` = on a lookalike's page, `0` = a company you gave) |
| `isNewSinceLastRun`, `previousRank`, `rankChange` | the change since your previous run (`null` on the first run) |
| `enriched` | `true` when the company's own page was read for details (only possible with **Add company details** on), otherwise `false` |
| `employees`, `followers`, `website`, `sizeBand`, `founded`, `headquarters` | only with **Add company details** on: read from the company's own page. `employees` is the headcount LinkedIn counts; `sizeBand` is what the company states about itself |
| `enrichError` | only when details were asked for and that company's page could not be read |
| `observedAt` | when the row was made |

Companies that could not be read come back as `type: "error"` rows (`seed`, `errorKind`, `message`) and are free.

Example, measured on 7 Oct 2026: given Stripe and Adyen, Revolut and Wise are on both pages (`timesListed: 2`) and come first; the other 15 are on one page each.

### Use it for

- **Account lists** — start from your best customers, get the companies that look like them, and feed the handles into your CRM or enrichment
- **Competitor and market maps** — see who LinkedIn puts next to a company, and who sits next to everyone (depth 2)
- **Watching a space** — schedule it and see which companies newly appear in a competitor's neighbourhood

### Input

```json
{ "companies": ["stripe", "https://www.linkedin.com/company/adyen"], "depth": 1, "maxCompanies": 100, "enrich": false, "includeSeeds": false }
```

- `companies` — LinkedIn company URLs or handles, one per line
- `depth` — `1` (default) reads only your companies' pages; `2` also reads the pages of the lookalikes, roughly 10 times more pages
- `maxCompanies` — the most lookalikes to return (default 100, up to 1,000); with depth 2 the Actor stops reading more pages once it has found that many
- `enrich` — read each lookalike's own page for employees, followers, website, size band, founding year and headquarters
- `includeSeeds` — also return a row for each company you gave (depth 0)

The change since the last run is remembered per set of companies and depth in a named key-value store in your Apify account (`linkedin-lookalike-history`), so the second run of the same input already shows it. Schedule it (Apify → Schedules) to keep watching.

### Pricing

**$1 per 1,000 lookalike companies**, plus $0.01 per run. With **Add company details** on, each row whose company page was read costs **$4 per 1,000** instead — one row is charged one price, never both. Error rows are free. A row whose own page could not be read comes back without the details and is charged the $1 price. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

100 lookalikes cost $0.11; 100 with company details cost $0.41.

### Notes

- Public data only: what anyone sees on a company page without signing in. Companies, not people — no names of employees, no emails, no phone numbers.
- The similar companies are **LinkedIn's own list** (usually 10 per page). The Actor adds the counting across pages, the ranking and the change tracking. Some company pages show no list; those come back as a free error row.
- `timesListed` counts only the pages that were read. With depth 2, a small `maxCompanies` stops the reading early, so the counts are then based on fewer pages.
- Pages are read at about 20 a minute (a polite, shared budget). Depth 1 with 100 companies given is 100 pages, about 5 minutes; depth 2 for one company and 100 lookalikes is roughly 10 to 20 pages; company details add one page per row. With company details on, rows are written closest first while the pages are read, so a stopped run still has the best ones.
- If LinkedIn answers "too many requests", the Actor waits 5 seconds and then 10 seconds and tries again. If four pages in a row still fail, it stops reading more pages: companies you gave that were not read come back as free error rows, and lookalikes whose details were not read come back without the details (charged the $1 price) — run it again a little later.
- `location` is empty on some cards, `founded` on companies that do not state it, `employees` on pages without a count (for example some showcase pages); `headquarters` is usually there. Empty fields are `null`, never guessed.
- The change since the last run compares with the last earlier run that read the **same pages**: the same companies, the same depth, and at depth 2 the same `maxCompanies` (it decides how many pages are read). It counts what LinkedIn listed, not only the top `maxCompanies`. If a page that was read last time could not be read this time (LinkedIn refused it, or the company is gone), nothing fair can be compared and that run shows `null`; the next normal run compares with the last normal one, so one bad day does not turn the whole list "new". A company that is simply not on LinkedIn does not switch the comparison off.
- School pages (`linkedin.com/school/…`) are accepted as input, but LinkedIn may refuse to show them without a sign-in (HTTP 999); such a school comes back as a free error row.
- Websites and plain company names are not matched here: use [Domain to LinkedIn Company URL](https://apify.com/northbell/domain-to-linkedin-company) to turn a list of websites into handles first.

For **headcount and how fast a company is growing**, see [LinkedIn Company Scraper — Headcount, Employee Growth & Details](https://apify.com/northbell/linkedin-company-growth-scraper) — its rows already carry the 10 similar companies for each company you give; this Actor is for ranking and widening them across many companies.

### For AI agents

`{"companies": ["stripe"], "maxCompanies": 20}` returns up to 20 lookalike companies as rows with `name`, `slug`, `industry`, `location` and `timesListed`; add `"enrich": true` for employees and website, `"depth": 2` for a wider net. Rows have `type`: `lookalike` or `error`. Feed `slug` values back into `companies` to walk the graph one step further.

# Actor input Schema

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

The companies to find lookalikes for. One per line: a LinkedIn company URL (linkedin.com/company/stripe) or just its handle (stripe). Websites and plain names are not matched here - use the Domain to LinkedIn Company URL Actor first.

## `depth` (type: `integer`):

1 reads only the pages of the companies you gave (about 10 lookalikes each). 2 also reads the pages of those lookalikes, so companies that many neighbours point at rise to the top - about 10 times more pages to read.

## `maxCompanies` (type: `integer`):

The most lookalike companies to return, closest first. With depth 2 the Actor also stops reading more pages once it has found this many. The companies you gave are not counted.

## `enrich` (type: `boolean`):

Read each lookalike's own company page and add employees, followers, website, size band, founding year and headquarters. One more page read per company, so the run is slower, and each such row costs $4 per 1,000 instead of $1.

## `includeSeeds` (type: `boolean`):

Also return one row per company you gave (depth 0), for example to get one combined list. Off by default: you already know these companies.

## Actor input object example

```json
{
  "companies": [
    "stripe"
  ],
  "depth": 1,
  "maxCompanies": 100,
  "enrich": false,
  "includeSeeds": false
}
```

# Actor output Schema

## `companies` (type: `string`):

Similar companies ranked by how many pages list them, with the change since the last run and optional company details.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/linkedin-lookalike-companies").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"] }

# Run the Actor and wait for it to finish
run = client.actor("northbell/linkedin-lookalike-companies").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"
  ]
}' |
apify call northbell/linkedin-lookalike-companies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northbell/linkedin-lookalike-companies"
        }
    }
}
```

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/UdRQWTj0MLrRJh2aC/builds/OqCGmvQtt1dUW8kY5/openapi.json