Connect Crunchbase to AI Agents: Track Startups, Deals, and Talent

You want to connect Crunchbase to an AI agent so your system can autonomously track startup funding, source investment deals, map competitor acquisitions, and identify executive talent. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to write and maintain complex custom integrations for the Crunchbase API.

Giving a Large Language Model (LLM) read access to your Crunchbase instance is an engineering challenge heavily rooted in schema management and API quirk resolution. You either spend weeks building a custom connector that handles complex predicate-based search queries and nested relationship cards, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting Crunchbase to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting Crunchbase to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for Crunchbase, bind them natively to an LLM using LangChain (or any framework like LangGraph, CrewAI, or Vercel AI SDK), and execute complex firmographic and financial workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.

The Engineering Reality of the Crunchbase API

Giving an LLM access to external firmographic data sounds simple in a prototype. You write a standard HTTP fetch request and wrap it in a tool decorator. When you deploy this against the Crunchbase API in production, this approach collapses.

Crunchbase's architecture introduces specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, you will spend your sprints writing defensive code instead of improving your model's reasoning capabilities. Here is what makes Crunchbase specifically tricky for LLMs.

Predicate-Based Search Architecture

Crunchbase does not use standard query parameters for filtering (e.g., ?industry=software&funding_total>1000000). Instead, the search endpoints require complex JSON payloads defining predicates. A predicate requires a specific field_id, an operator_id (like eq, contains, gte), and an array of values. Furthermore, multiple predicates are strictly AND-ed together by default. If you expose raw Crunchbase search directly to an LLM, the model will inevitably hallucinate invalid operators, use incorrect field IDs, or format the JSON array incorrectly. Truto's proxy tool schemas explicitly define the accepted operators and field IDs, forcing the LLM to adhere to the strict structural requirements before the network request is even made.

The Entity and Card Data Model

Crunchbase limits payload bloat by utilizing a "Card" system. When you request a single organization or person entity, you do not receive their entire relational graph. An organization's base entity does not automatically include its founders or recent funding rounds. To get that data, you must explicitly request specific relational cards (e.g., founders, child_ownerships, event_appearances). Standard LLMs struggle with this two-step relational mapping. They assume a get_organization call returns everything. Truto separates these out into distinct, clearly defined tools (e.g., crunchbase_organizations_get_card), allowing the agent to reason through the relational graph step-by-step.

Polymorphic Identifiers

Crunchbase allows you to query entities using either a UUID (a 32-character hex string) or a permalink (the string used in the Crunchbase URL). However, standardizing these across interconnected systems (like matching a Crunchbase UUID to a Salesforce Account ID) requires exact precision. When returning deleted entities or tracking historical changes, the identifier logic requires strict parsing. Truto's unified proxy layer normalizes the schema expectation, ensuring the LLM understands exactly which string format to pass into subsequent tool calls.

Crunchbase Hero Tools for AI Agents

A unified proxy layer exposes Crunchbase's complex capabilities as distinct, strictly typed functions. By calling Truto's /integrated-account/<id>/tools endpoint, you provide your LLM with a safe, deterministic interface to navigate the Crunchbase graph.

Here are the highest-leverage tools to equip your AI agent with.

list_all_crunchbase_search_organizations

This tool executes complex, predicate-based searches against Crunchbase's organization database. It is the primary entry point for list building, market mapping, and deal sourcing. The schema forces the LLM to provide exact field_ids and construct valid query operators, returning up to 1,000 matching entities.

"Find all enterprise software companies headquartered in San Francisco that were founded after 2020 and have raised Series A funding. Return their name, short description, and website URL."

get_single_crunchbase_organization_by_id

Once an agent identifies a target company, this tool retrieves the deep firmographic profile using the organization's UUID or permalink. It returns core fields like founded date, company type, website, and NAICS codes.

"Retrieve the full firmographic profile for the organization with the permalink 'truto' to determine their primary industry categories and exact founding date."

crunchbase_organizations_get_card

This tool is critical for navigating relationships. It allows the agent to extract nested data arrays attached to a specific organization, such as their founders, board members, headquarters address, or parent organization. It prevents the agent from guessing relational paths.

"Fetch the 'founders' card for the organization UUID 1234abcd-5678-efgh to get the names and permalinks of the founding team."

list_all_crunchbase_search_funding_rounds

