Tool Reference

This page documents every tool the Crunchbase MCP server exposes, for AI developers building agents and workflows on Crunchbase data, and for anyone who wants to understand exactly what the server can do.

In normal use, your AI assistant selects and calls these tools automatically; you never invoke them by name. Understanding them helps you write better prompts, debug unexpected results, and build reliable automated workflows.

All tools are served from https://mcp.crunchbase.com over Streamable HTTP. Every call is authenticated and runs as the signed-in user; see Connecting AI Tools for authentication.

How the tools fit together

The tools form a pipeline that most workflows follow in some order:

1. Understand the schema with cb_reference, or explore what's answerable with cb_expert_query_domain.
2. Resolve names to identifiers with cb_entity_autocomplete or cb_expert_resolve_entity. Crunchbase tools operate on identifiers (UUIDs and permalinks), not display names.
3. Find entities with cb_expert_build_search (natural language) or cb_search_query (explicit criteria), or answer a question directly with cb_expert_query_answer.
4. Retrieve full profiles for the entities that matter with cb_entity_get.
5. Persist results to Crunchbase lists with the cb_list_* tools.

Expert tools trade control for convenience: they accept plain language and handle schema resolution internally. Structured tools trade convenience for precision: they require exact field IDs and operators but produce deterministic, repeatable queries. Production workflows typically use expert tools to discover the right query shape, then move to structured tools for anything that runs repeatedly or where completeness matters.

Expert tools

cb_expert_query_answer

Answers a natural-language question using live Crunchbase data. The expert service interprets the question, constructs and executes the necessary queries, and returns an answer with supporting results.

Use it for exploratory and analytical questions where you want an answer rather than a result set to process: "How many Series B rounds closed in fintech last quarter?" or "Who are the most active seed investors in climate tech?"

Each response includes a request_id. Keep it: it's required to submit feedback via cb_expert_submit_feedback, and negative feedback can trigger the service to rewrite the query and return corrected results.

cb_expert_build_search

Translates a natural-language description of the entities you want into a compiled, structured Crunchbase search, handling field resolution, operator selection, and value formatting automatically.

Use it when you know what you're looking for but not the schema: "US-headquartered healthcare companies that raised a seed round in the last 90 days." A productive pattern for repeatable workflows is to use this tool once to discover the compiled predicates, then run those predicates directly through cb_search_query for deterministic execution afterward.

cb_expert_query_domain

Answers meta-questions about the shape of the Crunchbase data domain: what entities, fields, and relationships exist, and whether a draft question is answerable. It does not query actual records.

discover returns a domain map, suggested analytical paths, and example questions. assess returns diagnostics on answerability, clarifications that would improve the question, and recommended reformulations. Prefer cb_reference when you already know which entity or field area to inspect; it returns precise structured answers without the expert-service round trip.

cb_expert_resolve_entity

Disambiguates an entity name against the Crunchbase catalog and resolves it to a canonical entity. Returns a single match when confident, otherwise a ranked candidate list.

This is the right tool for ambiguous inputs ("Scale", "Beacon", "Marc at Andreessen Horowitz"). For simple identifier lookup where ambiguity is unlikely, cb_entity_autocomplete is lighter.

cb_expert_submit_feedback

Records user feedback on a previous cb_expert_query_answer result.

Negative feedback may trigger the expert service to rewrite the query; when it does, the corrected result set is returned in the feedback response. In agent workflows, wiring user reactions to this tool improves answer quality over time.

Structured tools

cb_reference

The schema reference for everything else. Returns Markdown documentation for a given path; call with an empty path (or "index") for the full navigable index. Every response lists the paths you can drill into next; use them verbatim rather than constructing your own. An unrecognized path never errors: it returns the index plus a closest-match hint.

The per-field path is the single most important call when constructing structured queries: it is the authoritative source for which operators a field accepts and what its values look like.

cb_entity_autocomplete

Searches Crunchbase entities by name and returns matching identifiers with short descriptions. This is how you obtain valid identifiers before calling other tools.

Beyond companies and people, use it to resolve filter values: locations (collection_ids="locations") and categories (collection_ids="categories") before using them in search predicates. See Working with identifiers.

cb_entity_get

Retrieves the full profile for one already-identified entity: fields (financials, leadership, locations, categories) plus relationship cards (funding rounds raised, investments made, employees, and so on).

