# Private Market Data API - Companies, Funding, Acquisitions (`nabeelbaghoor/private-market-data-api`) Actor

Search a private market database of companies, funding transactions, investors and acquisitions by sector feed, country, founding year, total raised, round type and investor. Returns company profiles, funding history and investor lists as flat rows. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/private-market-data-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 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 Market Data API

Search a private market database of companies, funding transactions, investors and acquisitions by sector feed, geography, founding year, total raised, round type and investor.

Four datasets sit behind one filter language. Search companies to build a market map, transactions to track who raised what and when, investors to profile the funds, and acquisitions to see who bought whom. A filter set written for one dataset mostly carries over to the others, which makes it practical to run the same thesis across all four.

### Four datasets

| Dataset | What it returns |
| --- | --- |
| `companies` | Company profiles with sector, geography, stage, funding and investors |
| `transactions` | Individual funding rounds with amount, currency, date and round type |
| `investors` | Investor and fund profiles |
| `acquisitions` | Acquisition events with acquirer and target |

### Filters that matter

Sector feeds are the backbone. `feedNames` uses the provider's own sector taxonomy, so Cybersecurity, Fintech and Cloud Infrastructure are values rather than free text, and picking the right feed does more to shape a result set than any other filter.

Funding filters come in pairs. `totalRaisedMin` and `totalRaisedMax` bound lifetime funding, while `roundAmountMin` and `roundAmountMax` bound a single round; the two answer different questions. `roundDateFrom` and `roundDateTo` narrow to a window, which is how you build a "who raised a Series A in Q2" list.

`investorNames` filters to companies backed by named funds, which maps a portfolio or exposes co-investment patterns without leaving the companies dataset.

Filter availability follows your subscription. A filter your subscription does not cover is rejected rather than ignored, and the error names it. Anything with no dedicated field here can be sent through the raw filter box, which is merged into the filter and wins on conflict.

### What comes back

Company rows carry the provider id, name, domain, description, founding year, country and city, stage, sector feeds, business model, employee count, total money raised, latest round category, amount and date, investor list, provider score, and profile and LinkedIn links.

Transaction rows carry the amount, currency, date and round category alongside the company they belong to. Acquisition rows carry the acquirer and target names.

Which of those a given row actually carries depends on your subscription and the dataset, so every column is read defensively and left null when the provider does not return it. Every row also carries `raw`, the untouched provider record, so nothing is lost by the flattening.

### Example output

```json
{
  "recordType": "company",
  "matched": true,
  "id": "c-1234567",
  "name": "Example Labs",
  "domain": "example.com",
  "description": "Runtime security for containerised workloads.",
  "foundedYear": 2021,
  "country": "United States",
  "city": "San Francisco",
  "stage": "Series B",
  "feedName": ["Cybersecurity", "Cloud Infrastructure"],
  "employeeCount": 148,
  "totalMoneyRaised": 62000000,
  "latestRoundCategory": "Series B",
  "latestRoundAmount": 40000000,
  "latestRoundDate": "2026-03-18",
  "investors": ["Example Ventures", "Second Fund"]
}
```

### Pricing

Pay per result. You are charged once per record saved to the dataset. Duplicates are removed before charging. Apify platform usage is included in the per-result price. Your own provider plan is billed separately by the provider.

### Bring your own API key

This actor does not include data access. You use your own access token from Tracxn, which is the provider whose API this actor calls, generated on the API token page of your provider account. The token is sent as a request header rather than as a URL parameter, so it never appears in a log line or a redirect. Tokens issued for a trial account are revoked when the trial ends, which reads exactly like a wrong token, so that is the first thing to check on an authentication error.

### FAQ

#### What is a private market data API?

A private market data API returns structured records for companies that are not publicly listed: what sector they operate in, when they were founded, how much they have raised, in which rounds, from which investors, and whether they have been acquired. It covers the part of the market that publishes no filings. This actor wraps one and turns its results into a dataset you can export as CSV, JSON or Excel, or pull from another tool.

#### How do I build a market map for one sector?

Set `feedNames` to the sector and `countries` to your geographies, sort by `totalMoneyRaised` descending, and run the companies dataset. Add `foundedYears` to isolate a cohort, or a `totalRaisedMin` to keep only companies past a funding threshold.

#### How do I find companies that raised recently?

