--- title: "Connect Kaspr to ChatGPT: Enrich LinkedIn Data & Monitor Credits" slug: connect-kaspr-to-chatgpt-enrich-linkedin-data-monitor-credits date: 2026-10-19 author: Riya Sethi categories: ["AI & Agents"] excerpt: "Learn how to connect Kaspr to chatgpt using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows." canonical: https://truto.one/blog/connect-kaspr-to-chatgpt-enrich-linkedin-data-monitor-credits/ --- # Connect Kaspr to ChatGPT: Enrich LinkedIn Data & Monitor Credits If you need to connect Kaspr to ChatGPT to automate LinkedIn data enrichment, monitor [API rate limits](https://truto.one/how-to-handle-api-rate-limits-in-saas-integrations/), or orchestrate bulk prospecting workflows, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between ChatGPT's [JSON-RPC tool calls](https://truto.one/understanding-mcp-architecture-json-rpc-transports/) and Kaspr's REST APIs. You can either build and maintain this infrastructure yourself, or use a [managed integration platform like Truto](https://truto.one/what-is-a-unified-api-integration-platform/) to dynamically generate a secure, authenticated MCP server URL. If your team uses Claude, check out our guide on [connecting Kaspr to Claude](https://truto.one/connect-kaspr-to-claude-automate-lead-enrichment-manage-limits/) or explore our broader architectural overview on [connecting Kaspr to AI Agents](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 lead enrichment platform like Kaspr is a specific engineering challenge. Kaspr operates on a strict credit economy and multi-tiered rate limits. Every time a developer adds a new enrichment step or attempts to pull bulk data, they risk burning through expensive API credits or triggering HTTP 429 errors. Your MCP server must expose these endpoints cleanly without obfuscating the underlying API limits. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Kaspr, connect it natively to ChatGPT, and execute complex prospecting workflows using natural language. > Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. > > [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, implementing it against Kaspr's specific API architecture requires careful handling of limits and credits. If you decide to build a custom MCP server for Kaspr, you own the entire API lifecycle. Here are the specific integration challenges you will face: ### The Multi-Faceted Credit Economy Kaspr does not charge a flat per-request fee; it operates a granular credit economy. A single prospect might consume different types of credits depending on the data requested: `workEmailCredits`, `directEmailCredits`, `phoneCredits`, and `exportCredits`. If you give an LLM unchecked access to an enrichment endpoint, a simple prompt like "Find contact info for these 100 leads" could instantly burn through your monthly quota of premium phone credits. Your MCP integration must explicitly expose credit-checking endpoints so the AI agent can audit available balances before executing large batch operations. ### Multi-Tiered Rate Limits and 429 Handling Kaspr enforces strict request velocity limits at the minute, hour, and day levels (`minutelyLimit`, `hourlyLimit`, `dailyLimit`). When building an MCP server, a common mistake is attempting to build automatic retries and exponential backoff into the proxy layer. Truto takes a different, explicitly architectural approach: Truto does not retry, throttle, or apply backoff on rate limit errors. When the Kaspr API returns an HTTP 429, Truto passes that error directly back to the caller (the AI agent). Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. This means the LLM itself - or the orchestration framework calling it - is responsible for reading the 429, inspecting the reset headers, and executing the retry or backoff strategy. This prevents silent timeouts and gives the AI agent deterministic control over execution. ### Nested Enrichment Payloads The core value of Kaspr is the enriched profile data. When an LLM calls the enrichment tool, the response payload is heavily nested, returning arrays for `professionalEmails`, `personalEmails`, and `phones`, alongside metadata like `processingTime`. Mapping flat LLM arguments into Kaspr's required query/body schemas requires an intelligent routing layer. Truto handles this by splitting the LLM's flat input namespace into the appropriate query parameters and JSON body properties based on Kaspr's [OpenAPI documentation](https://truto.one/generate-mcp-servers-from-openapi-specs/), ensuring the LLM doesn't have to guess where to place arguments. ## Kaspr to ChatGPT Quickstart Guide If you want the fastest path from a fresh Truto account to ChatGPT calling the Kaspr API, follow these steps. **What you need:** * A Truto account with API access. * A Kaspr account and API key. * A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available. ### Step 1: Connect Kaspr as an Integrated Account In the Truto dashboard, navigate to **Integrated Accounts -> New Integrated Account**, select Kaspr, and input your API key. Truto securely vaults this credential. Make a note of your `integrated_account_id`. ### Step 2: Generate the Kaspr MCP Server You can generate the MCP server URL scoped to this specific Kaspr account using either the Truto UI or the API. **Method A: Via the Truto UI** 1. Navigate to the integrated account page for your Kaspr connection. 2. Click the **MCP Servers** tab. 3. Click **Create MCP Server**. 4. Select your desired configuration (e.g., allow `read` and `write` methods, set tag filters). 5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/`). **Method B: Via the Truto API** Make a single POST call to scope an MCP endpoint to your Kaspr account. You can filter by `methods` to constrain what the LLM is allowed to execute. ```bash 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": "Kaspr Enrichment for ChatGPT", "config": { "methods": ["read", "write"], "tags": ["enrichment", "credits"] } }' ``` The API responds with a database record containing the `url` field. This single URL carries all routing and authentication - treat it like a secure credential. ### Step 3: Connect the MCP Server to ChatGPT Now you must register this server with your ChatGPT instance. You can do this via the ChatGPT interface or via a manual configuration file depending on your local setup. **Method A: Via the ChatGPT UI** 1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**. 2. Enable the **Developer mode** toggle. 3. Under **MCP servers / Custom connectors**, click to add a new server. 4. Set the **Name** to "Kaspr (Truto)". 5. Paste the Truto MCP URL into the **Server URL** field. 6. Click Save. ChatGPT will immediately connect, perform the MCP handshake, and discover the available Kaspr tools. **Method B: Via Manual Config File (SSE Transport)** If you are running a local orchestrator or a desktop app that requires a configuration file (like Cursor or custom LangChain setups), you can wrap the Truto URL in a standard [Server-Sent Events (SSE)](https://truto.one/mcp-transports-sse-vs-stdio-explained/) client transport. Add the following to your `mcp.json` or `claude_desktop_config.json` equivalent: ```json { "mcpServers": { "kaspr-truto": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-sse", "https://api.truto.one/mcp/YOUR_SECURE_TOKEN_HERE" ] } } } ``` ## Available Kaspr Tools for AI Agents When ChatGPT connects to the Truto MCP server, Truto dynamically generates tool definitions based on the Kaspr API schema. The LLM sees these as native functions it can invoke. Here are the high-leverage hero tools exposed for Kaspr workflows: ### 1. kaspr_linkedin_profiles_enrich This is the core operational tool. It takes a prospect's LinkedIn identifier and instructs Kaspr to retrieve their work email, direct personal email, and phone number. Be aware that requesting specific data types consumes corresponding credits, and a successful call consumes one export credit. *Required arguments:* `id` and `name`. > "I have a list of LinkedIn profiles for directors of engineering. Call kaspr_linkedin_profiles_enrich for Jane Doe (id: jane-doe-123) and return her professional email and company title." ### 2. list_all_kaspr_credits Because Kaspr charges differently for direct emails versus work emails, an autonomous agent needs to know its available resources before running a large batch. This tool returns the remaining balances for `workEmailCredits`, `directEmailCredits`, `phoneCredits`, and `exportCredits`. A value of `-1` indicates unlimited credits. > "Before we enrich this list of 50 leads, call list_all_kaspr_credits. If we have fewer than 50 workEmailCredits remaining, alert me and halt the operation." ### 3. list_all_kaspr_rate_limits To prevent the AI agent from triggering 429 Too Many Requests errors, it should periodically check its API allowance. This tool returns the `dailyLimit`, `hourlyLimit`, and `minutelyLimit` configured for the Kaspr workspace. > "We need to process a backlog of 500 LinkedIn URLs. Call list_all_kaspr_rate_limits to check our minutelyLimit so you can batch the enrichment requests safely." ### 4. list_all_kaspr_me This is a utility tool used for authentication verification and environment checks. It returns the `user` object, which identifies the owner of the API key (typically an email address). This is highly useful for multi-tenant AI agents that need to verify which Kaspr account they are currently operating under. > "Call list_all_kaspr_me and confirm which account email is currently bound to this session before we spend any credits." For the complete inventory of available Kaspr tools and their exact JSON schemas, visit the [Kaspr integration page](https://truto.one/integrations/detail/kaspr). ## Workflows in Action By giving ChatGPT access to both enrichment and telemetry tools, you enable autonomous, self-regulating prospecting workflows. ### Workflow 1: Self-Regulating Batch Enrichment In this scenario, the user asks ChatGPT to enrich a small batch of leads, but the AI agent is instructed to audit its operational limits first to prevent API errors and overages. > "I need you to enrich these three LinkedIn profile IDs: john-smith-88, sarah-connor-99, and alex-murphy-00. Before enriching, verify we have at least 3 work email credits and that we aren't near our minutely rate limit. If all is clear, enrich them and output a table of their names, titles, and work emails." **How the agent executes this:** 1. **Check Credits:** The agent calls `list_all_kaspr_credits`. It reads the `workEmailCredits` integer to ensure it is greater than or equal to 3 (or `-1` for unlimited). 2. **Check Rate Limits:** The agent calls `list_all_kaspr_rate_limits` to verify the `minutelyLimit` has sufficient capacity. 3. **Enrich Lead 1:** The agent calls `kaspr_linkedin_profiles_enrich` passing `{"id": "john-smith-88", "name": "John Smith"}`. 4. **Enrich Lead 2:** The agent calls `kaspr_linkedin_profiles_enrich` passing `{"id": "sarah-connor-99", "name": "Sarah Connor"}`. 5. **Enrich Lead 3:** The agent calls `kaspr_linkedin_profiles_enrich` passing `{"id": "alex-murphy-00", "name": "Alex Murphy"}`. **Result:** The LLM returns a formatted Markdown table with the enriched data, having safely navigated Kaspr's credit and rate limit constraints. ```mermaid sequenceDiagram participant User participant ChatGPT participant TrutoMCP as Truto MCP Server participant Kaspr as Kaspr API User->>ChatGPT: "Enrich these 3 leads safely" ChatGPT->>TrutoMCP: Call tool: list_all_kaspr_credits TrutoMCP->>Kaspr: GET /credits Kaspr-->>TrutoMCP: { workEmailCredits: 450 } TrutoMCP-->>ChatGPT: Return credit balance ChatGPT->>TrutoMCP: Call tool: list_all_kaspr_rate_limits TrutoMCP->>Kaspr: GET /rate-limits Kaspr-->>TrutoMCP: { minutelyLimit: 60 } TrutoMCP-->>ChatGPT: Return rate limits ChatGPT->>TrutoMCP: Call tool: kaspr_linkedin_profiles_enrich (x3) TrutoMCP->>Kaspr: POST /enrich Kaspr-->>TrutoMCP: Return enriched profiles TrutoMCP-->>ChatGPT: Return JSON payload ChatGPT-->>User: Render Markdown table ``` ### Workflow 2: Workspace Audit and Usage Reporting Account managers frequently need to know if they need to purchase more Kaspr credits before launching a new outbound campaign. You can ask ChatGPT to run a full diagnostic. > "Audit our Kaspr account. Tell me who owns the current API key, list our current daily and hourly rate limits, and provide a summary of our remaining phone and direct email credits." **How the agent executes this:** 1. **Identify User:** The agent calls `list_all_kaspr_me` and extracts the `user` email address. 2. **Fetch Limits:** The agent calls `list_all_kaspr_rate_limits` and extracts `dailyLimit` and `hourlyLimit`. 3. **Fetch Balances:** The agent calls `list_all_kaspr_credits` and extracts `phoneCredits` and `directEmailCredits`. **Result:** ChatGPT synthesizes the three API responses into a clean, human-readable executive summary, warning the user if any specific credit pool is running dangerously low. ## Security and Access Control When generating MCP servers via Truto, you are not blindly handing over root access to your Kaspr account. Truto provides strict access control mechanisms managed at the database level: * **Method Filtering:** Use `config.methods` to restrict the LLM to specific operations. For example, setting `methods: ["read"]` allows the agent to check credits (`list_all_kaspr_credits`) but prevents it from executing enrichment calls that consume credits. * **Tag Filtering:** Use `config.tags` to group tools logically. If Kaspr resources are tagged with `"enrichment"` or `"admin"`, you can limit an MCP server exclusively to administrative telemetry. * **Extra Authentication:** By default, the Truto MCP URL handles authentication. For enterprise environments, setting `require_api_token_auth: true` forces the client to also pass a valid Truto API bearer token in the headers, adding a second layer of security. * **Time-to-Live (TTL):** Set an `expires_at` ISO datetime when creating the MCP server. Truto's background alarm workers will automatically purge the server and its KV edge records at the exact timestamp, making it perfect for temporary agent sessions. ## Final Thoughts on Agentic Enrichment Connecting Kaspr to ChatGPT via MCP transforms an LLM from a static text generator into an autonomous prospecting engine. By exposing Kaspr's credit and rate limit endpoints alongside its enrichment capabilities, you allow the AI to govern its own execution - checking balances, monitoring velocity, and extracting contact data safely. Rather than spending weeks building custom JSON-RPC routers, managing OAuth token refreshes, or writing schema mapping boilerplate, Truto allows you to generate a secure, production-ready MCP server with a single API call. > Ready to give your AI agents secure, managed access to Kaspr and 100+ other enterprise APIs? Talk to our engineering team today. > > [Talk to us](https://truto.one/book-a-demo/)