Crunchbase API Review: Full 2026 Breakdown

The pitch is familiar: tap into nearly two decades of private company intelligence through a single REST endpoint.

The Crunchbase API sits on a dataset that has become a standard source for private market data, cited by Yahoo Finance, MarketWatch, Perplexity, and Clay. Version 4.0 exposes over 600 endpoints covering funding rounds, firmographics, AI insights, and predictions across 4M+ private companies.

The documentation is public, hosted on readme.io, and includes an OpenAPI specification in both JSON and YAML.

But the gap between "the data exists" and "you can build on it" depends on how the API is packaged: what the authentication model supports, what the rate limits allow, how much it costs, and whether you can get access without a sales conversation.

The Crunchbase API is likely the right choice if:

• You need structured access to private company funding histories, investor relationships, and acquisition timelines at scale.

• You are building a product or internal tool that needs to enrich records with firmographic and financial data sourced from first-party venture partner submissions.

• You want predictions (funding probability, acquisition likelihood, growth outlook) available programmatically, not just historical snapshots.

• You are a data licensing customer embedding Crunchbase data in a customer-facing application (the way Clay, Yahoo Finance, and J.P. Morgan Fusion do).

• You need entity lookups, search, and autocomplete endpoints for building type-ahead company discovery into your own UI.

However, it might not be the right fit if:

• You need contact-level data at scale: verified business emails, direct-dial phone numbers, employment history, or org charts across hundreds of millions of contacts.

• You need OAuth 2.0 with delegated access, scoped permissions, or token rotation for a multi-tenant integration.

• You want official SDKs in any language rather than building and maintaining raw HTTP calls yourself.

• You need webhook or event-driven automation. The API is read-only and poll-based, with no push notification system.

• You need a self-serve developer tier with transparent pricing. The free API tier has been discontinued, and access requires an enterprise license.

• You need buyer intent signals, technographic data, or behavioral indicators alongside company records.

In this case, consider the API from ZoomInfo, a B2B data platform with a REST suite covering search, enrichment, AI research, and audience management across 500M contacts and 100M companies, OAuth 2.0 authentication, tiered rate limits up to 35 req/sec, and an MCP server for AI-agent workflows.

This article reviews both: Crunchbase first in full technical depth, then ZoomInfo where your build needs contact data, intent signals, and developer tools that a private-market API does not cover.

Crunchbase API at a Glance

Crunchbase API: What Works Well & What to Plan Around

Crunchbase API: Authentication & Getting Started

Crunchbase gates API access behind an enterprise license. The Crunchbase Basic plan, which previously offered limited free API access, has been discontinued, and Crunchbase no longer issues new Basic API keys. Developers who want the API must contact sales for an Enterprise or Applications license.

Source: Crunchbase

Once licensed, Crunchbase emails API keys to the licensee during onboarding. Existing customers can view their key under Account Settings > Integrations > Crunchbase API. If a key is lost, contact api@crunchbase.com. There is no self-service key generation portal.

Authentication is straightforward. Pass the API key in one of two ways:

• As a URL query parameter: ?user_key=YOUR_API_KEY

• As an HTTP request header: X-cb-user-key: YOUR_API_KEY

A basic authenticated request looks like this:

curl "https://api.crunchbase.com/v4/data/entities/organizations/crunchbase" \

-H "X-cb-user-key: YOUR_API_KEY" \

-H "Content-Type: application/json"

All API requests must use HTTPS; HTTP requests return a 426 error. There is no OAuth flow, no session-based auth, and no scoped or delegated access. A single static key is the sole credential. For teams that need per-integration isolation, there is no documented way to create multiple keys under one license.

The upshot: getting started with the Crunchbase API requires a commercial commitment before you can make your first call. There is no sandbox, no trial key, and no way to test the API before signing a license agreement.

Crunchbase API: Core Endpoints & Capabilities

The API provides four classes of endpoints, all returning JSON. Data is organized around entity types (Organizations, People, Funding Rounds, Investments, Acquisitions, IPOs, and more), and the endpoint pattern follows a lookup-or-search model rather than CRUD. The API is entirely read-only.

Entity Lookup

Endpoint: GET /api/v4/data/entities/{collection}/{entity_id}