Switch the dataset to `transactions`, set `roundDateFrom` and `roundDateTo` to the window you care about, and add `roundCategories` for the stage. Each row is one round, with amount, currency and date, rather than a company profile with its latest round attached.

#### Can I map an investor's portfolio?

Yes, two ways. Put the fund in `investorNames` and search companies, which returns the companies they back. Or search the `investors` dataset for the fund's own profile. The first is usually what people mean by a portfolio map.

#### Why is a page only 20 records?

The provider documents 20 records per call, so the actor caps the page there and pages with an offset instead. A run of a few thousand records is therefore many small requests, and the actor paces itself between them to stay inside the provider's rate limits.

#### Can I check a filter set without spending entitlement?

Yes. Switch on the playground option and every request goes to the provider's playground environment, which answers with sample data. Use it to confirm that a filter name is accepted before committing a real run.

#### Why did my run stop early?

Two common reasons. Either a page returned only records already collected, which means that dataset is not paging for your token and the actor stops rather than charging for duplicates, or the filter matched fewer records than your result limit. Both are stated plainly in the run log.

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

Up to 25,000 per run, paged at 20 records per request.

#### 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

private market data API, private company data API, startup database API, funding rounds API, venture capital data API, investor data API, acquisitions data API, M\&A data API, sector taxonomy search, company funding search API, deal sourcing API, market map data, portfolio mapping API, co-investment data, startup funding tracker, private equity data API

# Actor input Schema

## `dataset` (type: `string`):

Which dataset to search. All four share the same filter language, so a filter set written for companies mostly carries over to transactions. Which datasets you may query depends on your subscription.

## `feedNames` (type: `array`):

The provider's sector taxonomy, for example Cybersecurity, Fintech or Cloud Infrastructure. This is the primary way to scope a search, and feed names come from your own account's taxonomy.

## `countries` (type: `array`):

Country names to restrict the search to, for example United States or India.

## `cities` (type: `array`):

City names to restrict the search to.

## `foundedYears` (type: `array`):

Years the company was founded. Several values match any of them, which is how you isolate a founding cohort.

## `domains` (type: `array`):

Company domains to look up directly. A pasted URL is reduced to its domain automatically.

## `names` (type: `array`):

Company names to look up directly.

## `totalRaisedMin` (type: `integer`):

Lower bound on the total funding the company has raised across all rounds.

## `totalRaisedMax` (type: `integer`):

Upper bound on the total funding the company has raised across all rounds.

## `roundCategories` (type: `array`):

Round categories to match, for example Seed, Series A or Series B, using the names from your own account's taxonomy.

## `roundAmountMin` (type: `integer`):

Lower bound on the amount raised in a single round.

## `roundAmountMax` (type: `integer`):

Upper bound on the amount raised in a single round.

## `roundDateFrom` (type: `string`):

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

## `roundDateTo` (type: `string`):

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

## `investorNames` (type: `array`):

Only return companies backed by these investors. Useful for mapping a fund's portfolio or finding co-investment patterns.

## `advancedFilter` (type: `string`):

A raw JSON filter object merged into the filter above, for any filter your subscription supports that has no dedicated field here. List filters take arrays, numeric and date filters take a min and max object. Keys given here win. Example: {"feedName": \["Fintech"], "totalMoneyRaised": {"min": 10000000}}

## `sortBy` (type: `string`):

A field name to sort by, for example totalMoneyRaised. Leave empty for the provider's own ordering.

## `sortDirection` (type: `string`):

Direction for the sort field.

## `usePlayground` (type: `boolean`):

Send every request to the provider's playground, which answers with sample data. The right place to check a filter set before spending entitlement on a real run.

## `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. The provider documents 20 per call as the maximum, so this is capped there and a large run is simply many small pages.

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

Your own access token for the data provider, generated on the API token page of your provider account. Required. Sent as a request header and never logged or placed in a URL.

## Actor input object example

```json
{
  "dataset": "companies",
  "sortDirection": "desc",
  "usePlayground": false,
  "maxResults": 100,
  "pageSize": 20
}
```

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

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

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/private-market-data-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": 20
}' |
apify call nabeelbaghoor/private-market-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/private-market-data-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/YivUR4juV3poGvejW/builds/2mFpXhF0fcr1YbzbR/openapi.json