---
title: "Connect Kaspr to Claude: Automate Lead Enrichment & Manage Limits"
slug: connect-kaspr-to-claude-automate-lead-enrichment-manage-limits
date: 2026-10-19
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Kaspr to Claude using a managed MCP server. Automate LinkedIn lead enrichment, parse nested contact data, and safely manage API limits."
tldr: "Connect Kaspr to Claude using Truto's managed MCP server to automate B2B lead enrichment. This guide shows how to expose Kaspr credits, rate limits, and profile enrichment tools securely."
canonical: https://truto.one/blog/connect-kaspr-to-claude-automate-lead-enrichment-manage-limits/
---

# Connect Kaspr to Claude: Automate Lead Enrichment & Manage Limits


If your sales or revenue operations team needs to connect Kaspr to Claude to automate lead enrichment, audit workspace credit limits, or verify prospect contact data at scale, 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 function calling capabilities and Kaspr's REST API. 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 [/connect-kaspr-to-chatgpt-enrich-linkedin-data-monitor-credits/](https://truto.one/connect-kaspr-to-chatgpt-enrich-linkedin-data-monitor-credits/) or explore our broader architectural overview on [/connect-kaspr-to-ai-agents-scale-contact-enrichment-usage-tracking/](https://truto.one/connect-kaspr-to-ai-agents-scale-contact-enrichment-usage-tracking/).

Giving a Large Language Model (LLM) read and write access to a specialized B2B contact database like Kaspr is a unique engineering challenge. You have to handle API key lifecycles, map nested JSON schemas containing arrays of personal and professional emails to MCP tool definitions, and deal with Kaspr's strict credit economy and rate limits. Every time an endpoint changes, 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 Kaspr, connect it natively to Claude Desktop, and execute complex lead enrichment workflows using natural language.

