# Crunchbase Scraper \[$4💰] | Funding Rounds | Investors (`ahmed_jasarevic/crunchbase-scraper`) Actor

Scrape Crunchbase company profiles from any URL or slug: funding rounds, investors, total funding, employee count, industries, location, social links and IPO status. Export as JSON, CSV or Excel. No API key, no login.

- **URL**: https://apify.com/ahmed\_jasarevic/crunchbase-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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/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 Scraper — Company Funding Rounds, Investors & Firmographics Data

Get structured [Crunchbase](https://www.crunchbase.com) company data for **from $0.004 per company** — funding rounds with dates and amounts, lead investors, total funding, employee count, industries and IPO status, delivered as clean JSON from any organization URL or slug. No API key, no login, no browser, no Crunchbase Enterprise contract.

### Main Use Cases — Funding Data, Market Research & Lead Generation

- **VC deal sourcing & investor research** — pull funding history and lead investors for a watchlist of startups and investor firms in minutes.
- **Startup market research** — map industries, stages, locations and funding totals across a portfolio of companies for ecosystem analysis.
- **B2B lead generation & ABM account list building** — export name, website, size, industry, location and social links for outreach tooling.
- **Startup funding monitoring** — schedule recurring runs to track new funding rounds and investors over time.
- **M\&A and IPO tracking** — record acquisition status and IPO events alongside funding history.
- **Company database building** — assemble structured company intelligence (firmographics + funding) exportable to Excel, CSV or your CRM.

### How the Extraction Works: Snapshots, TLS Impersonation, No Browser

This Actor accepts a list of Crunchbase organization page URLs (or bare slugs) and returns one JSON record per company. Each profile is fetched with a 3-stage strategy — (1) the newest archived snapshot of the live page (embeds full funding state, including round amounts and dates, typically ~1 second), (2) the live Crunchbase page via fast TLS fingerprint impersonation, and (3) a plain stealth fetch with residential proxy rotation. The first strategy that returns real data wins, and no headless browser is launched — the pipeline parses HTML with Cheerio over plain HTTP. Typical runs finish a company in well under a second to a few seconds.

Crunchbase sits behind Cloudflare's managed challenge, which re-challenges even a solved browser session, so this Actor deliberately avoids heavy anti-bot tricks: by default it serves each profile from an archived snapshot when one exists and only hits the live site when a snapshot is missing.

### Scrape Company Profiles From Any Crunchbase Organization URL

Input takes full organization URLs (`https://www.crunchbase.com/organization/openai`) or just the slug (`openai`) — one profile per entry.

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `companyUrls` | array (string or `{ "url": "..." }`) | ✅ | — | Crunchbase organization URLs or bare slugs. Strings and `{url}` objects are both accepted; duplicates are removed; non-organization entries are skipped with a warning. |
| `maxItems` | integer | — | `50` | Maximum company profiles to scrape. Hard cap: 1,000. Free-tier accounts are limited to 10 profiles per run. |
| `maxFundingRounds` | integer | — | `10` | Funding rounds kept per company (most recent first). Range 1–50; raise for deep funding-history research. |
| `proxyConfiguration` | object | — | Apify **RESIDENTIAL** proxies | Crunchbase blocks datacenter IPs, so residential proxies are strongly recommended (default). Proxy traffic bills per GB on top of results. |
| `maxConcurrency` | integer | — | `4` | Companies fetched in parallel (1–10). Higher values are faster but use more bandwidth. |

### Extract Startup Funding Rounds and Investor Data

One dataset item per company, with the full funding picture: total funding in USD, per-round records (`announcedDate`, `roundName`, `amountUsd`, `amountFormatted`, `leadInvestors`, `investors`), a deduplicated investor list with Crunchbase profile URLs, and the company's stage, operating status, IPO status and acquisition status.

| Field | Type | Description |
|---|---|---|
| `url` / `slug` | string | Crunchbase profile URL and slug |
| `name` / `legalName` | string | Company name, legal name |
| `description` / `shortDescription` | string | Long and short company descriptions |
| `location` | object | `{ city, region, country, formatted }` |
| `website` | string | Company's own domain (never the Crunchbase URL) |
| `employeeCount` | string | Employee range (e.g. `251-500`) |
| `totalFundingUsd` / `totalFundingFormatted` | number / string | Total disclosed funding (`85000000` / `$85M`) |
| `foundedDate` | string | Founded date (ISO) |
| `industries` | array | Industry categories (deduplicated) |
| `companyStage` | string | Latest funding stage (e.g. `Series B`) |
| `operatingStatus` | string | e.g. `active`, `closed`, `acquired` |
| `ipoStatus` / `ipo` | string / object | `private`/`public` plus `{ wentPublicOn, stockSymbol }` |
| `acquisitionStatus` | object | null | `{ acquired, acquiredBy, announcedDate }` |
| `cbRank` | number | Crunchbase rank score |
| `fundingRounds` | array | Rounds, most recent first (see fields above) |
| `investors` | array | `{ name, profileUrl }`, up to 100, alphabetized |
| `socialLinks` | object | `{ linkedin, twitter, facebook }` |
| `contactEmail` / `phoneNumber` | string | null | Publicly visible contact data; often `null` |
| `scrapedAt` | string | ISO timestamp of the run |
| `extractionSources` | object | Debug flags: `{ angularState, jsonLd, embeddedJson, dom }` |

The default **Companies** dataset view shows Company, Website, Location, Employees, Total Funding, Stage, Founded, Industries, Operating Status, IPO Status, LinkedIn, Crunchbase URL; the **Funding Rounds** view unwinds rounds into rows (Announced, Round, Amount, Lead Investors).

### Example Input: Scrape Company URLs or Slugs

```json
{
    "companyUrls": [
        { "url": "https://www.crunchbase.com/organization/openai" },
        "stripe"
    ],
    "maxItems": 50,
    "maxFundingRounds": 10
}
```

### Example Output: One JSON Record Per Company

```json
{
    "url": "https://www.crunchbase.com/organization/example",
    "slug": "example",
    "name": "Example Corp",
    "description": "Example Corp builds ...",
    "location": { "city": "San Francisco", "region": "California", "country": "United States", "formatted": "San Francisco, California, United States" },
    "website": "https://example.com",
    "employeeCount": "251-500",
    "totalFundingUsd": 85000000,
    "totalFundingFormatted": "$85M",
    "foundedDate": "2019-04-01",
    "industries": ["Artificial Intelligence", "SaaS"],
    "companyStage": "Series B",
    "operatingStatus": "active",
    "ipoStatus": "private",
    "acquisitionStatus": null,
    "ipo": null,
    "cbRank": 12345,
    "fundingRounds": [
        {
            "announcedDate": "2023-06-15",
            "roundName": "Series B",
            "amountUsd": 60000000,
            "amountFormatted": "$60M",
            "leadInvestors": ["Acme Ventures"],
            "investors": ["Acme Ventures", "Seed Fund"]
        }
    ],
    "investors": [{ "name": "Acme Ventures", "profileUrl": "https://www.crunchbase.com/organization/acme-ventures" }],
    "socialLinks": { "linkedin": "https://www.linkedin.com/company/example", "twitter": "https://twitter.com/example", "facebook": null },
    "contactEmail": null,
    "phoneNumber": null,
    "scrapedAt": "2026-09-19T12:00:00.000Z",
    "extractionSources": { "angularState": true, "jsonLd": true, "embeddedJson": true, "dom": false }
}
```

Fields that are not publicly visible on a profile come back `null`; check `extractionSources` to see which data layers produced the record.

### Track Startup Funding With Integrations & Automation

This Actor runs on Apify, so it plugs into everything the platform ships:

- **Apify API** — call it from any application with a `POST /v2/acts/{actorId}/runs` request; results land in a dataset you can paginate.
- **Apify MCP** — AI agents (Claude, ChatGPT, Perplexity, Cursor) can call the Actor directly through the Apify MCP server.
- **Webhooks** — get an HTTP callback when a run finishes (e.g. feed results into a Slack channel or web app).
- **Zapier & Make** — official Apify integrations let you pipe company records into CRMs, Sheets, Airtable and back-office tools without code.
- **Scheduling** — the most common production pattern is a **daily or weekly scheduled run** of your company watchlist: new funding rounds and stage changes show up as new/updated rows, and recurring usage also improves the Actor's Store recommendation signals. Datasets can be exported as JSON, CSV, Excel, or HTML at any time.

### Related Actors: Company Data & Lead Generation Tools

A curated, relevance-first cluster — complement this Actor with company enrichment, funding deal flow, and research sources:

- [Company Data Enricher](https://apify.com/miccho27/company-data-enricher) — free enrichment of company data by domain (tech stack, contacts, Wikidata metadata); a zero-API-key complement to this database.
- [Startup Fundraising Scraper](https://apify.com/complex_intricate_networks/fundraising-and-startup-funding-scraper) — daily startup funding rounds and VC deal flow from Crunchbase, TechCrunch and FinSMEs.
- [Google Search Scraper](https://apify.com/apify/google-search-scraper) — the authoritative Google results extractor for market and lead research.
- [Google Maps Places](https://apify.com/compass/crawler-google-places) — location-based business data for account lists and territory mapping.
- [LinkedIn Profile Scraper](https://apify.com/harvestapi/linkedin-profile-scraper) — enrich funding-stage companies with decision-maker contacts.

### How This Compares to Other Crunchbase Scrapers

Verified against the top Crunchbase Actors in the Apify Store (Sep 2026) — their listings' pricing and inputs, not assumptions:

| Capability | Other Store Actors | This Actor |
|---|---|---|
| Price per company result | US$0.008 – US$0.069 (memo23, johnvc, pratikdani, davidsharadbhatt, parseforge) | **US$0.004** |
| Input | search filters (davidsharadbhatt, curious\_coder) or cookies (curious\_coder, jungle\_synthesizer) | URL or bare slug, nothing else |
| Login / Pro session / API key | required by several competitors | **none** |
| Browser automation | common (Playwright-based) | none — Cheerio + TLS impersonation |
| Instant database / discovery mode | yes (memo23 139K DB, davidsharadbhatt) | no — bring your own URLs |
| Field count | 130+ (davidsharadbhatt) | ~30 core fields, funding-round-focused |

The trade-off is deliberate: this is the **fastest and cheapest URL-to-rows path** for companies you already know, while competitors' search-mode actors are better for open-ended discovery.

### FAQ: Crunchbase API vs Scraper, Alternatives, Legality & Data Freshness

#### Why use this actor instead of the official Crunchbase API?

Crunchbase's free ("Open") API tier stopped accepting new registrations around 2022, the free Basic tier does not expose funding-round data, and full API access is sold through an Enterprise/Applications license — third-party 2026 sources estimate ~US$2,000/month at the low end (web-data-labs) and a median contract of ~US$20K/year with enterprise deals at ~US$50K+/year (Vendr deal data cited by Fundable). This Actor delivers the same public company pages — funding rounds, investors, firmographics, IPO/acquisition status — as JSON at ~US$0.004 per company with no contract, no key, and no login.

#### Does Crunchbase have a free API?

No. The free "Open Data" tier is closed to new sign-ups (since ~2022). Crunchbase Basic (the current free tier) only covers organization lookup/discovery endpoints, not funding-round data, and the full API is enterprise-gated with a 200-calls-per-minute baseline rate limit.

#### What are the best Crunchbase alternatives?

For programmatic funding data without an enterprise contract: this Actor (pay-per-result), Fundable, Apollo, Tracxn Lite, Dealroom (European), PitchBook (deep analyst data), Harmonic (stealth discovery). Crunchbase also ships a first-party MCP server, but access is a paid per-seat add-on tied to your existing Crunchbase account — see below. On Apify specifically, `johnvc/crunchbase-company-api` (US$0.00855/company, MCP-ready) and `davidsharadbhatt/crunchbase-company-scraper` (US$0.01998/company, 130+ fields, search mode) are the closest comparables.

#### Does Crunchbase have an MCP server for AI agents?

Yes — Crunchbase operates a first-party MCP server at `mcp.crunchbase.com` that works with Claude, ChatGPT, Gemini and Cursor. It is sold **per seat** and requires signing in with an existing Crunchbase account/package — there is no free tier. This Actor gives AI agents the same public company and funding data through the Apify API/MCP at US$0.004 per company, with no Crunchbase account required.

#### How do I export Crunchbase data to CSV or Excel?

Crunchbase's own CSV export requires a Pro/Business subscription and is capped at 1,000 rows per export. With this Actor, any run's dataset downloads as CSV, JSON, Excel or HTML — no subscription and no row cap inside `maxItems` (1,000 per run on paid plans; 10 on the free tier).

#### Is scraping Crunchbase legal?

This Actor reads only publicly visible Crunchbase organization pages — it does not log in, bypass paywalls, or solve CAPTCHAs. Whether scraping public web pages is permissible depends on your jurisdiction and Crunchbase's Terms of Service, which restrict automated access and prohibit reselling compiled datasets as a competing data product. Review the Terms before scraping at scale and ensure any contact data you export is handled lawfully (see the disclaimer below). You are responsible for how you use the data.

#### Why does this Actor read an archived snapshot first?

Crunchbase's Cloudflare layer re-challenges even solved browser sessions, so a snapshot-first strategy is both faster and more reliable: the newest archive.org snapshot of a profile usually contains the full funding state (amounts and dates) and loads in ~1 second. The live page is fetched when no snapshot exists. Snapshot-sourced records are technically as-of the snapshot date and occasionally omit round names or investors.

#### How fresh is the data?

If a snapshot serves the profile, freshness is bounded by the newest archive.org snapshot of that page (usually within the last year or faster for popular companies); snapshot order is newest-first. When the live page is reachable, data is current as of the run.

#### How can I find investors for a startup?

Scrape the funding rounds and investor list of leading companies in the sector you care about (the dataset's `fundingRounds.leadInvestors` and `investors` fields with profile URLs), then schedule a recurring run to catch new rounds as they are announced.

### Competitive Comparison: Cheapest Verified Price

Every price row below is the per-company "result" price published on the respective Store listing (Sep 2026): this Actor **US$0.004** vs. curious\_coder US$0.0025+US$0.01/page and US$0.005 start, meme-style bundles aside — for a clean URL-list scrape with funding history included, this Actor is the lowest all-in per-company price among the verified comparables (memo23 US$0.008, johnvc US$0.00855, pratikdani US$0.01267, davidsharadbhatt US$0.01998, parseforge US$0.069).

### For AI Agents & LLM Apps

**Purpose:** pass Crunchbase organization URLs or slugs; receive one JSON record per company (funding rounds with dates/amounts/lead investors, total funding, firmographics, IPO/acquisition status, social links, optional public contact data).

**Minimal working input** (produces a valid paid-plan run):

```json
{
  "companyUrls": [
    { "url": "https://www.crunchbase.com/organization/openai" },
    { "url": "https://www.crunchbase.com/organization/stripe" }
  ]
}
```

Bare slugs are also accepted: `"companyUrls": ["openai", "stripe"]`. A depth-variant input adds `"maxFundingRounds": 50` (full round history) or lowers `"maxConcurrency": 1` for gentler scraping.

**Output fields** (`dataset` items): `url`, `slug`, `name`, `legalName`, `description`, `shortDescription`, `location{city,region,country,formatted}`, `website`, `employeeCount`, `totalFundingUsd`, `totalFundingFormatted`, `foundedDate`, `industries[]`, `companyStage`, `operatingStatus`, `ipoStatus`, `ipo{wentPublicOn,stockSymbol}|null`, `acquisitionStatus{acquired,acquiredBy,announcedDate}|null`, `cbRank`, `fundingRounds[]{announcedDate,roundName,amountUsd,amountFormatted,leadInvestors[],investors[]}`, `investors[]{name,profileUrl}`, `socialLinks{linkedin,twitter,facebook}`, `contactEmail|null`, `phoneNumber|null`, `scrapedAt`, `extractionSources{angularState,jsonLd,embeddedJson,dom}`.

**Behaviors an agent should know:**

- `companyUrls` accepts strings or `{url}` objects; non-`crunchbase.com/organization` entries are skipped (with a warning), duplicates are removed, and if no valid entry remains the run exits with no output.
- **Free-tier accounts are capped at 10 profiles per run** regardless of `maxItems`; paying accounts may set `maxItems` up to 1,000 (the hard cap).
- Snapshot-first by default: profiles come from the newest archive.org snapshot when one exists (fast, but as-of the snapshot date), falling back to the live page. Snapshot records can return `null` for round names/investors.
- `contactEmail`/`phoneNumber` are only populated from publicly visible page data and are frequently `null` — do not assume they exist.
- `maxFundingRounds` (default 10, max 50) caps the round list, most recent first; `investors` is capped at 100 entries, alphabetized.
- Residential proxies are used by default (Crunchbase blocks datacenter IPs); proxy traffic bills per GB on top of results.
- Failed profiles are logged and skipped — a run still returns whatever succeeded.

**Billing model:** pay-per-result + start fee. ~US$0.004 per company record pushed to the dataset, plus a run-start fee (one event per GB of memory; default 1024 MB), plus residential proxy traffic per GB. Free tier: 10 profiles per run.

### Legal & Compliance Disclaimer

Crunchbase Scraper is an independent tool and is **not affiliated with, endorsed by, or sponsored by Crunchbase, Inc.** It accesses only publicly visible Crunchbase organization pages — no login, no CAPTCHA solving, no paywall bypass, and no use of Crunchbase's private API. Where a profile publicly lists a contact email or phone number, those fields are returned as published; they are often absent.

You are responsible for complying with Crunchbase's Terms of Service (which restrict automated access and prohibit reselling compiled datasets as a competing data product) and with applicable law in your jurisdiction. If you process or export personal contact data (emails, phone numbers) of individuals in the EU or California, data-protection regimes such as **GDPR and CCPA/CPRA** may apply. Do not use contact data for unsolicited commercial outreach in violation of laws such as **CAN-SPAM, GDPR e-privacy, or TCPA**. Nothing here is legal advice; consult counsel for high-volume or commercial use.

### SEO Keywords

crunchbase scraper, crunchbase api alternative, scrape crunchbase data, crunchbase data extraction, crunchbase company data, startup funding data, startup funding database, company funding rounds, investor database, vc deal sourcing, startup market research, company intelligence, firmographic data, b2b lead generation, abm account lists, crunchbase without api, crunchbase data no login, crunchbase export to csv, crunchbase data to excel, track startup funding, ai startup funding, crunchbase mcp, crunchbase api pricing, find investors for a startup, latest funding rounds

# Actor input Schema

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

Crunchbase organization page URLs (e.g. https://www.crunchbase.com/organization/openai) or just the slugs (e.g. 'openai'). One profile per URL.

## `maxItems` (type: `integer`):

Maximum number of company profiles to scrape (hard cap 1000).

## `maxFundingRounds` (type: `integer`):

How many funding rounds to extract per company (most recent first).

## `proxyConfiguration` (type: `object`):

Proxy settings. Crunchbase blocks datacenter IPs, so RESIDENTIAL proxies are strongly recommended (default).

## `maxConcurrency` (type: `integer`):

How many companies to scrape in parallel (1–10). Higher values increase speed but use more bandwidth. Archive.org rate limits are modest, so 4 is a safe default.

## Actor input object example

```json
{
  "companyUrls": [
    {
      "url": "https://www.crunchbase.com/organization/openai"
    },
    {
      "url": "https://www.crunchbase.com/organization/stripe"
    }
  ],
  "maxItems": 50,
  "maxFundingRounds": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 4
}
```

# Actor output Schema

## `results` (type: `string`):

No description

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/crunchbase-scraper"
        }
    }
}
```

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/Uf6Rnr9OK7YAa2YQI/builds/veg2nkdo7FCaSeBY0/openapi.json