# Lookalike Company Search API - Find Similar Companies (`nabeelbaghoor/lookalike-company-search-api`) Actor

Find companies that look like your best customers. Search a B2B company database by lookalike domain, industry, technology stack, headcount, revenue, funding and location, enrich domains you already hold, and pull the people behind each account. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/lookalike-company-search-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Business, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$14.00 / 1,000 results

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/platform/actors/running/actors-in-store#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

## Lookalike Company Search API

Give it the domains of your best customers and get back companies that look like them, scored, filtered and flattened into rows you can export.

Most company search APIs make you describe your ideal customer in filters and hope the filters are the thing that made those customers good. This one starts from the customers themselves: it reads what a company's website actually says it does and finds others that say something similar. Structured filters for industry, technology stack, headcount, revenue, funding and location sit on top of that, so you can narrow a semantic result set the ordinary way.

### Four modes

| Mode | What it does | What you give it |
| --- | --- | --- |
| `company-search` | Returns full company records, cursor-paged | Lookalike domains and/or filters |
| `company-preview` | Counts how many companies match and returns a small sample | The same filters |
| `company-enrich` | Resolves domains you already hold into full records | A list of domains |
| `people-search` | Returns individual contacts at matching companies | People filters, company filters |

Run `company-preview` first. It reports the total match count for a filter set and returns a handful of example companies, so you can size an audience and sanity check the filters before committing to a full paged search.

### What comes back

Company rows carry name, legal name, domain, root URL, description and logo; size as a headcount band, an employee count and a LinkedIn employee count; revenue band and founding year; headquarters country, city, region, postcode and street, plus every country the company operates in and a location count; industries, industry categories, the LinkedIn industry and free-text keywords; the detected technology stack and its categories; emails and phone numbers; LinkedIn, Twitter, Facebook, Instagram and YouTube profiles; estimated monthly visits, page views and pages per visit; last funding date, type, amount in USD and Crunchbase link; headcount growth over three, six and twelve months; department headcounts; and the provider's last update date.

Person rows carry name, first and last name, job title and its English translation, computed seniorities and departments, current job description, headline, summary, skills, country, state, location, LinkedIn profile, photo, email and phone where held, connection and follower counts, and the domain of the company they were found at.

Lookalike results also carry `similarityScore` between 0 and 1, and `relevance` as an A, B or C band.

Every row carries `raw`, the untouched provider record, so nothing is lost by the flattening.

### Example output

```json
{
  "recordType": "company",
  "matched": true,
  "domain": "example.com",
  "name": "Example Labs",
  "legalName": "Example Labs, Inc.",
  "description": "Battery recycling software for grid storage operators.",
  "companySize": "51-200",
  "employeeCountLinkedin": 148,
  "revenue": "10-50M",
  "yearFounded": 2018,
  "primaryCountry": "us",
  "hqCity": "Oakland",
  "hqRegion": "California",
  "industries": ["Climate Tech", "Industrial Software"],
  "technologies": ["Segment", "Snowflake", "HubSpot"],
  "technologyCategories": ["Analytics", "CRM"],
  "primaryEmail": "hello@example.com",
  "linkedinUrl": "https://www.linkedin.com/company/example-labs",
  "webTrafficVisits": 41200,
  "lastFundingType": "Series B",
  "lastFundingAmountUsd": 32000000,
  "lastFundingDate": "2026-02-11",
  "headcountGrowthTwelveMonths": 39,
  "similarityScore": 0.94,
  "updatedAt": "2026-07-28T09:14:02Z"
}
```

### Pricing

Pay per result. You are charged once per record saved to the dataset. Duplicates are removed before charging, and a domain that resolves to nothing is stored with `matched: false` free of charge, so a list of dead domains costs you nothing. Apify platform usage is included in the per-result price. Your own provider plan is billed separately by the provider, and each run logs how many provider credits it consumed.

### Bring your own API key