Retrieves data fields and relationships for a specific entity, identified by UUID or permalink. Two optional parameters control what comes back:

• field_ids: which data fields to include in the response

• card_ids: which relationship lists (cards) to attach

Entity types covered by the Lookup API include Organizations, People, FundingRounds, Investments, Acquisitions, IPOs, Events, EventAppearances, Jobs, Funds, Addresses, Categories, CategoryGroups, Locations, Ownerships, PressReferences, DiversitySpotlights, Degrees, and Principals.

For organizations, available relationship cards include founders, raised_funding_rounds, participated_investments, acquirer_acquisitions, acquiree_acquisitions, investors, ipos, headquarters_address, parent_organization, child_organizations, jobs, and press_references.

One constraint: card relationships return a maximum of 100 items per request. Organizations with long funding histories or large investor lists require pagination using the single-card entity lookup endpoints.

What you would build with this: a company profile page that pulls structured funding history, investor relationships, and leadership data from Crunchbase and renders it alongside your own application's data.

Search

Endpoint: POST /api/v4/data/searches/{collection}

Finds entities matching structured filter criteria. The request body requires field_ids (which fields to return) and query (a list of predicate objects). Optional order and limit parameters control sorting and page size.

POST https://api.crunchbase.com/v4/data/searches/funding_rounds?user_key=YOUR_API_KEY

{

"field_ids": ["identifier", "announced_on", "funded_organization_identifier", "money_raised"],

"query": [

{"type": "predicate", "field_id": "announced_on", "operator_id": "gte", "values": ["2024"]}

],

"limit": 100

}

Collections available for search match the entity types: organizations, people, funding rounds, investments, acquisitions, IPOs, events, jobs, funds, locations, categories, and more.

One structural limitation: query predicates are AND-only. If you need OR logic (for example, "companies in fintech OR healthtech"), you must make separate calls and merge results on the client side. For complex filters, this multiplies your API calls against the 200/minute rate limit.

What you would build with this: a prospecting engine that queries for recently funded companies in a target vertical and employee-count range, feeding results into a CRM or outbound pipeline.

Autocomplete

Suggests matching entity identifiers based on a text query string, filtered by entity_def_ids. This is the endpoint for building type-ahead search in your application, returning entity names and IDs as the user types.

Deleted Entities

Retrieves entities removed from the platform. If you mirror Crunchbase data into a downstream database, polling Deleted Entities lets you remove retired records without a full re-index.

Data Packages

The data available through these endpoints is organized into three tiers, each gated by your license level:

• Fundamentals: historical firmographics and financials (company profiles, funding history, valuations, investor details)

• Insights: AI analyses (growth insights, news insights, investor insights, products/services insights)

• Predictions: AI forecasts (funding probability, acquisition likelihood, growth trajectory, IPO identification, layoff and closure predictions)

The Predictions tier is where Crunchbase's recent product investment shows up in the API. Funding predictions carry 95% precision and 99% recall in backtesting; acquisition predictions achieve 96% precision and 95% recall. Whether your license includes the Predictions package is a commercial question, not a technical one.

Crunchbase API: SDKs, Docs & Rate Limits

SDKs & Libraries

Crunchbase does not publish official SDKs for any language. All documentation examples use raw cURL commands, and the official docs reference no community libraries. Developers integrate over HTTP using whatever client library their language provides.

The absence of an SDK is itself a signal. For a simple Entity Lookup integration, raw HTTP is fine. For a production pipeline making hundreds of Search calls with pagination, retry logic, and rate-limit backoff, you build and maintain the client layer yourself.

The OpenAPI specification in JSON and YAML partly offsets this: you can generate a typed client from the spec using tools like openapi-generator, though generated clients still need testing against the live API.

Documentation & Developer Experience

Developer documentation is hosted at data.crunchbase.com on the readme.io platform. The structure is clear:

• Getting Started guides: authentication, base URLs, and endpoint types

• API Reference: per-endpoint schema documentation with request and response examples

• API Starter Playbooks: annotated use-case walkthroughs (e.g., "Define and Pull Your ICP," "Forecast Investment Upside & Risk," "Discover Early-Stage Investment Opportunities")

• Data Dictionary: all available fields listed by collection

