---
title: "Connect Captain Data to Claude: Scale Lead Sourcing & Company Intel"
slug: connect-captain-data-to-claude-scale-lead-sourcing-company-intel
date: 2026-10-04
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect Captain Data to Claude. Automate LinkedIn scraping, lead enrichment, and company intel without exposing credentials."
tldr: "Connect Captain Data to Claude via a managed MCP server to automate B2B prospecting. This guide covers API realities, secure MCP setup, hero tools, and real-world scraping workflows."
canonical: https://truto.one/blog/connect-captain-data-to-claude-scale-lead-sourcing-company-intel/
---

# Connect Captain Data to Claude: Scale Lead Sourcing & Company Intel

**Captain Data in Claude, in about a minute.** The best way to connect Captain Data to Claude is Elaichi: connect Captain Data to Elaichi once, then add Elaichi to Claude as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect Captain Data.** Connect Captain Data once in Elaichi. Claude never gets more access than you have.
3. **Add Elaichi to Claude.** In Claude, open Customize, then Connectors, press Add and paste https://api.elaichi.ai/mcp. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=captaindata) · [Captain Data on Elaichi](https://elaichi.ai/connectors/captaindata/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=captaindata)

*Building Captain Data into your own product? The guide below is for you.*

---

If your team needs to connect Captain Data to Claude to automate B2B lead sourcing, enrich LinkedIn profiles, or extract company intelligence, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's tool calls and Captain Data's specialized REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on [connecting Captain Data to ChatGPT](https://truto.one/connect-captain-data-to-chatgpt-automate-prospecting-enrichment/) or explore our broader architectural overview on [connecting Captain Data to AI Agents](https://truto.one/connect-captain-data-to-ai-agents-map-work-history-professional-data/).

Giving a Large Language Model (LLM) read and write access to a powerful scraping and enrichment engine like Captain Data is an engineering challenge. You have to handle complex nested JSON responses, map exact parameter combinations (like providing exactly a domain or a company name, but never both), and deal with strict credit limits. Every time Captain Data updates an endpoint or deprecates a search parameter, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Captain Data, connect it natively to Claude Desktop, and execute complex lead-generation workflows using natural language.

> Want to give your AI agents secure, authenticated access to Captain Data and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Captain Data API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specialized B2B data APIs is painful. Captain Data is built to execute large-scale web scraping, LinkedIn Sales Navigator searches, and data enrichment. Its API reflects the complexity and cost of those operations.

If you decide to [build a custom Captain Data MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), here are the specific integration challenges you will face:

**Financial Risk via Credit Consumption**
Unlike a standard CRM API where an infinite loop might just hit a rate limit, Captain Data operates on a strict credit economy. For example, `list_all_captain_data_search_peoples` costs 1 credit per request *plus* 1 credit per result. If an LLM hallucinates a loop to paginate through 10,000 Sales Navigator results, it will instantly burn through your monthly workspace budget. You must build strict guardrails, pagination limits, and cost-monitoring tools into your MCP server to prevent an agent from bankrupting your account.

**Mutually Exclusive Input Parameters**
Captain Data enforces strict validation on its inputs. When looking up a company, the API demands exactly one identifier—either the `domain` or the `company_name`. If an LLM sends both in the same payload, the API throws an error. Your MCP server must explicitly guide the LLM via carefully constructed JSON Schemas, using `oneOf` constraints or detailed property descriptions, to ensure the model formats its requests correctly.

**Strict Quotas and 429 Handling**
Captain Data enforces strict rate limits depending on your plan tier (ranging from 5 to 100 requests per minute). It is critical to understand how this is handled in a managed environment: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream Captain Data API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller—in this case, your MCP client or AI orchestration layer—is entirely responsible for reading these headers and implementing its own retry or backoff logic.

## Creating the Managed Captain Data MCP Server

Instead of building a JSON-RPC 2.0 server from scratch and hand-coding schemas for Captain Data's complex enrichment endpoints, you can use Truto to generate a managed MCP server dynamically. The server is scoped to a specific authenticated Captain Data workspace and derives its tool definitions directly from the integration's underlying documentation.

You can create this MCP server in two ways: via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

For quick prototyping or internal team use, the UI is the fastest path:

1. Log in to your Truto dashboard and navigate to your **Integrated Accounts**.
2. Select the connected Captain Data account you want the LLM to access.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. (For example, you might want to restrict the LLM to `read` methods to prevent it from launching expensive automated extraction jobs without oversight).
6. Click Save and **copy the generated MCP server URL**. It will look something like `https://api.truto.one/mcp/a1b2c3d4e5f6...`.

### Method 2: Via the Truto API

For production deployments where you need to provision MCP servers dynamically for your own users, use the Truto API. This validates the configuration, generates a secure cryptographic token, and provisions the edge endpoint.

Execute a `POST` request to `/integrated-account/:id/mcp`:

```bash
curl -X POST https://api.truto.one/admin/integrated-accounts/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Captain Data Sales Intel Agent",
    "config": {
      "methods": ["read", "custom"],
      "tags": ["enrichment", "search"]
    }
  }'
```

The API responds with the server details and the critical connection URL:

```json
{
  "id": "mcp_srv_9x8y7z6",
  "name": "Captain Data Sales Intel Agent",
  "config": {
    "methods": ["read", "custom"],
    "tags": ["enrichment", "search"],
    "require_api_token_auth": false
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Connecting the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero additional code. The URL itself contains the secure cryptographic token needed to route the request to the correct Captain Data workspace.

### Method A: Via the Claude UI (or ChatGPT)

If you are using an AI chat interface that supports custom connectors:

**For Claude:**
1. Open Claude and navigate to **Settings → Integrations → Add MCP Server**.
2. Paste your Truto MCP URL (`https://api.truto.one/mcp/...`).
3. Click **Add**. Claude will instantly execute an `initialize` handshake and discover the Captain Data tools.

**For ChatGPT (Enterprise/Pro):**
1. Navigate to **Settings → Apps → Advanced settings**.
2. Enable **Developer mode**.
3. Under MCP servers / Custom connectors, click add and paste the Truto MCP URL.
4. Save to complete the connection.

### Method B: Via Manual Config File (Claude Desktop)

If you are using the Claude Desktop app or building a local agent, you connect via the `claude_desktop_config.json` file. Because Truto provides the server over HTTPS via Server-Sent Events (SSE), you use the official `@modelcontextprotocol/server-sse` transport.

Add this to your configuration file:

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

Restart Claude Desktop. The agent now has native access to your Captain Data workspace.

## Hero Tools for Lead Sourcing

Truto [automatically generates highly descriptive, AI-optimized tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) from the Captain Data API documentation. The schemas include explicit instructions—like warning the LLM about credit consumption or parameter exclusivity—so the model knows exactly how to format its requests.

Here are 6 high-leverage hero tools exposed by the Captain Data MCP server.

### 1. `list_all_captain_data_people_finds`
This tool allows the LLM to find a specific person by their full name, optionally narrowed by their company name. It returns the person's unique UID, LinkedIn profile URL, and profile ID. 

*Contextual Note: This costs 2 credits per execution. Ensure the LLM has the exact `full_name` before calling it to avoid wasting credits on ambiguous searches.*

> "Find the LinkedIn profile URL for 'Jane Doe' who works at 'Acme Corp'."

### 2. `list_all_captain_data_search_peoples`
Executes a complex LinkedIn Sales Navigator people query. It returns a page of people (up to 25 per page) including their UID, name, job title, company, and URLs. 

*Contextual Note: This is an expensive operation (1 credit per request + 1 per result). The LLM is instructed via the schema to carefully formulate the `query` parameter to be as specific as possible.*

> "Run a Sales Navigator search for 'VP of Engineering' in the San Francisco Bay Area in the Software Development industry, and return the top 10 results."

### 3. `list_all_captain_data_people_enriches`
Takes a standard LinkedIn profile URL and returns a comprehensive, enriched profile including identity, headline, location, current job, education, and company data. Setting `full_enrich=true` adds a preview of experiences and skills.

> "Take this LinkedIn URL (linkedin.com/in/janedoe) and run a full enrichment. Give me a summary of her current role, past two companies, and top 5 skills."

### 4. `list_all_captain_data_search_companies`
Executes a LinkedIn Sales Navigator company query. Returns a paginated list of companies including their UID, name, description, LinkedIn URLs, and company size data.

> "Search for B2B SaaS companies in London with a headcount between 50 and 200 employees."

### 5. `list_all_captain_data_workspaces_consumptions`
A critical operational tool. Retrieves the credit consumption for the current billing month, broken down by action.

*Contextual Note: You should instruct your AI agent to call this tool before running large bulk searches to ensure you have sufficient budget remaining.*

> "Check our Captain Data workspace consumption. How many credits have we spent this month on 'search_peoples', and how many total credits do we have left?"

### 6. `list_all_captain_data_quotas`
Retrieves the workspace quota, including the plan name, credits used, credits left, and the current billing period timeframe. 

> "Verify our current API quota and let me know when our billing period resets so we can plan our next batch extraction."

For the complete tool inventory, required fields, and schema definitions, visit the [Captain Data integration page](https://truto.one/integrations/detail/captaindata).

## Workflows in Action

When Claude is connected to the Captain Data MCP server, you move beyond simple Q&A. The LLM can orchestrate multi-step intelligence gathering workflows autonomously.

### Workflow 1: Target Account Expansion

A common RevOps task is identifying a target company and finding the key decision-makers within it.

> "Find the company UID for 'Stripe', then search for all people with the title 'Director of Partnerships' at that company. Finally, enrich the profile of the top result and summarize their recent work experience."

**How Claude executes this:**
1. Calls `list_all_captain_data_companies_finds` with `{ "company_name": "Stripe" }` to retrieve the `company_uid`.
2. Calls `list_all_captain_data_company_employees` passing the `company_uid` and filtering by the query "Director of Partnerships".
3. Extracts the `li_profile_url` of the first returned employee.
4. Calls `list_all_captain_data_people_enriches` with `full_enrich=true` using that URL.
5. Synthesizes the raw JSON response into a readable executive summary.

```mermaid
flowchart TD
    A["Claude<br>Receives Prompt"] --> B["list_all_captain_data_companies_finds<br>Locate Company UID"]
    B --> C["list_all_captain_data_company_employees<br>Search 'Director of Partnerships'"]
    C --> D["Extract Target URL<br>Select top match"]
    D --> E["list_all_captain_data_people_enriches<br>Scrape full profile"]
    E --> F["Synthesize Data<br>Return Executive Summary"]
```

### Workflow 2: Automated Credit Monitoring & Rate Limit Handling

Because AI agents can loop rapidly, you need to ensure they don't hit hard rate limits (HTTP 429) or drain your account.

> "I need a list of CTOs in New York. First, check our remaining Captain Data quota. If we have more than 500 credits left, execute the search. If the API returns a rate limit error, tell me exactly when the limit resets based on the headers."

**How Claude executes this:**
1. Calls `list_all_captain_data_quotas` to evaluate `credits_left`.
2. Evaluates the logic: if credits > 500, proceed.
3. Calls `list_all_captain_data_search_peoples` with the query "CTO New York".
4. If Captain Data is overloaded and returns an HTTP 429, Truto passes the error back to Claude along with `ratelimit-reset`. Claude reads the JSON-RPC error, parses the reset time, and informs the user to try again later, honoring the API's constraints without infinite looping.

## Security and Access Control

Exposing a credit-based system like Captain Data to an AI model requires strict governance. Truto's managed MCP server architecture provides fine-grained access control at the server level, ensuring the LLM only has access to what it strictly needs.

*   **Method Filtering:** When creating the MCP server, you can restrict it to specific operation types. By configuring `methods: ["read", "list"]`, you guarantee the LLM cannot trigger expensive `create` or `write` extraction jobs without human approval.
*   **Tag Filtering:** You can restrict the server to specific domains. For example, applying `tags: ["company-intel"]` ensures the LLM can only access company search endpoints, not personal employee lookups.
*   **Extra Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access. For higher security, enabling this flag forces the MCP client to also pass a valid Truto API token in the Authorization header. This means the URL alone is useless if leaked in a config file.
*   **Expiration (`expires_at`):** You can generate ephemeral MCP servers. By setting an ISO datetime for `expires_at`, the server will automatically self-destruct. This is perfect for giving a contractor or temporary AI agent 48 hours of access to your Captain Data workspace to run a specific campaign.

## Moving Forward with Agentic Scraping

Connecting Captain Data to Claude transforms how your team handles outbound intelligence. Instead of manually exporting CSVs from Sales Navigator, running them through Captain Data workflows, and parsing the results in spreadsheets, you can orchestrate the entire pipeline through natural language. 

By leveraging a managed MCP server via Truto, you eliminate the overhead of building JSON-RPC layers, mapping complex scraping schemas, and handling token authentication. Your agents get immediate, secure access to the data, and your engineering team avoids another integration maintenance burden.

> Ready to give your AI agents autonomous access to Captain Data, CRMs, and 100+ other enterprise APIs? Let's talk about managed MCP infrastructure.
>
> [Talk to us](https://truto.one/book-a-demo/)