Connect Crunchbase to ChatGPT: Research Companies and Funding Rounds

If you need to connect Crunchbase to ChatGPT to automate market research, analyze competitor funding rounds, or source deal flow, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Crunchbase's REST API. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Crunchbase to Claude or explore our broader architectural overview on connecting Crunchbase to AI Agents.

Giving a Large Language Model (LLM) access to a deep enterprise dataset like Crunchbase is an engineering challenge. You must handle complex query predicate payloads, navigate nested relationship "cards", and manage massive pagination schemas. Building static MCP schemas for a dynamic data provider means writing a schema parser that translates natural language intent into strict JSON parameters. If you skip this, your LLM will hallucinate endpoint paths and fail to format search queries correctly.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Crunchbase, connect it natively to ChatGPT, and execute complex market research workflows using natural language.

The Engineering Reality of the Crunchbase API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools (via JSON-RPC 2.0), implementing it against Crunchbase's highly specific API is exceptionally painful.

If you decide to build a custom MCP server for Crunchbase, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Crunchbase:

1. Complex Search Predicates

Crunchbase does not rely on simple REST query parameters (e.g., ?industry=ai&stage=series_a). Instead, searching organizations or funding rounds requires building deeply nested query objects with strict type, field_id, operator, and values syntax. For example, to find AI companies funded in the last 30 days, your LLM must construct a JSON array of predicates. Without a dynamically generated JSON Schema enforcing these exact payload requirements, ChatGPT will inevitably guess the structure and return HTTP 400 Bad Request errors.

2. Entity Polymorphism and Cards

Crunchbase structures its data using base entities and relational "Cards". If an LLM needs an organization's details, a standard GET request only returns base properties (name, UUID, permalink). To get the founders, headquarters address, or parent company, the LLM must explicitly request the correct card_ids. Mapping these available card types into an MCP schema so the model knows they exist is a tedious, manual mapping exercise if done from scratch.

3. Identifier Abstraction

Crunchbase responses wrap key references in an identifier object rather than returning flat strings. A company's industry isn't just "software"; it's an object containing entity_def_id, uuid, permalink, image_id, and value. Models easily hallucinate when traversing this if the MCP tool's response schema isn't perfectly mapped to instruct the LLM on how to parse the nested values.

Crunchbase to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Crunchbase API, follow these steps. Deeper architecture and security details live in the sections below.

What you need:

• A Truto account with API access.
• Crunchbase Enterprise API credentials.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

Step 1: Connect Crunchbase as an Integrated Account

In the Truto dashboard, open Integrated Accounts -> New Integrated Account, select Crunchbase, and authenticate using your API credentials. Truto securely vaults these credentials, ensuring ChatGPT never sees your raw API keys.

Step 2: Generate a Crunchbase MCP Server

Truto scopes MCP endpoints to specific connected accounts. You can generate this server via the Truto UI or the API.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your Crunchbase connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read methods only, tag filters).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>).

Method B: Via the Truto API Alternatively, generate the server programmatically. You will need your integrated_account_id.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Crunchbase Market Research",
    "config": {
      "methods": ["read"],
      "tags": ["organizations", "funding_rounds", "people"]
    }
  }'

The response returns a url field. This single URL carries routing and authentication - treat it like a secret.

Step 3: Connect the MCP Server to ChatGPT

Now, you must register this endpoint with ChatGPT.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click add a new server.
4. Name: Enter a label (e.g., "Crunchbase (Truto)").
5. Server URL: Paste the Truto MCP URL you copied earlier.
6. Save. ChatGPT connects, performs the initialization handshake, and lists available tools.

Method B: Via Manual Config File (Local Agents) If you are testing locally or using a CLI framework that mimics ChatGPT's tool calling (like LangChain or a local Claude Desktop instance for cross-testing), you use the SSE transport config:

{
  "mcpServers": {
    "crunchbase": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your-token-here>"
      ]
    }
  }
}

Hero Tools for Crunchbase

Truto dynamically generates MCP tools based on the live documentation and schema definitions of the Crunchbase integration. This guarantees that your LLM always has the correct parameters. Here are six high-leverage tools available for your AI agents:

get_single_crunchbase_organization_by_id

Retrieves the full organization entity including name, description, founded date, categories, and financials. You can use the field_ids and card_ids query parameters to select specific relationship cards.

"Fetch the full Crunchbase profile for the organization with permalink 'stripe', including their 'founders' card data."

list_all_crunchbase_search_organizations

Executes a complex search across all Crunchbase organizations using predicate-based filtering in the request body. The LLM constructs the predicate array to filter by industry, location, or funding stage.

"Search for all enterprise software organizations based in San Francisco that have raised a Series B round in the last 6 months."

list_all_crunchbase_search_funding_rounds

Searches funding round entities with advanced filtering. Returns the money_raised, investment_type, funded_organization_identifier, and num_investors.

"Find all seed funding rounds in the artificial intelligence sector announced this quarter, and list the amount raised for each."

get_single_crunchbase_person_by_id