This tool allows the agent to scan the market for capital movement. It supports complex filtering to find specific investment types, money raised thresholds, and announced dates. It is essential for triggering workflows based on recent funding events.

"Search for all Seed and Series A funding rounds announced in the last 30 days within the artificial intelligence sector where the money raised exceeds 5 million dollars."

list_all_crunchbase_search_people

This tool searches the Crunchbase graph for specific individuals based on job titles, primary organizations, or names. It is highly effective for automated talent mapping and executive tracking.

"Find people whose primary job title contains 'Chief Technology Officer' and who are currently associated with organizations in the cybersecurity category."

crunchbase_people_get_card

Similar to the organization card tool, this retrieves specific relational data for a person. An agent uses this to pull a person's employment history (jobs), academic background (degrees), or organizations they have founded.

"Get the 'jobs' card for the person with permalink 'jane-doe' to analyze their previous executive roles before joining their current company."

To view the complete inventory of available proxy tools, query parameters, and JSON schemas for this API, visit the Crunchbase integration page.

Workflows in Action

When you bind these tools to a reasoning engine like GPT-4o or Claude 3.5 Sonnet, you can execute complex market intelligence routines autonomously.

Automated Deal Flow and Competitor Triage

Investment teams and corporate development units spend hours manually tracking market movements. An agent can completely automate the initial triage of a sector.

"Analyze the recent activity in the supply chain logistics software market. Find companies that raised a Series B in the last quarter, extract their founding teams, and summarize their core value propositions."

1. The agent calls list_all_crunchbase_search_funding_rounds with predicates filtering for 'Series B', the specific date range, and the industry category.
2. For each funding round returned, the agent extracts the funded_organization_identifier.
3. The agent loops through get_single_crunchbase_organization_by_id for each organization to pull their short description and website.
4. The agent then calls crunchbase_organizations_get_card (requesting the founders card) for each company to identify the leadership team.
5. The agent compiles this unstructured data into a structured market brief and returns it to the user.

Executive Talent and Track Record Mapping

Recruiting teams mapping out a specific talent pool need historical context that isn't always easily searchable. An agent can cross-reference people and their past company performance.

"I need a list of former VP of Engineering candidates who worked at companies that eventually went public or were acquired for over $100M. Find 5 candidates fitting this profile."

1. The agent calls list_all_crunchbase_search_people with a title predicate for 'VP of Engineering' or 'Vice President of Engineering'.
2. The agent loops over the returned candidates, calling crunchbase_people_get_card (requesting the jobs card) to get their employment history.
3. For the past employers identified in the jobs card, the agent calls crunchbase_organizations_get_card (requesting the parent_ownership or cross-referencing IPO endpoints) to determine exit status.
4. The agent discards candidates whose previous companies did not meet the exit criteria and returns a finalized list of verified candidates with a summary of their track record.

Building Multi-Step Workflows

To build these autonomous workflows in production, your code must handle the realities of API interaction - specifically, rate limiting and pagination. Truto normalizes the interface, but the agent still needs to respect the infrastructure.

Handling Crunchbase Rate Limits

Crunchbase enforces strict rate limits to protect its infrastructure. Truto does not silently absorb, retry, or apply backoff to rate limit errors. If you exceed the quota, the upstream API returns an HTTP 429 Too Many Requests error, which Truto immediately passes back to your caller.

Crucially, Truto normalizes the upstream rate limit information into standard IETF headers across all integrations. When your agent receives a 429, the response will contain ratelimit-limit, ratelimit-remaining, and ratelimit-reset. Your agent execution loop is responsible for catching this error, reading the ratelimit-reset header, and pausing execution before retrying.

Here is how this architectural flow works:

sequenceDiagram
    participant Agent as AI Agent Loop
    participant SDK as TrutoToolManager
    participant Truto as Truto Proxy API
    participant CB as Crunchbase API

    Agent->>SDK: Execute search_organizations
    SDK->>Truto: POST /proxy/crunchbase/search<br>with Bearer Token
    Truto->>CB: Forward complex predicate query
    CB-->>Truto: HTTP 429 Too Many Requests
    Note over Truto: Normalizes headers to<br>IETF standard
    Truto-->>SDK: HTTP 429<br>(ratelimit-reset: 60)
    SDK-->>Agent: Tool execution error (429)
    Note over Agent: Catch error<br>Parse ratelimit-reset<br>Sleep for 60 seconds
    Agent->>SDK: Retry search_organizations
    SDK->>Truto: POST /proxy/crunchbase/search
    Truto->>CB: Forward query
    CB-->>Truto: HTTP 200 OK
    Truto-->>SDK: Normalized JSON Response
    SDK-->>Agent: Tool execution success