> Want to give your AI agents secure, authenticated access to Kaspr and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Kaspr 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 a [data enrichment provider](https://truto.one/connect-cognism-to-claude-discover-and-enrich-high-value-accounts/) is unforgiving. Kaspr is built to map sparse social inputs (like a LinkedIn profile URL) to highly structured, multi-channel contact arrays. Its API reflects that complexity.

If you decide to build a custom Kaspr MCP server, here are the specific integration challenges you will face:

**The Credit-Based API Economy**
Kaspr does not just limit how many requests you make - it limits what data you can successfully retrieve based on a complex credit system. Retrieving a work email costs a different credit type than retrieving a direct phone number, and exporting a profile consumes yet another credit. If you give an LLM unrestrained access to the enrichment endpoint without context, it will happily iterate through 5,000 LinkedIn profiles and immediately bankrupt your Kaspr workspace. Your integration layer must expose credit auditing tools first, and your system prompts must mandate that the LLM verify balances before executing batch enrichment loops.

**Strict Rate Limits and IETF Normalization**
Kaspr enforces strict request quotas at the minute, hourly, and daily levels. When an LLM executes a rapid sequence of tool calls, it is incredibly easy to hit a 429 Too Many Requests error. Truto does not automatically retry, throttle, or apply backoff on rate limit errors. Instead, when the upstream Kaspr API returns a 429, Truto passes that error directly to the caller while normalizing the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Your MCP client architecture - or the LLM itself - is responsible for reading these headers and orchestrating the necessary backoff strategy.

**Nested Contact Arrays**
When you successfully enrich a profile, the response payload is not a simple flat object. Kaspr returns distinct arrays for `professionalEmails`, `personalEmails`, and `phones`. An LLM trying to construct a JSON response or CRM payload must understand how to traverse these arrays, pick the primary contact method, and handle null values when certain data types were not found. The MCP tool schema must precisely map these arrays so Claude knows exactly how to parse the result.

## Creating the Managed Kaspr MCP Server

Instead of building a local Node.js or Python server to handle Kaspr's schemas, authentication, and error bubbling, you can use Truto to generate a managed MCP server. This server dynamically translates Kaspr's OpenAPI definitions into JSON-RPC 2.0 tools that Claude can natively understand.

Truto scopes each MCP server to a single integrated account. This means the server URL contains a cryptographically signed token that authenticates requests specifically for your Kaspr workspace. You can create this server through the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

If you are manually setting up an environment for your internal operations team, the UI is the fastest path.

1. Log into your Truto dashboard and navigate to the integrated account page for your Kaspr connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Define your configuration settings. You can optionally restrict the server to only `read` methods or apply specific tags (we will cover this in the Security section).
5. Click Save, and immediately copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

If you are provisioning AI agents programmatically for your users, you should generate the MCP server via the Truto REST API. This validates that the integration is AI-ready, generates a secure hashed token in Cloudflare KV, and returns the endpoint.

Make an authenticated `POST` request to the `/integrated-account/:id/mcp` endpoint:

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Kaspr Enrichment Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The API responds with the server ID and the ready-to-use URL:

```json
{
  "id": "kaspr-mcp-8f92",
  "name": "Kaspr Enrichment Agent",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Connecting Claude to Kaspr

Once you have your Truto MCP server URL, you must register it with your Claude environment. The MCP protocol handles the handshake - Claude will send an `initialize` request, and Truto will return the specific Kaspr capabilities and tool schemas.

### Method A: Via the Claude Desktop UI

If you are using Claude Desktop (or similar web clients that support visual configuration):

1. Open Claude Desktop and navigate to **Settings** -> **Integrations**.
2. Click **Add MCP Server** or **Add custom connector**.
3. Give the server a descriptive name like "Kaspr Enrichment".
4. Paste your Truto MCP server URL into the endpoint field.
5. Click **Add**. Claude will instantly connect and discover the available Kaspr tools.

### Method B: Via the Manual Configuration File

If you are configuring Claude Desktop manually or deploying a custom LangGraph agent, you will use the configuration JSON file. For Claude Desktop, edit your `claude_desktop_config.json` file (typically located in `~/Library/Application Support/Claude/` on macOS or `%APPDATA%\Claude\` on Windows).

Add the Truto server using the Server-Sent Events (SSE) configuration command:

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

Restart Claude Desktop. The Kaspr tools are now directly accessible in your prompt context.

## Kaspr MCP Hero Tools

Truto automatically derives tool definitions from Kaspr's underlying REST resources and documentation. When Claude queries the `tools/list` JSON-RPC endpoint, Truto parses the query and body schemas and injects them into the MCP response format. 

Here are the critical, high-leverage hero tools exposed for Kaspr.

### list_all_kaspr_credits

Before executing any [enrichment operations](https://truto.one/connect-seamless-ai-to-claude-find-enrich-and-export-company-data/), an AI agent must audit the workspace's remaining credits to prevent failed transactions. This tool returns the exact balances for `workEmailCredits`, `directEmailCredits`, `phoneCredits`, and `exportCredits`. Note that a value of `-1` indicates an unlimited tier.

> "Claude, check our Kaspr workspace credit balance. If we have more than 50 phone credits remaining, we can proceed with the lead enrichment batch. If we are under 50, alert me and stop."

### list_all_kaspr_rate_limits

Kaspr restricts how rapidly you can hit their enrichment endpoints. This tool retrieves the currently configured `dailyLimit`, `hourlyLimit`, and `minutelyLimit` for your workspace. Exposing this to Claude allows the agent to calculate safe batch sizes and implement logical pauses between requests.

> "What are our current minute and hourly rate limits in Kaspr? Calculate how many profiles I can safely enrich in a single batch without triggering a 429 Too Many Requests error."

### kaspr_linkedin_profiles_enrich

This is the core execution tool. It accepts a prospect's LinkedIn profile `id` and `name`, and returns a deeply nested JSON object containing arrays of professional emails, personal emails, and phone numbers. Crucially, a successful call against this tool consumes your workspace credits.

> "Take this LinkedIn profile ID (jane-doe-1234) and use Kaspr to find her direct phone number and professional email address. Format the output as a clean vCard."

### list_all_kaspr_me

This utility tool verifies that the Kaspr API key backing the integrated account is active and valid. It returns the owner's identity (typically the registered email address). It is highly useful as a health check at the start of complex agentic workflows.

> "Verify our Kaspr connection is healthy by retrieving the account owner details. If the API key is invalid, halt the workflow immediately."

To view the complete schema definitions and the full inventory of Kaspr resources, visit the [Kaspr integration page](https://truto.one/integrations/detail/kaspr).

## Workflows in Action

Connecting Claude to Kaspr unlocks [autonomous prospecting workflows](https://truto.one/connect-leadiq-to-claude-find-decision-makers-and-identify-companies/) that normally require dedicated engineering resources or fragile Zapier logic. Here are two real-world examples of how Claude orchestrates these tools.

### Workflow 1: Safe Bulk Enrichment and CRM Formatting

Sales development representatives (SDRs) often have lists of raw LinkedIn URLs that need emails and phone numbers attached before being imported into a CRM. An agent must check limits before spending credits.

> "I have a list of three LinkedIn profiles: alice-smith-corp, bob-jones-dev, and charlie-brown-ops. First, check our Kaspr credit balance. If we have at least 3 work email credits and 3 phone credits, enrich all three profiles. Finally, output a CSV containing their Name, Job Title, Best Work Email, and Best Phone Number."

**Execution Steps:**
1. Claude calls `list_all_kaspr_credits` to retrieve the current balances. It verifies that `workEmailCredits` and `phoneCredits` are greater than 3.
2. Claude executes `kaspr_linkedin_profiles_enrich` for Alice. It parses the nested `professionalEmails` and `phones` arrays.
3. Claude repeats `kaspr_linkedin_profiles_enrich` for Bob.
4. Claude repeats `kaspr_linkedin_profiles_enrich` for Charlie.
5. Claude structures the extracted data into a raw CSV block and outputs it to the user.

### Workflow 2: Rate Limit Aware Pacing

When dealing with high-volume lists, agents must be aware of upstream quotas to avoid crashing the integration pipeline.

> "I need to enrich these 15 LinkedIn profile IDs. Before starting, check the Kaspr rate limits. Tell me exactly what the minutely limit is. If the limit is lower than 15, explain how we should chunk this request, but do not execute the enrichment yet."

**Execution Steps:**
1. Claude calls `list_all_kaspr_rate_limits`.
2. The proxy API returns the configuration, showing a `minutelyLimit` of 10.
3. Claude analyzes the result and responds to the user: "Your Kaspr account has a strict limit of 10 requests per minute. Because you requested 15 profiles, attempting this in a single batch will result in a 429 Too Many Requests error. We should chunk this into two batches: 10 profiles now, followed by a 60-second wait, then the remaining 5."

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Router
    participant Proxy as Truto Proxy API
    participant Upstream as Kaspr API

    User->>Claude: "Check rate limits for 15 profiles"
    Claude->>MCP: Call tool: list_all_kaspr_rate_limits
    MCP->>Proxy: Route request with context
    Proxy->>Upstream: GET /rate_limits
    Upstream-->>Proxy: { "minutelyLimit": 10 }
    Proxy-->>MCP: Normalized response
    MCP-->>Claude: JSON-RPC Result
    Claude-->>User: "Limit is 10. We must chunk the requests."
```

## Security and Access Control

Exposing an enrichment database that charges per request to an LLM requires strict governance. Truto provides several configuration layers to lock down your MCP server and prevent runaway billing scenarios.

*   **Method Filtering**: You can strictly limit the MCP server to specific HTTP verbs. For Kaspr, you might restrict an agent to only `["read"]` methods, meaning it can check credits and limits, but cannot execute the `custom` enrichment endpoints that cost money.
*   **Tag Filtering**: Truto allows you to scope tools by resource tags. You can isolate specific API domains so the LLM does not hallucinate calls to unrelated endpoints.
*   **Expiration Timers (`expires_at`)**: You can assign an ISO datetime for the MCP server to self-destruct. This is highly effective for giving a contractor or temporary script 24-hour access to Kaspr enrichment tools.
*   **Enforced API Token Auth (`require_api_token_auth`)**: By default, the cryptographically signed MCP URL acts as the authentication layer. For stricter environments, you can enable this flag, requiring the client to pass a valid Truto API bearer token in addition to possessing the URL.

## Moving Beyond Point-to-Point Scripts

Connecting Kaspr to Claude via an MCP server replaces brittle Python scripts with autonomous, self-healing agentic workflows. By dynamically generating tools directly from Kaspr's documentation, Truto ensures that your AI agents always understand the exact nested JSON schema required to parse phone numbers and professional emails. 

More importantly, by exposing operational tools like `list_all_kaspr_credits` and `list_all_kaspr_rate_limits`, Truto allows you to write system prompts that treat the LLM as a responsible operator rather than a blind execution engine. The agent can audit its own capacity, respect the vendor's API economy, and fail gracefully when resources are exhausted.

> Stop writing boilerplate parsing logic for enrichment APIs. Connect Claude to Kaspr in minutes with Truto's managed MCP servers.
>
> [Talk to us](https://truto.one/book-a-demo/)