This actor does not include data access. You use your own API token from Ocean.io, which is the provider whose API this actor calls. The token is sent as the `x-api-token` request header rather than as a URL parameter, so it never appears in a log line or a redirect.

### FAQ

#### What is a lookalike company search API?

A lookalike company search API takes one or more companies you already value and returns others that resemble them, rather than making you write filters that approximate what made them a fit. This provider compares website content semantically, so two companies match when they describe similar products and services, not merely because they share an industry label. This actor wraps that API and turns its results into a dataset you can export as CSV, JSON or Excel, or pull from another tool.

#### How do I build an ideal customer profile list from my existing customers?

Put up to ten of your best customer domains in `lookalikeDomains` and run `company-preview`. Read the total match count, then tighten with `hqIncludeCountries`, `companySizes` and `excludeDomains` for the customers you already have. When the count looks right, switch to `company-search` and raise `maxResults`.

#### What is the difference between precise and broad matching?

`precise` compares what the companies actually sell, using semantic similarity of their website content, and returns a tight set. `broad` matches anything inside the same industries and returns a far larger set. Start precise. Move to broad only when precise returns too few companies to work with.

#### Can I filter companies by the software they use?

Yes. `technologiesAny`, `technologiesAll` and `technologiesNone` filter on software detected on the company website, and `technologyCategoriesAny` filters on broader groupings such as Analytics or Security. Excluding a competitor's product with `technologiesNone` is the usual way to strip out accounts that are already committed elsewhere.

#### How do I find decision makers at the companies I just found?

Run `people-search` with the same company filters plus `seniorities` set to Founder, C-Level or VP, and `jobTitleKeywordsAny` for the function you want. Set `peoplePerCompany` to cap how many contacts come back from each account so one large company does not consume the whole run.

#### How does pagination work?

Paging is a cursor, not an offset. Each response carries a `searchAfter` value that the next request sends back, and a response without one means the result set is finished. The actor handles this for you and simply stops when the provider runs out of pages or `maxResults` is reached.

#### Why are some of my lookalike domains ignored?

A seed domain is only usable if the provider already holds enough content for it. Domains that are missing, still being crawled, or lacking a usable content vector are listed in the run log with the reason, and the search proceeds on the remaining seeds. Adding more seeds is the fix.

#### How many results can one run return?

Up to 25,000 per run, paged at up to 1,000 records per request. Preview mode is capped by the provider at 50 sample companies, but reports the full match count regardless of that cap.

#### Do I need my own API key?

Yes. This actor is bring your own key, and your usage is billed on your own provider plan. The actor charges separately for each result it returns.

### Keyword map

lookalike company search API, similar companies API, ideal customer profile API, ICP builder API, B2B company data API, company search API, company enrichment API, domain to company API, technographics API, technology stack lookup API, firmographics API, company funding data API, B2B prospecting API, account based marketing data, sales prospecting API, contact data API, people search API

# Actor input Schema

## `mode` (type: `string`):

What this run does. Company search returns full company records page by page. Preview only counts how many companies match and returns a small sample, which is the cheap way to size an audience first. Company enrichment resolves domains you already hold. People search returns individual contacts at the companies your filters describe.

## `lookalikeDomains` (type: `array`):

Up to 10 domains of companies you already like. The provider finds semantically similar companies from their website content, which is the core of this API. Leave empty to search on the structured filters alone.

## `companyMatchingMode` (type: `string`):

How strictly lookalike domains are matched. Precise uses semantic similarity of products and services. Broad matches anything in the same industries and returns a much wider set.

## `includeDomains` (type: `array`):

Restrict the result set to these domains. Useful for re-running a known list through the same field selection.

## `excludeDomains` (type: `array`):

Remove these domains from the results, for example customers you already have.

## `enrichDomains` (type: `array`):

The domains to resolve into full company records. One provider call per domain. Enrichment mode only.

## `industries` (type: `array`):

Industry names from the provider vocabulary, such as Advertising Platforms or Biopharma. The full list is served by the provider's data fields endpoint.

