# Private Company Search API - Find and Enrich Companies (`nabeelbaghoor/private-company-search-api`) Actor

Search and enrich private companies by keywords, industry, employee size, headquarters location, revenue, funding and ownership. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/private-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

$15.00 / 1,000 company 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

## Private Company Search API - find and enrich private companies

**Private Company Search API** turns a private-company intelligence dataset into a clean, structured export. Search private companies by what they do, how big they are, where they are based, how much they make and who owns them, then export the matches as JSON, CSV or Excel.

Bring your own API key and pay only for the records you keep.

### Why use this actor?

- **Private-company focus** - built for private and hard-to-find companies, not just public filings.
- **Rich firmographic filters** - keywords, employee size, headquarters location, revenue, founded year, business model, ownership and end customer, all as proper fields.
- **Search or enrich** - discover companies by criteria, or enrich specific companies you already know by domain or company id.
- **Advanced escape hatch** - pass any provider filter the fields do not surface through a single raw JSON object.
- **Pay per result** - you are charged only for the records actually returned, up to 5,000 per run.
- **No proxies, no blocks** - data comes through a stable API, so runs are fast and reliable.

### Use cases

- **Deal sourcing** - build lists of private acquisition or investment targets by size, geography and model.
- **Market mapping** - map every company in a niche defined by keywords and business model.
- **Lead and account research** - find lookalike companies and enrich them with firmographics.
- **CRM enrichment** - append industry, employee size, revenue, ownership and funding to your records.
- **Competitive intelligence** - track private competitors that public databases miss.

### Input

Configure everything from the visual editor. Every filter is a proper field, no code needed.

Search by criteria:

```json
{
  "searchMode": "search",
  "keywords": "industrial automation, robotics",
  "employeesMin": 50,
  "employeesMax": 1000,
  "hqCountry": "United States",
  "revenueMin": 10000000,
  "ownership": "bootstrapped",
  "endCustomer": "b2b",
  "maxResults": 100,
  "apiKey": "YOUR_API_KEY"
}
```

Enrich known companies by domain or company id:

```json
{
  "searchMode": "enrich",
  "domain": "acme.com, example.io",
  "maxResults": 50,
  "apiKey": "YOUR_API_KEY"
}
```

#### Advanced raw filters

Some provider filters are not surfaced as fields. Pass them through `rawFilters`, a JSON object merged verbatim over the built request body (raw values win) and sent straight to the search endpoint:

```json
{
  "searchMode": "search",
  "keywords": "logistics",
  "rawFilters": {
    "employees_range": [200, 5000],
    "any_custom_provider_field": "value"
  },
  "maxResults": 100,
  "apiKey": "YOUR_API_KEY"
}
```

The actor sends your filters straight to the search endpoint, so `rawFilters` is the reliable way to use the full filter surface of your plan.

### Output

One clean JSON object per company, with the useful firmographics lifted to stable top-level fields and the full raw record preserved:

```json
{
  "company_uid": "abc123",
  "name": "Acme Robotics",
  "domain": "acme.com",
  "industry": "Industrial Automation",
  "naics": "333249",
  "employees": 420,
  "revenue": 85000000,
  "year_founded": 2011,
  "headquarters": "Austin, Texas, United States",
  "ownership": "bootstrapped",
  "funding": null,
  "end_customer": "b2b",
  "business_models": ["hardware", "saas"],
  "description": "Builds robotic automation systems for warehouses.",
  "profile_url": "https://example.com/companies/acme"
}
```

### FAQ

#### What is the Private Company Search API?

It is a private-company intelligence API. It lets you search private companies by keywords, size, location, revenue, founded year, business model, ownership and end customer, and enrich specific companies by domain or company id. This actor runs that search and exports the matches as JSON, CSV or Excel.

#### Do I need an API key?

Yes. This actor calls a private-company data API on your behalf using your own key (bring your own key). The underlying provider is Grata, and access is typically enterprise-provisioned rather than fully self-serve. Get a key from the provider, paste it into the input, and run. Your key is stored securely and never logged. You can also set it as the `DATA_API_KEY` environment secret instead of putting it in the input.

#### What is the difference between search and enrich?