Card pagination. When a card holds more entities than fit in one response, has_more_entities is true. Fetch the next page by calling again with card_ids set to that single card, after_id set to the identifier.uuid of the last entity in the previous response, and field_ids=[].

Cost discipline. This is the most expensive call in the toolset, and cards on well-connected entities (a major investor's raised rounds, for example) can be very large. Do discovery through cb_search_query with explicit field_ids, and reserve cb_entity_get for the entities that survive screening, scoping follow-ups tightly with card_ids and field_ids=[].

cb_search_query

Executes a structured search and returns matching entities with the requested fields. This is the precision instrument: deterministic, repeatable, and completeness-friendly.

Resolve before you filter. For every field used in a predicate or sort, call cb_reference('entities/<ed>/fields/<field_id>') first. It returns the valid operators, example predicates, enum values, and live sample data. Guessed operators and value formats are the dominant cause of failed or, worse, silently empty searches.

Validation errors are instructions. A rejected search returns a description of exactly what's wrong (invalid field, unsupported operator for the field type, bad value format). Fix the named problem rather than abandoning the structured query for a vaguer one.

Result URLs. Each entity in the results carries a url field linking to its Crunchbase profile. Surface these links when presenting results; they're the user's path from an AI answer back to the source.

A minimal example, finding recently funded early-stage US companies:

{
  "collection_id": "funding_rounds",
  "predicates": [
    {"field_id": "announced_on", "operator_id": "gte", "values": ["2026-06-01"]},
    {"field_id": "investment_type", "operator_id": "includes", "values": ["seed", "series_a"]},
    {"field_id": "funded_organization_location", "operator_id": "includes", "values": ["united-states"]}
  ],
  "field_ids": ["identifier", "announced_on", "investment_type", "money_raised", "funded_organization_identifier"],
  "order": [{"field_id": "announced_on", "sort": "desc"}],
  "limit": 50
}

Note the location value: "united-states", an identifier, not "United States". See the next section.

Working with identifiers

Crunchbase tools operate on identifiers: UUIDs and permalinks. Display names are for humans; identifiers are for queries. Three rules keep searches reliable:

• Never fabricate an identifier. Obtain them from cb_entity_autocomplete, cb_expert_resolve_entity, or previous results.
• Identifier-valued filter fields expect identifier values. Location fields such as location_identifiers and funded_organization_location take permalinks like united-states or united-kingdom. A display name like "United States" is not an error; it simply matches nothing, so the search returns zero rows. Resolve locations first with cb_entity_autocomplete(query, collection_ids="locations") and use the returned permalink. The same applies to categories (collection_ids="categories").
• When a search unexpectedly returns zero rows, loosen one filter at a time, starting with identifier-valued filters. An unresolved location or category value is the most common cause of silent empty results.

Money fields take plain integer USD values (15000000, not "$15M"). Dates are ISO format ("2026-06-01").

List tools

Lists connect agent research to the Crunchbase platform: an AI-built list is immediately visible and usable by the whole team in Crunchbase.

cb_list_query

Returns all saved lists owned by the caller, with names, entity counts, and timestamps. Call this first to find a list_id.

cb_list_create

Creates a new empty list. Takes a single name parameter; populate it with cb_list_add_entities.

cb_list_add_entities

Appends entities to an existing list. Takes list_id and an array of entity_ids (entity UUIDs, e.g. from search results).

cb_list_get

Returns the entity identifiers in a list. Takes list_id, with after_id for pagination (the UUID of the last entity from the previous page).

These are the toolset's write operations: they modify data in your Crunchbase workspace. In clients with per-tool permission controls, they're the ones to keep on manual approval until you trust the workflow.

Utilities

cb_metering_get_state

Returns the caller-visible meter states for the current user: which limits apply and how they affect each tool. Takes no parameters. Call it after any metering-related failure from another tool to understand what limit was hit, or proactively in long-running agent workflows to budget remaining quota.

Programmatic access

The tools above are documented as your AI assistant uses them through an interactive, user-authenticated connection. Crunchbase also offers options for programmatic MCP access: headless agents, backend services, and automated workflows that connect without an interactive user session.

These arrangements have their own authentication, identity, and data-access considerations, so they're set up individually; contact your Customer Success Manager for guidance before building against the server programmatically.