# Crunchbase Company API — Company & Funding Profiles (`khadinakbar/crunchbase-company-api`) Actor

Look up Crunchbase organization URLs for company enrichment and investment research. Export company profiles with available funding, investors, industries, headquarters, employee bands and source URLs. Process deduplicated batches with explicit limits. Pay per event plus platform usage.

- **URL**: https://apify.com/khadinakbar/crunchbase-company-api.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 company profiles

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Crunchbase Company API

Look up public Crunchbase organization URLs and receive one source-linked JSON record per successfully collected company. Use the actor for CRM enrichment, investment research and comparing a known list of companies by industry, headquarters, employee band and available funding information.

Provider collection times vary. Review OUTPUT and RUN_SUMMARY before using the collected profiles, and choose a deadline that matches your workflow.

### Input and quick start

### Workflow: from profile URLs to CRM account research

A sales operations analyst starts with Crunchbase profile links already attached to CRM accounts. Submit those URLs as a batch, join each returned row on `companyUrl`, and use the industry, employee band and institutional investor fields to prepare account research. An investment analyst can repeat the same workflow for a known shortlist, preserving `fetchedAt` with each comparison.

Use when you already have company profile URLs and need company-level enrichment. Avoid when your starting input is only a name or domain, or you need personal contacts. Start with URL discovery for a broad company search. This actor accepts organization profile URLs; company names, website domains, person pages and arbitrary websites need a different starting tool.

```json
{
  "companyUrls": ["https://www.crunchbase.com/organization/stripe"],
  "maxCompanies": 1,
  "batchSize": 1,
  "deadlineSecs": 240
}
```

Send up to 1,000 input URLs. Duplicates, tracking parameters and profile tabs normalize to the same company before the result limit is applied. `maxCompanies` defaults to 50; `batchSize` defaults to 5 and supports 1–10; `deadlineSecs` defaults to 240 and supports 60–900. The actor stops scheduling work when the remaining profile charge allowance is exhausted. Individual page requests are bounded to 60 seconds. Prefer the asynchronous Apify API for batches; collection stops after an upstream failure to preserve useful work and bound additional source spending.

### Company output

Each row contains `companyUrl`, `name`, `fetchedAt` and `provider`. Optional source fields are omitted when unavailable. They remain source observations, not independently verified company disclosures.

| Fields | Meaning |
| --- | --- |
| `description`, `website`, `legalName` | Company overview and business identity |
| `hqLocation`, `region`, `country` | Headquarters labels |
| `employeeCount`, `industries` | Employee band and industry names |
| `operatingStatus`, `companyType`, `ipoStatus`, `cbRank` | Company status and source rank |
| `numFundingRounds`, `lastFundingType`, `numInvestors`, `numLeadInvestors` | Available funding and investor counts |
| `fundingRounds`, `investors` | Funding types/stages and organization investor names |
| `totalFunding`, `totalFundingCurrency` | A company-level total only when the source explicitly supplies it |
| `numAcquisitions`, `acquisitions` | Available business acquisition details |
| `monthlyVisits`, `monthlyVisitsGrowth`, `growthScore`, `heatScore` | Source business signals when available |
| `fetchedAt`, `provider` | Retrieval time and source provider |

Example from a collected Stripe profile, trimmed for length:

```json
{
  "companyUrl": "https://www.crunchbase.com/organization/stripe",
  "name": "Stripe",
  "fetchedAt": "2026-10-14T12:12:14.728Z",
  "employeeCount": "5001-10000",
  "country": "United States",
  "numInvestors": 75,
  "numFundingRounds": 24,
  "lastFundingType": "secondary_market"
}
```

Export the dataset as JSON, CSV or Excel through Apify. Retrieve larger datasets with Apify's `offset` and `limit` pagination. Output order follows completed provider jobs; join rows by `companyUrl` rather than array position. `fetchedAt` is the retrieval time, while individual source metrics may refer to an earlier reporting period. A funding-round entry can contain investor names without a monetary amount. Industry-wide featured-list totals are never reused as a company's total funding.

### Additional business intelligence and source coverage

Profiles also preserve the source's detailed description, company logo, stock symbol, public company social links, headquarters regions, website technologies, products, suggested similar companies and recent news when those values are present. Growth and heat trends retain the source scale. `trafficAsOf` records the reporting date for traffic metrics separately from `fetchedAt`.

Use the business-intelligence view for company research and the source-quality view for checking coverage. `availableFields` lists returned source values, `missingFields` identifies unavailable optional values, and `fundingAmountAvailability` distinguishes a supplied amount from a supplied amount with currency. These coverage fields describe the source response; they are not a company accuracy score. A profile remains one billed company even when it includes related-company references or news.

### Optional cached profiles

Set `cacheMaxAgeHours` to 1–24 to reuse public business data collected by your account. Default 0 requests fresh data. `cacheHit` identifies reuse and `sourceFetchedAt` preserves the original observation time. Every saved profile, including cache hits, counts as one company-profile event. Cache storage usage is charged by Apify.

### Pricing: Pay per event and platform usage