Search discovers companies matching a set of criteria and pages through all the matches automatically. Enrich looks up specific companies you already know, by domain or by company id, and returns one record each.

#### What filters can I use?

Keywords and exclude-keywords, employee range, headquarters country, state and city, revenue range, founded-year range, business models, ownership and end customer. Anything not surfaced as a field can be passed through the advanced `rawFilters` JSON object, which is merged over the request body and sent straight to the search endpoint.

#### How many results can I get per run?

Up to 5,000 records per run. Search pages automatically until it reaches your **Maximum results** cap or the results run out. For larger sets, split the search by geography, size or keyword across multiple runs.

#### How much does it cost?

Pricing is pay-per-result: a small fixed amount per company record returned, plus standard Apify platform usage, plus your own API usage against your key. A run that returns nothing costs almost nothing. Set **Maximum results** to cap each run's spend exactly.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run it daily or weekly and connect the dataset to Zapier, Make, n8n, webhooks or the API to push new companies into your CRM, deal-sourcing pipeline or data warehouse.

### Keyword map

private company search api, private company data api, company intelligence api, deal sourcing api, company firmographics api, company enrichment api, lookalike company search, private company database, company discovery api, ownership and funding data api, b2b company search api, market mapping api.

### Support and feedback

Found an issue or missing a filter? Open an issue in the **Issues** tab. It is monitored daily.

# Actor input Schema

## `searchMode` (type: `string`):

Search discovers companies by criteria and pages through the matches. Enrich looks up specific companies you already know by domain or company id.

## `keywords` (type: `string`):

Comma-separated keywords describing what a company does, e.g. `industrial automation, robotics`. Companies matching any keyword are returned. Search mode only.

## `keywordsExclude` (type: `string`):

Comma-separated keywords to exclude. Companies matching any of these are filtered out. Search mode only.

## `employeesMin` (type: `integer`):

Only companies with at least this many employees. Leave blank for no lower bound.

## `employeesMax` (type: `integer`):

Only companies with at most this many employees. Leave blank for no upper bound.

## `hqCountry` (type: `string`):

Restrict to a headquarters country, e.g. `United States`. Search mode only.

## `hqState` (type: `string`):

Restrict to a headquarters state or region, e.g. `California`. Search mode only.

## `hqCity` (type: `string`):

Restrict to a headquarters city, e.g. `Austin`. Search mode only.

## `revenueMin` (type: `integer`):

Only companies with at least this estimated annual revenue in USD. Leave blank for no lower bound.

## `revenueMax` (type: `integer`):

Only companies with at most this estimated annual revenue in USD. Leave blank for no upper bound.

## `foundedMin` (type: `integer`):

Only companies founded in or after this year, e.g. `2010`. Leave blank for no lower bound.

## `foundedMax` (type: `integer`):

Only companies founded in or before this year, e.g. `2024`. Leave blank for no upper bound.

## `businessModels` (type: `string`):

Comma-separated business model tags to match, e.g. `saas, hardware, marketplace`. Search mode only.

## `ownership` (type: `string`):

Filter by ownership structure. Search mode only.

## `endCustomer` (type: `string`):

Filter by who the company sells to. Search mode only.

## `rawFilters` (type: `object`):

Advanced escape hatch. A JSON object merged verbatim over the built request body (raw values win), sent straight to the search endpoint. Use this to pass provider filters not surfaced as fields above. See the README for details. Search mode only.

## `domain` (type: `string`):

Comma-separated website domains to enrich, e.g. `acme.com, example.io`. One record is returned per resolved company. Enrich mode only.

## `companyUid` (type: `string`):

A single provider company id (uid) to enrich. Optional alternative to a domain. Enrich mode only.

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

Stop after this many records (1-5,000). Search pages automatically until this cap or the results run out. You are charged per result returned.

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

Your company data provider API key. Required. Provisioned by the provider (enterprise access). Stored securely and never logged.

## Actor input object example

```json
{
  "searchMode": "search",
  "ownership": "any",
  "endCustomer": "any",
  "maxResults": 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
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/private-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 }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/private-company-search-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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
}' |
apify call nabeelbaghoor/private-company-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nabeelbaghoor/private-company-search-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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