• Examples: Search API, Entity Lookup, and Autocomplete worked examples

• FAQ section: common query patterns and troubleshooting

• OpenAPI specification: downloadable in JSON and YAML

• llms.txt index: all documentation pages in markdown, at data.crunchbase.com/llms.txt, for AI agent consumption

The readme.io platform typically includes an interactive API console, though Crunchbase gates testing behind a license key. There is no public sandbox. Version labeling shows "v4.0 (Current)" in the docs nav. No public changelog was found during review, making it harder to track changes between releases.

Developer support channels: lost API keys go to api@crunchbase.com, rate-limit issues escalate to a Customer Success Manager, and sales inquiries go to sales@crunchbase.com. There is no developer forum, Slack channel, or community support path.

Rate Limits & Constraints

Crunchbase enforces a rate limit of 200 API calls per minute across all endpoints. The limit is uniform, with no tiering by plan level and no documented upgrade path. When you exceed it, the API returns an error. Crunchbase directs customers hitting the limit to their Customer Success Manager.

Additional hard constraints:

• Card pagination ceiling: relationship cards return a maximum of 100 items per request

• AND-only query logic: Search API predicates are conjunctive; OR logic requires separate calls

• JSON only: the API accepts and returns JSON exclusively

• HTTPS required: HTTP requests return a 426 error

• No bulk export endpoint: legacy CSV export workflows have been migrated to the v4 API

For sizing throughput: 200 calls per minute gives you roughly 3.3 requests per second. If each Search call returns 100 results, you can pull about 20,000 records per minute before hitting the ceiling. For pipelines that need to sync large datasets, the rate limit is the binding constraint, and AND-only query logic compounds it by requiring more calls for complex filters.

Crunchbase API Pricing & Access Costs

Crunchbase does not publish API pricing. The Crunchbase Basic API, previously a free limited-access tier, has been discontinued.

Source: Crunchbase

Full API access comes only through paid enterprise licensing, with two commercial pathways:

• Crunchbase Data Enrichment: for feeding Crunchbase data into internal CRMs, automation platforms, and workflows. Aimed at revenue and operations teams.

• Crunchbase Data Licensing: for embedding Crunchbase data in customer-facing products and platforms. Requires an Applications license and mandatory attribution.

Both pathways are quote-only. No per-call metering, credit packs, or published overage costs are documented. The minimum entry point is an Enterprise or Applications license; you negotiate pricing directly with sales.

For context on Crunchbase's broader pricing: the platform starts at $49/month (annual) or $99/month (monthly) for Crunchbase Pro, which includes search and export but not API access. Crunchbase Business (which adds predictions and CRM integrations) is also custom-priced. The API sits above both tiers as a separate enterprise commitment.

The cost question a developer must answer before evaluating this API: can your organization commit to an enterprise license before making a single test call? There is no way to evaluate the API at a trial or self-serve price point.

Where the Crunchbase API Falls Short

These are the practical limits a developer should plan around. Several reflect scope decisions: what Crunchbase built (a private market intelligence API) and what it did not.

No self-serve access path. The free API tier is discontinued, and there is no trial key, sandbox, or developer plan. Evaluating the API requires a sales conversation and an enterprise license. For a developer comparing APIs before committing budget, this is a barrier.

No webhooks or event-driven delivery. The API is a read-only RESTful service with no push notification system. If your pipeline needs to react to new funding rounds, leadership changes, or prediction updates in real time, you must poll on your own schedule. For event-driven architectures, you build and maintain your own change-detection layer.

Static API key authentication only. There is no OAuth flow, no token rotation, no scoped permissions, and no delegated access. For teams building multi-tenant integrations where each customer authenticates independently, or organizations with strict credential-rotation policies, a single static key is limiting.

No official SDKs. Every integration is raw HTTP. The OpenAPI spec helps, but there are no maintained client libraries, no GitHub SDK repos, and no community libraries referenced in the docs.

Contact data is secondary, not primary. Crunchbase maintains 18M contacts at 400K organizations. For builds that need verified business emails, direct-dial phone numbers, employment histories, or org charts across hundreds of millions of contacts, the coverage gap is large.

