Connect Captain Data to ChatGPT: Automate Prospecting & Enrichment

If you need to connect Captain Data to ChatGPT to automate high-volume prospecting, enrich company firmographics, or build autonomous sales pipelines, you need a Model Context Protocol (MCP) server. This server acts as a standardized translation layer between ChatGPT's JSON-RPC tool calls and Captain Data's REST API.

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

Giving a Large Language Model (LLM) read and write access to a powerful data extraction and enrichment engine like Captain Data presents massive engineering challenges. The API relies on complex, polymorphic identifiers (using uid for some lookups and li_profile_url for others), aggressive rate limits, and strict credit-based consumption models. If you build this integration in-house, your engineering team owns the entire lifecycle—maintaining tool schemas, parsing errors, and handling authentication state.

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

The Engineering Reality of the Captain Data API

A custom MCP server is essentially a self-hosted integration middleware. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Captain Data's highly specific API architecture is exceptionally painful.

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

Credit-Based API Economics

Captain Data operates on a strict credit consumption model where different endpoints incur different costs. For example, calling an enrichment endpoint might cost 1 credit, but running a Sales Navigator search costs 1 credit per request plus 1 credit per result. If an LLM is given unrestricted access to these endpoints without proper semantic instruction or access to the workspace consumption metrics, a runaway reasoning loop could burn hundreds of credits in minutes. Your MCP server needs to expose consumption tracking alongside the operational tools to ensure the agent acts within budget constraints.

Polymorphic Identity Resolution

API endpoints in Captain Data do not use a unified identifier format. When enriching a person, the API might require a LinkedIn profile URL (li_profile_url). When looking up a company's employees, it requires the Captain Data specific company_uid. When building a custom MCP server, you must write schema parsers that explicitly guide the LLM on which identifier to use for which tool. If you skip this, the LLM will hallucinate identifiers or pass URLs where UIDs are expected, resulting in persistent 400 Bad Request errors.

Transparent Rate Limits and the IETF Spec

Depending on your Captain Data plan, the API enforces strict rate limits (often between 5 to 100 requests per minute). When using Truto as your integration layer, it is critical to understand how this is handled: Truto does not retry, throttle, or apply backoff on rate limit errors. When the Captain Data upstream API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller.

However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This means your MCP client or AI agent framework must parse these headers and implement its own retry and backoff logic. Truto will not magically absorb 429 errors.

Step-by-Step: Connecting Captain Data to ChatGPT

To bypass the boilerplate of building a custom server, you can use Truto to dynamically generate a managed MCP server for Captain Data.

Step 1: Connect Captain Data to Truto

Before you can generate an MCP server, you must connect the target Captain Data workspace as an Integrated Account in Truto. This handles the underlying authentication (API keys) and maintains the connection state.

1. In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account.
2. Select Captain Data and provide the required API credentials.
3. Note the integrated_account_id generated by Truto.

Step 2: Create the MCP Server

You can create the MCP server URL either through the Truto UI or programmatically via the API.

Option A: Via the Truto UI

1. Navigate to the integrated account page for your Captain Data connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (name, allowed methods like "read" or "write", and specific resource tags).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Option B: Via the Truto API Send a POST request to Truto to provision an MCP server scoped specifically to this Captain Data account.

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": "Captain Data Prospecting Server",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["enrichment", "prospecting"]
    }
  }'

The response will return a secure url containing a cryptographic token. This single URL handles both routing and authentication—treat it as a secret.

Step 3: Connect the MCP Server to ChatGPT

Once you have the URL, you must register it with ChatGPT. You can do this natively in the UI or via a configuration file if you are using an overarching agent framework.

Option A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP support requires this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "Captain Data (Truto)").
5. Paste the Truto MCP URL into the Server URL field and click Add. ChatGPT will immediately connect, perform the MCP handshake, and list the available Captain Data tools.

