# Startup Funding Data API - Companies, Rounds and Investors (`nabeelbaghoor/startup-funding-data-api`) Actor

Search a startup and scaleup database by industry, sub-industry, headquarters location, business model, launch year and keyword, then pull funding totals, rounds, valuations and investors as flat rows. Includes investor search and funding round search. Pay per result. Bring your own API key.

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

## Startup Funding Data API

Search a startup and scaleup database by industry, headquarters location, business model and launch year, and pull funding totals, rounds, valuations and investors as flat rows.

Public company data is easy to find. The interesting private companies, the ones that are three years old and have raised once, are not in any filing you can query. This actor wraps an ecosystem database built for exactly those: it tracks companies, the rounds they raise, the funds that back them and how all three connect.

### Four modes

| Mode | What it does | What you give it |
| --- | --- | --- |
| `company-search` | Finds companies by industry, location, business model, launch year or keyword | Filters, a keyword, or both |
| `company-lookup` | Reads full profiles for ids you already hold | A list of company ids |
| `investor-search` | Finds funds and their profiles | The same filter envelope |
| `transaction-search` | Finds funding rounds | The same filter envelope |

### Filters that matter

`industries` and `subIndustries` are the primary axis, and they nest: pick fintech at the industry level and payments at the sub-industry level to narrow inside it. `hqLocations` accepts cities, countries and regions, so Berlin, Germany and Europe are all valid values at different widths. `businessModels` separates a SaaS company from a marketplace in the same sector. `launchYears` is how you isolate a founding cohort.

`lastUpdatedAfter` is the one to reach for on a schedule. Set it to the timestamp of your last run and the search only returns records that changed since, which keeps a recurring pull small.

Which filters your account may use depends on your plan. A filter your plan does not include is rejected outright rather than quietly ignored, and the error names it, so a failed run tells you exactly which filter to drop.

### What comes back

Rows carry the provider id, name, profile path and a link to the profile; website, tagline and description; company status, type, launch year and employee count; headquarters locations, country and city; industries, sub-industries, business models and tags; total funding, last funding date, last round type, funding round count and valuation; growth stage; investor names and a count of them; and LinkedIn and Twitter profiles. Funding round rows additionally carry the amount, currency, date and round name.