No intent signals, technographics, or behavioral data. The API covers firmographics, funding, predictions, and AI insights, but does not expose buyer intent signals, technology stack data, or website visitor identification. Builds that need to know which companies are researching a category, or what stack a target runs, need a separate data source.

200 calls/minute ceiling with no documented upgrade path. The rate limit is uniform and firm. Combined with AND-only query logic in the Search API (which multiplies calls for complex filters), this constrains throughput for high-volume sync and enrichment pipelines.

ZoomInfo API: The Contact Intelligence and Signal Layer Crunchbase Does Not Cover

Crunchbase tells you about companies: their funding history, investor relationships, growth predictions, and acquisition probability. ZoomInfo tells you about the people at those companies: who they are, how to reach them, what technology their company uses, whether they are researching your category, and where they sit in the org chart.

The two APIs serve different layers of a B2B data pipeline. The gap between "this company just raised a Series B" and "here are the three decision-makers to contact, with verified emails and direct dials" is where ZoomInfo's API fits.

Behind ZoomInfo's API sits the GTM Context Graph, which processes 1.5B+ data points daily by combining ZoomInfo's B2B data with your CRM records, conversation transcripts, and behavioral signals.

Source: ZoomInfo

What the API Covers

ZoomInfo's Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into four areas documented in the interactive API reference:

Data API (Search & Enrich): the core. Search endpoints cover Contacts, Companies, Intent, News, and Scoops, returning matched records without consuming credits.

Source: ZoomInfo

Enrich endpoints unlock the full payload: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, accepting up to 25 records per call.

Source: ZoomInfo

The search-then-enrich pattern lets you filter freely, then pay only for the records you commit to. The dataset spans 500M contacts, 100M companies, 135M+ verified phone numbers, and 200M+ verified business email addresses.

Source: ZoomInfo

Copilot API (AI Intelligence, part of GTM Workspace): Account Summary returns structured account research with a free-form Q&A endpoint. Find Similar Companies finds lookalikes. Contact Recommendations returns AI-ranked buying-committee suggestions by use case (prospecting, deal acceleration, renewals).

Marketing API: CRUD endpoints for programmatic audience management.

Platform API (Engagements, Beta): bidirectional engagement data via the Engagements API.

What you would build with this: a pipeline that detects a funding round via Crunchbase's API, then uses ZoomInfo's Search to find the VP of Engineering and CFO at that company, enriches them with verified emails and direct dials, and enrolls them in an outbound sequence, all programmatically.

Authentication & Developer Experience

ZoomInfo uses OAuth 2.0 with PKCE via Okta, issuing 24-hour access tokens with rotating refresh tokens. Three flows are supported: Authorization Code with PKCE (for web applications), Client Credentials (for server-to-server), and Refresh Token. Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints.

Source: ZoomInfo

This is a different authentication model from Crunchbase's static API key. OAuth 2.0 supports delegated access, credential rotation, and scoped permissions, which suits multi-tenant integrations and enterprise security requirements.

Documentation lives at docs.zoominfo.com with an interactive API reference, OAuth recipes in five languages (Shell, Node, Ruby, PHP, Python), and an llms.txt index for AI development tools. A Docs MCP server enables AI-assisted code generation against the API spec.

Rate Limits, Credits & Webhooks

Rate limits are published by tier: Builder (5 req/sec), Standard (25 req/sec), and Scaling (35 req/sec), with per-hour and per-day sliding-window limits enforced simultaneously. Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing.

Source: ZoomInfo

Credits follow a rolling 12-month window: enriching a record for the first time consumes one credit; re-enriching the same record within the year is free. Search and lookup operations do not consume credits.

Webhooks are available via the Agents API, tied to ZoomInfo's Agent Teams system. Event types cover bulk enrichment jobs completing, records changing, credit usage crossing thresholds, and new signals (scoops, funding events, intent spikes) becoming available, with retry behavior configurable per event type.

For developers building AI agents, ZoomInfo's MCP server at https://mcp.zoominfo.com/mcp exposes search, enrich, and account research as native tools for MCP-compatible assistants, currently supporting Claude and ChatGPT.

Source: ZoomInfo

ZoomInfo does not publish official SDKs either, so both platforms require direct HTTP integration. ZoomInfo has extended API access to all relevant plans, though pricing remains custom-quoted.