Option B: Via Manual Config File (for local agents or desktop clients) If you are configuring a desktop client or an external agent framework that accepts standard MCP configuration files (like Claude Desktop or Cursor), you can proxy the SSE connection using the official MCP CLI:

{
  "mcpServers": {
    "captain_data": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN"
      ]
    }
  }
}

Captain Data Hero Tools

Truto automatically generates MCP tools based on Captain Data's underlying API schemas. Here are the highest-leverage tools available for your AI agents to automate prospecting and enrichment.

Search People via Sales Navigator

Tool: list_all_captain_data_search_peoples Executes a people search using a LinkedIn Sales Navigator query string. This is your agent's primary entry point for top-of-funnel discovery. It returns paginated results (25 per page) including the uid, name, job title, company, and LinkedIn URLs. Note: Costs 1 credit per request plus 1 per result.

"Run a Sales Navigator search for 'VP of Engineering' in 'San Francisco' focusing on B2B SaaS companies. Return the top 25 results and their profile URLs."

Enrich Person Profile

Tool: list_all_captain_data_people_enriches Fetches a comprehensive person profile directly from a LinkedIn profile URL. This returns high-fidelity data including identity, headline, location, current job, education, and company info. You can set full_enrich=true to force a preview of experiences and skills.

"Take this list of LinkedIn profile URLs and enrich each one to find their current job title and location."

List Work History and Experiences

Tool: list_all_captain_data_people_experiences Retrieves the full chronological work history of a prospect. The API accepts either a people_uid (preferred) or a li_profile_url. It returns one record per experience, detailing the title, company, dates, and location. Ideal for AI qualification checks (e.g., ensuring a prospect has 5+ years of management experience).

"Look up the work history for this candidate using their LinkedIn URL. Summarize their past three roles and calculate their total tenure at their current company."

Search Companies via Sales Navigator

Tool: list_all_captain_data_search_companies Executes a company search using a LinkedIn Sales Navigator query. Returns paginated company data (25 per page) including the uid, name, description, size, and URLs. Use this to build target account lists before searching for individual stakeholders.

"Search for companies in the 'Financial Services' industry with a headcount between 50-200 located in London."

Enrich Company Profile

Tool: list_all_captain_data_companies_enriches Provides a deep-dive company profile based on a LinkedIn company URL. Returns description, exact industry tagging, size, headquarters, office locations, funding data, website, and affiliates.

"Enrich this list of 10 company URLs and extract their website domains and total funding amounts."

Check Workspace Consumption

Tool: list_all_captain_data_workspaces_consumptions Retrieves credit consumption for the current billing month, broken down by specific action. Giving your LLM access to this tool allows it to self-audit its credit spend and pause high-volume operations if budgets are nearing exhaustion.

"Check our Captain Data workspace consumption. How many credits have we spent on people enrichment this month, and how many total credits remain?"

To view the complete schema definitions and the full list of available operations, view the Captain Data integration page.

Workflows in Action

When you connect Captain Data to ChatGPT via MCP, you empower the model to chain multiple complex API calls together. Here are two real-world prospecting workflows.

Scenario 1: Targeted Lead Generation and Qualification

An SDR needs to build a highly qualified list of engineering leaders in a specific region and verify their career trajectory.

"Search for VPs of Engineering at Series B B2B SaaS companies in New York. For the top 5 results, enrich their profiles to confirm their current company, then pull their full work history to see if they've held a VP title previously. Summarize the qualified candidates in a table."

Execution Steps:

1. ChatGPT calls list_all_captain_data_search_peoples using a constructed Sales Navigator query string.
2. The model iterates over the top 5 returned profiles, calling list_all_captain_data_people_enriches using the extracted li_profile_urls.
3. To verify past titles, the model calls list_all_captain_data_people_experiences for each candidate.
4. ChatGPT evaluates the JSON payloads, formats the data, and returns a clean, filtered Markdown table to the user.