Which of those a given row actually carries depends on your plan and on the field selection, 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": 1234567,
  "name": "Example Labs",
  "path": "companies/example_labs",
  "profileUrl": "https://app.dealroom.co/companies/example_labs",
  "websiteUrl": "https://example.com",
  "tagline": "Battery recycling for grid storage operators",
  "launchYear": 2021,
  "employees": "51-200",
  "hqLocations": ["Berlin"],
  "industries": ["energy"],
  "subIndustries": ["battery tech"],
  "businessModels": ["saas"],
  "totalFunding": 32000000,
  "lastRoundType": "SERIES B",
  "lastFundingDate": "2026-02-11",
  "fundingRoundsCount": 3,
  "growthStage": "scaling",
  "investors": ["Example Ventures", "Second Fund"],
  "lastUpdated": "2026-07-30"
}
```

### Pricing

Pay per result. You are charged once per record saved to the dataset. Duplicates are removed before charging, and an id that resolves to nothing is stored with `matched: false` free of charge, so a list of dead ids costs you nothing. 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 API key from Dealroom, which is the provider whose API this actor calls. The key is sent in the `Authorization` request header rather than as a URL parameter, so it never appears in a log line or a redirect. API access is arranged with the provider directly, through their sales team or your account manager.

### FAQ

#### What is a startup funding data API?

A startup funding data API returns structured records for private, venture-backed companies: what they do, where they are, when they were founded, how much they have raised, in which rounds, and from which investors. It covers the companies that publish no financial statements and therefore appear in no filing-based dataset. 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 deal sourcing list?

Run `company-search` with `industries` and `subIndustries` set to your thesis, `hqLocations` set to the geographies you invest in, and `launchYears` set to the founding cohort you target. Add `lastUpdatedAfter` and schedule the run so each pull only returns companies whose profiles changed since the last one.

#### Can I get the investors behind a company?

Yes. Company rows carry an investor name list and a count where your plan includes them. To go the other way, `investor-search` returns fund profiles, and `transaction-search` returns the individual rounds with amount, currency, date and round name.

#### How do I track a market rather than a company?

Search by industry and sub-industry with no keyword, sort by last funding date, and run it on a schedule with `lastUpdatedAfter`. The rows you get back each time are the companies in that market that moved, which is a far more useful signal than the whole market re-exported every week.

#### Why did my run stop after one page?

Not every plan pages every endpoint. When a second page returns only records the run has already collected, the actor recognises that the offset was not applied, logs it plainly, and stops rather than looping over the same rows and charging for duplicates. Narrowing the filters is the way to reach different records in that case.

#### Why was my filter rejected?

Filter availability follows your plan. Where a filter is not included, the API rejects the request and names the field rather than dropping it silently. Remove that filter, or use the advanced filters box to send only the ones your plan covers.

#### Can I send a filter this actor does not have a field for?

Yes. The advanced filters box takes a raw JSON object that is merged into the filter block, so any filter your plan supports can be sent even when there is no dedicated input for it. Keys you set there win over the fields above.

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

Up to 25,000 per run, requested in pages of up to 250, subject to what your own plan allows per request and whether it pages the endpoint you are querying.

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

startup funding data API, venture capital data API, startup database API, private company data API, funding rounds API, investor data API, deal sourcing API, company funding search, startup search API, scaleup data API, tech ecosystem data API, valuation data API, growth stage company data, VC deal flow API, private market data API, funding round tracker

# Actor input Schema

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

What this run does. Company search finds startups and scaleups by industry, location, business model and keyword. Company lookup reads full profiles for ids you already hold. Investor search finds funds and their profiles. Transaction search finds funding rounds.

## `keyword` (type: `string`):

Free-text search across the profile. Works on its own or alongside the filters below.

## `keywordMatchType` (type: `string`):

How strictly the keyword is matched. Fuzzy tolerates spelling differences and widens the result set.

## `companyIds` (type: `array`):

The provider company ids to read full profiles for. These are the id values the company search returns. Lookup mode only.

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

Industry names from the provider taxonomy, for example fintech, health, energy. Several values widen the search.

## `subIndustries` (type: `array`):

Narrower categories beneath the industries above, for example payments or insurtech.

## `hqLocations` (type: `array`):

Places the company is headquartered in. Accepts cities, countries and regions, for example London, Germany or Europe.

## `businessModels` (type: `array`):

Business model tags from the provider taxonomy, for example saas or marketplace.

## `launchYears` (type: `array`):

The year the company was founded. Several values match any of them.

## `companyType` (type: `string`):

The provider's company type flag, used to separate operating companies from other entities on the platform.

## `lastUpdatedAfter` (type: `string`):

Only return records the provider changed after this timestamp, in the provider's format such as 2026-04-01 00:00:00. This is the filter to use for a recurring run that should only pick up what has changed.

## `advancedFilters` (type: `string`):

A raw JSON object merged into the filter block alongside the fields above, for any filter your plan supports that is not listed here, such as funding round or growth stage filters. Keys given here win. Example: {"industries": "fintech", "employees\_latest": {"min": 50}}

## `advancedFormData` (type: `string`):

A raw JSON object merged into the search envelope one level above the filters, for envelope-level keys other than the updated-after cut-off. Most searches do not need this.

## `fields` (type: `array`):

Field names to return, for example id, name, path, website\_url. Leave empty to take the provider's own default selection, which is the safer choice since an unknown field name is rejected.

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

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

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

Direction for the sort field. Descending is sent as a leading minus on the field name, which is the provider's convention.

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

Leave unresolved ids 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 250). Lower this if the provider rejects large pages on your plan.

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

Your own API key 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",
  "keywordMatchType": "default",
  "sortDirection": "desc",
  "skipUnmatched": false,
  "maxResults": 100,
  "pageSize": 50
}
```

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/startup-funding-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/G4jJIgcXYIEtFNyBt/builds/w0xiLNAhWO0l8t8M5/openapi.json