Pricing is **$12 per 1,000 saved profiles** plus a **$0.00005 startup event** and platform usage. It uses **Pay per event** for one validated, saved company profile, plus **Apify platform usage** as selected by the owner. Apify applies an automatic startup event. Refer to the live [Pricing tab](https://apify.com/khadinakbar/crunchbase-company-api/pricing) for effective rates after cloud configuration.

For example, 10 records cost $0.12005 in events, plus platform usage. For a run saving K profiles, estimate event cost as K × the profile-event rate + the automatic startup event, then add platform usage. Company-profile events apply only to validated, saved profiles. The startup event and actual platform work can still cost money. Set Apify's maximum total charge and use `maxCompanies` to limit scheduled profiles. An active page request can finish within its 60-second request limit after the scheduling deadline.

### Call through the Apify API

Store your Apify token in `APIFY_TOKEN`. Create a run with the asynchronous endpoint, inspect its status, then read `OUTPUT` and the dataset using the returned storage IDs.

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/khadinakbar~crunchbase-company-api/runs?memory=256&timeout=960&maxTotalChargeUsd=0.10' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"companyUrls":["https://www.crunchbase.com/organization/stripe"],"maxCompanies":1,"batchSize":1,"deadlineSecs":900}'
```

Get the run at `GET /v2/actor-runs/{runId}`. After it ends, read `GET /v2/key-value-stores/{defaultKeyValueStoreId}/records/OUTPUT` and `GET /v2/datasets/{defaultDatasetId}/items?format=json&offset=0&limit=100`, using the Authorization header on each request. These private-candidate endpoints become usable after deployment and provider configuration.

### Agent prompt card

> Look up the supplied Crunchbase organization URLs with this actor. Limit work to the requested companies and set a spending cap. Read OUTPUT and RUN_SUMMARY, then read the dataset. Return company name, source URL, employee band, industry, headquarters and institutional investors where present. Preserve retrieval time and report missing profiles and collection diagnostics separately. Keep funding totals and currency tied to the explicitly supplied source fields.

The schemas are structured for agent consumption. Hosted MCP client execution is pending validation; use the [Apify MCP configurator](https://mcp.apify.com) when connecting a supported client and inspect the current tool schema before calling it. Direct API execution and a successful hosted MCP client test are separate checks.

### Best results and outcome recovery

`OUTPUT` gives the stable outcome and counts. `RUN_SUMMARY` adds processed inputs, safe provider diagnostics, billing counts, limits and estimated reserved provider costs.

| Outcome | Meaning and next step |
| --- | --- |
| `COMPLETE` | All selected companies were saved; consume the dataset. |
| `PARTIAL` | Useful profiles were saved, with omissions, failures or a reached limit; inspect the summary. |
| `VALID_EMPTY` | The cap allowed no profile work. |
| `INVALID_INPUT` | Correct the listed input requirement and start a new run. |
| `UPSTREAM_FAILED` | No useful profile was returned; inspect provider diagnostics and a pending job in STATE. |
| `CONFIG_ERROR` | Resolve owner provider configuration or an uncertain side effect before retrying. |

The actor persists completed-company checkpoints and a write/charge ledger in `STATE`. Resurrecting the same run with unchanged input/build preserves completed work. An uncertain submission or dataset write blocks paid replay until its actual result is reconciled; this is a duplicate-work guard, not an exactly-once guarantee. A fresh run submits fresh work. Keep storage retention appropriate for your research or CRM workflow and delete run storage through Apify when it is no longer needed.

### Builder's note

I found that a bounded public-page route returned the same company much faster than the long asynchronous source job. Public company cards include nested funding summaries and object-valued industry labels. This implementation maps those structures explicitly, and validates the source URL against the requested company before saving a row. The actor validates company identity and useful business fields before saving and billing each profile.

### Responsible use, data handling and brand disclosure

Collection is limited to public organization profiles. The actor uses an owner-managed provider credential supplied through its encrypted runtime environment. Credentials, provider inputs, personal contacts, individual investor identities and partner details are excluded from the dataset, OUTPUT and logs. Company-level business data is stored in the run's dataset; STATE contains canonical target URLs, job handles and reconciliation metadata.

Crunchbase is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by Crunchbase. Use the results only where your collection and downstream use comply with applicable laws, site terms and data rights.

### Verification and source freshness

The public-page mapping was checked against a retrieved Stripe company page on 2026-10-15. The local suite covers identity validation, cache behavior, spending limits and checkpoint recovery. Source coverage varies by company; review the final cloud-run evidence before production use.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/crunchbase-company-api/changelog.md

# Actor input Schema

## `companyUrls` (type: `array`):

Provide public Crunchbase organization URLs. Duplicates and profile tabs normalize before limits.

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

Limit the unique company URLs processed in this run. Default 50, maximum 1,000. Duplicates are removed before applying this limit. Omitted inputs are reported in RUN_SUMMARY.

## `batchSize` (type: `integer`):

Legacy upper bound for request grouping. Company pages are collected individually to preserve completed work and isolate failures.

## `deadlineSecs` (type: `integer`):

Bound collection work to 60–900 seconds. Default 240. Each page request is limited to 60 seconds. Useful completed profiles remain available if the deadline is reached.

## `cacheMaxAgeHours` (type: `integer`):

Use a sanitized profile from this caller account when it is no older than 0–24 hours. Default 0 fetches fresh data. Cache hits retain sourceFetchedAt and still count as delivered company profiles.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.crunchbase.com/organization/stripe"
  ],
  "maxCompanies": 50,
  "batchSize": 5,
  "deadlineSecs": 240,
  "cacheMaxAgeHours": 0
}
```

# Actor output Schema

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

Download validated company profiles as JSON.

## `output` (type: `string`):

Read the terminal outcome and saved counts.

## `summary` (type: `string`):

Read provider outcomes, counts, limits and safe diagnostics.

# 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 = {
    "companyUrls": [
        "https://www.crunchbase.com/organization/stripe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/crunchbase-company-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 = { "companyUrls": ["https://www.crunchbase.com/organization/stripe"] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/crunchbase-company-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 '{
  "companyUrls": [
    "https://www.crunchbase.com/organization/stripe"
  ]
}' |
apify call khadinakbar/crunchbase-company-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/crunchbase-company-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/XVyx4Gq1M0V9PPx32/builds/TEFjnCP6kELUgJc27/openapi.json