sequenceDiagram
    participant User
    participant Agent as ChatGPT (Client)
    participant MCP as Truto MCP Server
    participant Upstream as Captain Data API

    User->>Agent: "Find VPs of Engineering..."
    
    Agent->>MCP: Call list_all_captain_data_search_peoples
    MCP->>Upstream: Execute Search Query
    Upstream-->>MCP: Return 25 results
    MCP-->>Agent: JSON list of profiles
    
    loop For Top 5 Profiles
        Agent->>MCP: Call list_all_captain_data_people_enriches
        MCP->>Upstream: Fetch profile data
        Upstream-->>MCP: Return enriched profile
        MCP-->>Agent: JSON profile details
        
        Agent->>MCP: Call list_all_captain_data_people_experiences
        MCP->>Upstream: Fetch work history
        Upstream-->>MCP: Return chronological roles
        MCP-->>Agent: JSON work history
    end
    
    Agent-->>User: Render qualified candidates table

Scenario 2: Account-Based Intelligence

An Account Executive needs to map out the organizational structure of a target account before a discovery call, while ensuring they don't blow through the team's API budget.

"Check our workspace credit limits first. If we have more than 500 credits left, get the full company profile for Stripe from its LinkedIn URL. Then, find all employees currently at Stripe with the 'Sales Manager' title and list their LinkedIn profile URLs."

Execution Steps:

1. ChatGPT calls list_all_captain_data_workspaces_consumptions to verify available credits.
2. Assuming sufficient credits, the model calls list_all_captain_data_companies_enriches to extract Stripe's firmographic data and, crucially, the company_uid.
3. The model passes the company_uid into list_all_captain_data_company_employees, filtering for the "Sales Manager" title.
4. The agent outputs the company overview alongside the list of target stakeholders.

Security and Access Control

When exposing powerful enrichment tools to AI agents, security is paramount. Truto's MCP infrastructure provides granular controls over what your agents can see and do:

• Method Filtering: Restrict servers to specific HTTP verbs. You can constrain an agent to methods: ["read"] (only GET/LIST) to prevent it from accidentally executing mutative actions.
• Tag Filtering: Scope servers to specific domains. By passing tags: ["enrichment"], you ensure the LLM only sees tools related to profile enrichment, hiding irrelevant endpoints and reducing token overhead.
• Dual-Layer Authentication (require_api_token_auth): By default, possessing the MCP server URL is enough to connect. Enabling this flag forces the client to also provide a valid Truto API token in the Authorization header, meaning the URL cannot be abused if leaked.
• Ephemeral Access (expires_at): You can set an exact ISO datetime for the server to expire. Once reached, Truto's durable edge schedulers automatically destroy the token, severing the agent's access instantly.

Behind the MCP: How Truto Auto-Generates Tools

Unlike traditional integration platforms where developers must hand-code every tool definition, Truto's MCP servers are dynamic and documentation-driven.

When ChatGPT requests the list of tools, Truto doesn't serve a static JSON file. Instead, it inspects the Captain Data integration configuration and matches available API endpoints against a centralized documentation repository. A tool only appears in the MCP server if it has a corresponding documentation entry detailing its description, query parameters, and body schemas. This acts as a strict quality gate—ensuring the LLM only receives well-documented, semantically clear tools.

Furthermore, the raw MCP token is never stored in plaintext. When you generate a server, the token is hashed via HMAC and stored in a globally distributed edge key-value store for rapid validation. When ChatGPT executes a tool, Truto maps the LLM's flat JSON argument payload into the correct query parameters and request bodies expected by Captain Data, completely abstracting the API mechanics away from the prompt layer.

Final Thoughts

Building AI agents that can autonomously prospect, enrich leads, and manage API credit budgets is the holy grail of modern sales ops. But forcing your engineering team to write bespoke schemas, manage OAuth refresh loops, and parse raw 429 rate limits is a waste of resources.

By connecting Captain Data to ChatGPT via Truto's MCP servers, you offload the entire infrastructure burden. Your agents get immediate, secure access to the tools they need, and your engineers get back to building your core product.