## `industriesMode` (type: `string`):

Any of matches a company carrying at least one of the industries. All of requires every one of them.

## `excludeIndustries` (type: `array`):

Industries to remove from the results.

## `industryCategories` (type: `array`):

Broader groupings above industries, such as Real Estate or Hardware.

## `industryCategoriesMode` (type: `string`):

Whether a company must carry any or all of the listed categories.

## `excludeIndustryCategories` (type: `array`):

Industry categories to remove from the results.

## `linkedinIndustries` (type: `array`):

The industry as stated on the company's LinkedIn page, such as Computer Software. This is an any-of filter.

## `excludeLinkedinIndustries` (type: `array`):

LinkedIn industries to remove from the results.

## `keywordsAny` (type: `array`):

Match a company carrying at least one of these keywords. Widens the result set.

## `keywordsAll` (type: `array`):

Require every one of these keywords. Narrows the result set sharply.

## `keywordsNone` (type: `array`):

Remove companies carrying any of these keywords.

## `companySizes` (type: `array`):

Headcount bands, as defined by the provider. Select as many as you need.

## `revenues` (type: `array`):

Estimated annual revenue bands in USD.

## `employeeCountFrom` (type: `integer`):

Lower bound on the number of employees linked to the company's LinkedIn page.

## `employeeCountTo` (type: `integer`):

Upper bound on the number of employees linked to the company's LinkedIn page.

## `yearFoundedFrom` (type: `integer`):

Earliest founding year, for example 2015.

## `yearFoundedTo` (type: `integer`):

Latest founding year, for example 2024.

## `ecommerce` (type: `string`):

Whether to keep only e-commerce companies, exclude them, or ignore the distinction.

## `hqIncludeCountries` (type: `array`):

Two letter lowercase ISO 3166 country codes for the company headquarters, for example us, gb, de.

## `hqExcludeCountries` (type: `array`):

Two letter lowercase ISO 3166 country codes to exclude from the headquarters filter.

## `officeIncludeCountries` (type: `array`):

Countries where the company has an office other than the headquarters. Use this to find companies with a presence in a market rather than a head office there.

## `officeExcludeCountries` (type: `array`):

Countries whose offices should disqualify a company.

## `countriesCountFrom` (type: `integer`):

Lower bound on how many countries the company operates in. A quick proxy for international reach.

## `countriesCountTo` (type: `integer`):

Upper bound on how many countries the company operates in.

## `locationsCountFrom` (type: `integer`):

Lower bound on the number of offices or sites the company has.

## `locationsCountTo` (type: `integer`):

Upper bound on the number of offices or sites the company has.

## `technologiesAny` (type: `array`):

Software detected on the company website, matched if any one is present. Names come from the provider's technology vocabulary.

## `technologiesAll` (type: `array`):

Require every one of these technologies on the website.

## `technologiesNone` (type: `array`):

Exclude companies running any of these technologies, for example a competitor's product.

## `technologyCategoriesAny` (type: `array`):

Broader technology groupings such as Analytics, Security or Advertising.

## `technologyCategoriesNone` (type: `array`):

Technology categories that disqualify a company.

## `fundingRoundTypes` (type: `array`):

Match companies whose latest known round is one of these types.

## `fundingRaisedFrom` (type: `integer`):

Lower bound on the amount raised in the funding round.

## `fundingRaisedTo` (type: `integer`):

Upper bound on the amount raised in the funding round.

## `fundingDateFrom` (type: `string`):

Earliest funding round date, as an ISO date such as 2024-01-01.

## `fundingDateTo` (type: `string`):

Latest funding round date, as an ISO date such as 2026-01-01.

## `webTrafficVisitsFrom` (type: `integer`):

Lower bound on estimated monthly website visits. A practical size signal when headcount is missing.

## `webTrafficVisitsTo` (type: `integer`):

Upper bound on estimated monthly website visits.

## `webTrafficViewsFrom` (type: `integer`):