BDO Canada reported an 87% reduction in time spent updating internal data dashboards using the ZoomInfo API, with one analyst calling the integration plug-and-play across any process. (ZoomInfo)

Crunchbase API vs. ZoomInfo API

Final Verdict

Crunchbase's API gives developers structured access to a dataset that leads private market intelligence: nearly two decades of venture-sourced funding data, investor relationships, and AI predictions on company trajectories.

The documentation is clear, the OpenAPI spec is downloadable, and the data packages (Fundamentals, Insights, Predictions) let you scope your integration to the layer you need. For builds centered on private company funding intelligence, this is the reference API.

Choose the Crunchbase API if you are building a product or pipeline that needs private market data as its foundation: funding round histories, investor graphs, acquisition predictions, or firmographic profiles of early-stage and growth-stage companies. The dataset's depth on private companies, sourced from a 4,000-firm venture partner network and 600,000+ community contributors, is hard to replicate.

Choose the ZoomInfo API if your build needs to go beyond company intelligence into contact-level data at scale: verified emails, direct dials, employment history, org charts, technographics, buyer intent signals, and AI account research across 500M contacts and 100M companies.

The OAuth 2.0 authentication, tiered rate limits (up to 35 req/sec), webhook support, and MCP server provide the developer infrastructure a high-volume, event-driven pipeline requires.

Start with the ZoomInfo Enterprise API or explore the developer docs to see the endpoint surface directly.

A developer who needs neither API should weigh whether the lack of a self-serve access tier on the Crunchbase side and the lack of published pricing on both sides are acceptable friction. Both APIs require a commercial commitment before you write your first line of integration code.

FAQ

Is the Crunchbase API free?

No. The Crunchbase Basic plan, which previously provided limited free API access, has been discontinued. Crunchbase no longer issues new Basic API keys. Full API access requires an Enterprise or Applications license, custom-priced through a sales conversation. There is no trial key, sandbox, or self-serve developer tier.

Does Crunchbase have a GraphQL API?

No. Crunchbase exposes a REST API (v4.0) over HTTPS, returning JSON. There is no GraphQL endpoint. The API provides Entity Lookup, Search, Autocomplete, and Deleted Entities endpoints, all in a standard REST pattern. If you need a GraphQL interface, you would build a wrapper layer on top of the REST API.

What is the Crunchbase API rate limit?

Crunchbase enforces 200 calls per minute across all endpoints. The limit is uniform with no tiering by plan level. When you exceed it, the API returns an error. Crunchbase directs customers hitting the limit to their Customer Success Manager.

Combined with AND-only query logic in the Search API, this ceiling can become the binding constraint for pipelines syncing large datasets or running complex multi-predicate searches.

Are there official Crunchbase SDKs?

No. Crunchbase does not publish official SDKs for any language. All documentation examples use raw cURL commands, and the official docs reference no community libraries. The OpenAPI specification in JSON and YAML lets developers generate typed clients using tools like openapi-generator, but there are no maintained SDK packages or GitHub repositories from Crunchbase.

Does the Crunchbase API support webhooks?

No. The Crunchbase API is a read-only RESTful service with no webhook, push notification, or event streaming system. Developers who need to detect new funding rounds, prediction changes, or entity updates must poll endpoints on their own schedule. This is a real constraint for event-driven architectures.

ZoomInfo's API, by comparison, supports webhooks via its Agent Teams system, covering events like enrichment job completion, credit threshold alerts, and new signals.

What does ZoomInfo's API add to a Crunchbase build?

ZoomInfo's API adds the contact intelligence, intent signals, and developer tools that Crunchbase's private-market data API does not cover.

Where Crunchbase gives you the company (funding history, investor relationships, growth predictions), ZoomInfo gives you the people at that company (500M contacts with verified emails, 135M+ verified phone numbers, employment history, org charts) and the behavioral signals showing whether they are in-market (buyer intent, scoops, news).

The two APIs use different authentication models (static API key vs. OAuth 2.0), different rate-limit structures (200 calls/minute vs. tiered per-second with sliding windows), and different pricing mechanics (enterprise license vs. consumption-based), so plan the integration layer to handle both.

ZoomInfo's MCP server extends the same data to AI-agent workflows, adding a developer surface Crunchbase does not offer.