Retrieves a single person entity by UUID or permalink. Useful for extracting founder history, returning first name, last name, and optional cards like jobs, degrees, or founded_organizations.

"Get the profile for the founder with UUID '1234abcd', and include their past 'jobs' and 'degrees' cards."

crunchbase_funding_rounds_get_card

Retrieves a specific relational card for a funding round entity. Crucial for pulling the actual investors or lead investors attached to a specific funding event.

"Get the 'investors' card for the funding round with UUID '5678efgh' to see which venture firms participated."

list_all_crunchbase_search_acquisitions

Searches acquisition entities to track market consolidation. Returns acquisitions with data on price, acquiree, acquirer, and status based on query predicates.

"List all acquisitions made by Microsoft in the cybersecurity space over the last two years, including the acquisition price if available."

For the complete inventory of available endpoints and their exact JSON schema requirements, view the Crunchbase integration page.

Workflows in Action

Connecting Crunchbase to ChatGPT unlocks powerful, multi-step market intelligence workflows. Because Truto handles the protocol translation, ChatGPT can chain these tools together autonomously.

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT (Client)
    participant Truto as Truto MCP Server
    participant Crunchbase as Crunchbase API

    User->>ChatGPT: "Analyze recent AI acquisitions"
    ChatGPT->>Truto: tools/call list_all_crunchbase_search_acquisitions
    Truto->>Crunchbase: POST /v4/data/searches/acquisitions
    Crunchbase-->>Truto: JSON (Acquisition data)
    Truto-->>ChatGPT: Tool result (uuid, acquiree, acquirer)
    ChatGPT->>Truto: tools/call get_single_crunchbase_organization_by_id
    Truto->>Crunchbase: GET /v4/data/entities/organizations/{id}
    Crunchbase-->>Truto: JSON (Target company details)
    Truto-->>ChatGPT: Tool result
    ChatGPT-->>User: Synthesized market report

Scenario 1: Venture Capital Due Diligence

Analysts spend hours cross-referencing funding announcements with founder backgrounds. AI agents can automate this instantly.

"Find all Series A funding rounds over $10M announced last month for AI companies. For the top 3 results, pull the organization profile and retrieve the 'founders' card to give me a summary of the founding team's previous experience."

Execution flow:

1. ChatGPT calls list_all_crunchbase_search_funding_rounds constructing a query predicate for investment_type = series_a and announced_on within the last 30 days.
2. ChatGPT extracts the funded_organization_identifier from the top 3 results.
3. It loops through and calls get_single_crunchbase_organization_by_id for each company, requesting the founders card in the parameters.
4. The agent synthesizes the nested JSON responses into a readable human brief detailing the companies and their founders.

Scenario 2: Competitor Acquisition Analysis

Tracking market consolidation requires mapping acquirers to acquirees and parsing the target companies' firmographics.

"List all recent acquisitions made by Salesforce. For the three most recent acquisitions, pull the target company's profile and tell me what industry categories they operate in."

Execution flow:

1. ChatGPT calls list_all_crunchbase_search_organizations to find Salesforce's exact UUID.
2. It calls list_all_crunchbase_search_acquisitions using a predicate where acquirer_identifier matches Salesforce's UUID.
3. It extracts the acquiree_identifier from the results.
4. It calls get_single_crunchbase_organization_by_id for each target company to pull their categories and short_description.
5. The user receives a cohesive report on Salesforce's latest M&A targets and their strategic sectors.

Architectural Note on Rate Limits

When exposing APIs to autonomous agents, rate limits are a critical failure point. It is important to note: Truto does not retry, throttle, or apply backoff on rate limit errors.

When the upstream Crunchbase API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the ChatGPT caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (or the LLM framework) is entirely responsible for interpreting these headers and executing the appropriate retry/backoff logic.

Security and Access Control

Exposing an enterprise data source like Crunchbase to an LLM requires strict governance. Truto provides multiple security controls natively via the MCP token configuration:

• Method Filtering: Restrict the MCP server to specific HTTP methods. By setting methods: ["read"] during token creation, you guarantee ChatGPT can only execute GET and LIST operations, completely eliminating the risk of accidental writes.
• Tag Filtering: Scope the available tools by resource area. Configuring tags: ["organizations", "funding_rounds"] ensures the LLM cannot access unrelated endpoints like billing or user management.
• Time-to-Live (TTL): Use the expires_at property to create temporary MCP servers. If you are generating a server for a one-off audit agent, the token will automatically expire and invalidate access at the designated time.
• Additional Authentication: By enabling require_api_token_auth: true, the MCP server URL alone is not enough to connect. The client must also pass a valid Truto API token in the Authorization header, adding a secondary defense layer for highly secure environments.

Skip the Boilerplate

Connecting ChatGPT to Crunchbase manually means writing custom schema parsers, managing OAuth token refreshes, and continuously updating your tool definitions whenever Crunchbase alters their payload structure.

By leveraging Truto's dynamically generated MCP servers, your AI agents always have real-time, documentation-driven access to the Crunchbase API. You eliminate the integration boilerplate and keep your engineering team focused on building core AI features.