Lower bound on estimated monthly page views.

## `webTrafficViewsTo` (type: `integer`):

Upper bound on estimated monthly page views.

## `updatedWithinMonths` (type: `integer`):

Only return companies the provider refreshed in the last N months, up to 60. Use this to keep a recurring run away from stale records.

## `minRelevance` (type: `string`):

Relevance band floor for lookalike searches, where A is the most relevant.

## `maxRelevance` (type: `string`):

Relevance band ceiling. Set minimum and maximum to the same letter to take exactly one band.

## `fieldsExist` (type: `array`):

Only return companies where these fields are populated, for example emails or locations. A cheap way to keep an export usable.

## `fieldsNotExist` (type: `array`):

Only return companies where these fields are missing.

## `seniorities` (type: `array`):

Seniority levels computed from the person's job title. People search, or as a company filter meaning the company employs at least one such person.

## `jobTitleKeywordsAny` (type: `array`):

Match a person whose job title carries at least one of these words.

## `jobTitleKeywordsAll` (type: `array`):

Require every one of these words in the job title.

## `jobTitleKeywordsNone` (type: `array`):

Exclude people whose job title carries any of these words.

## `skillsAny` (type: `array`):

Match a person whose LinkedIn profile lists at least one of these skills.

## `skillsAll` (type: `array`):

Require every one of these skills on the profile.

## `skillsNone` (type: `array`):

Exclude people whose profile lists any of these skills.

## `peopleCountries` (type: `array`):

Two letter lowercase ISO 3166 country codes for where the people are, which is not always where the company is.

## `lookalikeLinkedinHandles` (type: `array`):

LinkedIn handles of people you already want more of. The provider returns similar profiles. A handle is the last part of the profile URL.

## `includeLinkedinHandles` (type: `array`):

Restrict the people search to these handles.

## `excludeLinkedinHandles` (type: `array`):

Remove these people from the results.

## `peoplePerCompany` (type: `integer`):

Cap how many people are returned from each company, 1 to 20. Leave empty to take everyone who matches. People search only.

## `advancedCompanyFilters` (type: `string`):

A raw JSON object merged into the company filter tree, for filters beyond the fields above such as departmentSizes, headcountGrowth, mobileAppsFilter or socialMedias. Keys given here win over the fields above. Example: {"headcountGrowth": {"months": "Three months", "growthRange": {"from": 5}}}

## `advancedPeopleFilters` (type: `string`):

A raw JSON object merged into the people filter tree, for filters beyond the fields above such as states, currentJobDescription or profileDescription. Example: {"states": \[{"abbreviation": "NY", "country": "us"}]}

## `skipUnmatched` (type: `boolean`):

Leave unresolved domains out of the dataset entirely. By default they are stored with matched set to false, which is free, so you can see exactly which inputs failed to resolve.

## `maxResults` (type: `integer`):

Stop after this many records (1 to 25,000). You are charged per record returned.

## `pageSize` (type: `integer`):

How many records to request per call (1 to 1000). Larger pages mean fewer round trips. Preview mode clamps this to the provider's 5 to 50 range.

## `apiKey` (type: `string`):

Your own API token for the data provider. Required. Sent as a request header and never logged or placed in a URL.

## Actor input object example

```json
{
  "mode": "company-search",
  "companyMatchingMode": "precise",
  "industriesMode": "anyOf",
  "industryCategoriesMode": "anyOf",
  "ecommerce": "any",
  "skipUnmatched": false,
  "maxResults": 100,
  "pageSize": 100
}
```

# 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 = {
    "maxResults": 100,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/lookalike-company-search-api").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 = {
    "maxResults": 100,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/lookalike-company-search-api").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 '{
  "maxResults": 100,
  "pageSize": 100
}' |
apify call nabeelbaghoor/lookalike-company-search-api --silent --output-dataset

```

## MCP server setup

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

```

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/09ZteWP3SrEx8gtzZ/builds/vt0KILkP6AjF4d8m1/openapi.json