Binding Tools to the Agent Framework

Fetching the tools and binding them to an LLM is straightforward using Truto's SDKs. The /tools endpoint dynamically provides the OpenAPI schemas that your framework (like LangChain) requires.

Here is a complete, framework-agnostic architectural pattern using the TrutoToolManager from the Langchain.js toolset. This script fetches the Crunchbase tools, binds them to a model, and executes a multi-step reasoning loop with robust error handling for rate limits.

import { ChatOpenAI } from "@langchain/openai";
import { TrutoToolManager } from "@trutohq/langchainjs-toolset";
import { HumanMessage } from "@langchain/core/messages";
 
async function runCrunchbaseAgent() {
  // 1. Initialize the LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
  });
 
  // 2. Initialize Truto Tool Manager for the Crunchbase integration
  const toolManager = new TrutoToolManager({
    trutoApiKey: process.env.TRUTO_API_KEY,
    integratedAccountId: process.env.CRUNCHBASE_ACCOUNT_ID,
  });
 
  // 3. Fetch all available Crunchbase tools dynamically
  console.log("Fetching Crunchbase tools...");
  const tools = await toolManager.getTools();
  
  // 4. Bind the strictly typed schemas to the LLM
  const llmWithTools = llm.bindTools(tools);
 
  // 5. Define the user objective
  const messages = [new HumanMessage("Find 3 enterprise software companies founded after 2022. Then look up who their founders are.")];
 
  // 6. Execute the agent loop with explicit rate limit handling
  console.log("Starting agent reasoning loop...");
  let isDone = false;
 
  while (!isDone) {
    const response = await llmWithTools.invoke(messages);
    messages.push(response);
 
    if (response.tool_calls && response.tool_calls.length > 0) {
      for (const toolCall of response.tool_calls) {
        console.log(`Executing tool: ${toolCall.name}`);
        
        const selectedTool = tools.find((t) => t.name === toolCall.name);
        if (!selectedTool) continue;
 
        try {
          const toolResult = await selectedTool.invoke(toolCall.args);
          messages.push({
            role: "tool",
            name: toolCall.name,
            tool_call_id: toolCall.id,
            content: JSON.stringify(toolResult),
          });
        } catch (error: any) {
          // Explicitly handle 429 Rate Limits using Truto's normalized headers
          if (error.response && error.response.status === 429) {
            const resetTime = error.response.headers['ratelimit-reset'];
            const waitTime = resetTime ? parseInt(resetTime, 10) * 1000 : 60000;
            console.warn(`Rate limit hit. Sleeping for ${waitTime}ms...`);
            
            // Backoff logic
            await new Promise((resolve) => setTimeout(resolve, waitTime));
            
            // Inform the LLM of the delay and failure so it can retry
            messages.push({
              role: "tool",
              name: toolCall.name,
              tool_call_id: toolCall.id,
              content: JSON.stringify({ 
                error: "Rate limit exceeded. System backed off. Please retry the exact same tool call." 
              }),
            });
          } else {
             // Handle generic tool errors
             messages.push({
              role: "tool",
              name: toolCall.name,
              tool_call_id: toolCall.id,
              content: JSON.stringify({ error: error.message }),
            });
          }
        }
      }
    } else {
      // The LLM has reached a final answer
      isDone = true;
      console.log("\nFinal Output:\n", response.content);
    }
  }
}
 
runCrunchbaseAgent().catch(console.error);

By pulling tools dynamically via Truto, you ensure that if Crunchbase updates a query parameter schema or adds a new filter property, your agent automatically inherits those changes without you having to manually update a hardcoded OpenAPI spec in your codebase.

Moving from Manual Research to Autonomous Intelligence

Giving an AI agent access to Crunchbase fundamentally changes how your system interacts with market data. Instead of building static dashboards or manual search interfaces, you empower your users to execute conversational, multi-step research queries that comb through thousands of records in seconds.

However, building and maintaining the infrastructure to support this - managing OAuth lifecycles, normalizing complex schema permutations, and surfacing predictable error codes - drains engineering velocity. By using Truto's proxy APIs and /tools endpoint, you abstract away the API friction and focus entirely on prompt engineering and agent reliability.