Connect Lusha to ChatGPT: Prospect leads and enrich contact info

If you need to connect Lusha to ChatGPT so your AI agents can prospect leads, score buying signals, and enrich contact profiles, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Lusha's 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 Claude, check out our guide on connecting Lusha to Claude or explore our broader architectural overview on connecting Lusha to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise prospecting platform like Lusha is an engineering challenge. You have to handle complex asynchronous enrichment jobs, manage strict API credit consumption, and deal with highly specific pagination sessions. Every time Lusha adds a new premium field or updates a signal type, your custom server code must be updated, redeployed, and tested.

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

The Engineering Reality of the Lusha 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 Lusha's API surface introduces several strict architectural requirements.

If you decide to build a custom MCP server for Lusha, you own the entire API lifecycle. Here are the specific integration challenges you will face:

Credit-Aware Tool Execution

Lusha's API pricing is strictly consumption-based. Calling an endpoint like lusha_companies_enrich doesn't just consume a generic API request - it charges credits based on the specific premium fields requested (e.g., competitors, intent, ultimateParent). If you expose these endpoints to an LLM without strict boundaries, a hallucinating agent could burn through thousands of dollars in credits in minutes. Your MCP implementation must actively filter which endpoints the LLM can access and optionally enforce soft limits on the backend to prevent runway credit consumption.

Asynchronous Polling and Exponential Backoff

Enrichment operations in Lusha are not always synchronous. When triggering a contact enrichment job, the API often returns a job ID with a retryAfter value. Your MCP server must either wrap this polling logic into a single blocking tool call (which risks timing out the LLM connection) or expose the polling mechanism directly to the LLM. Exposing the polling mechanism requires strictly defining the retryAfter field in the JSON Schema so the LLM knows exactly how long to wait before checking the job status again.

Deduplication Session State

Unlike standard offset or cursor-based pagination, Lusha's lookalike endpoints (lusha_contacts_lookalikes and lusha_companies_lookalikes) rely on a dedupeSessionId. To fetch the next page of lookalike records without returning duplicates, the client must pass this exact session ID back to the API. If your MCP server drops this state, the LLM will endlessly loop through the same top 100 lookalike results.

Explicit Rate Limit Handling

When integrating with Lusha at scale, you will hit HTTP 429 rate limits. Truto does not retry, throttle, or absorb rate limit errors on your behalf. When Lusha returns a 429, Truto passes that error directly back to the caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your MCP client or agent framework is strictly responsible for inspecting these headers and executing a backoff strategy before re-attempting the tool call.

How to Create the Lusha MCP Server

Truto dynamically generates MCP tools based on Lusha's API documentation and your specific integration configuration. The tools are never pre-built or cached - they are generated at runtime when ChatGPT requests the tool list.

You can create a scoped MCP server for Lusha via the Truto dashboard or programmatically via the API.

Method 1: Via the Truto UI

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Lusha account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods, apply specific tags like prospecting).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

You can dynamically provision an MCP server for a specific Lusha integrated account. This is ideal for multi-tenant SaaS applications provisioning agents for end-users.

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": "Lusha Prospecting Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["contacts", "companies", "enrichment"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API returns a secure url payload. This single URL handles routing, tenant isolation, and authentication. Treat it as a sensitive credential.

How to Connect the MCP Server to ChatGPT

Once you have your Truto MCP server URL, you must register it with your ChatGPT environment.

Method 1: Via the ChatGPT UI (Custom Connectors)

If you are on a ChatGPT Pro, Plus, Business, Enterprise, or Education plan, you can connect the server directly:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under MCP servers / Custom connectors, click Add new server.
4. Set a name (e.g., "Lusha Operations").
5. Paste the Truto MCP server URL into the Server URL field.
6. Click Save.

ChatGPT will immediately ping the /initialize endpoint, retrieve the Lusha tool schemas, and make them available to your agent.

Method 2: Via Manual Configuration (Local / CLI Agents)

If you are running a local agent or wrapping ChatGPT in a custom framework (like LangChain or a local Claude Desktop instance testing against OpenAI models), you can use the official MCP SSE transport utility to bridge the connection.

Create an mcp-config.json file:

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

This instructs the agent framework to establish a Server-Sent Events (SSE) connection to the Truto edge router, exposing the Lusha tools natively.

Security and Access Control

Exposing an enterprise database like Lusha to an autonomous agent requires strict security boundaries. Truto provides four native control mechanisms at the MCP token level:

• Method Filtering: Restrict the server to specific HTTP verbs. Setting methods: ["read"] ensures the LLM can only execute get and list operations, effectively creating a read-only agent that cannot spend credits on write-heavy enrichments.
• Tag Filtering: Group Lusha endpoints logically. Passing tags: ["prospecting"] ensures the LLM only sees tools related to finding contacts, hiding administrative or webhook subscription endpoints.
• Expiration (expires_at): Set a strict TTL on the MCP server. When the timestamp passes, Truto's distributed KV store automatically drops the token, and background alarms sweep the database records.
• Additional Authentication (require_api_token_auth): By default, the MCP URL is a bearer token. For zero-trust environments, enable this flag to force the client to also pass a valid Truto API token in the Authorization header on every JSON-RPC request.

Lusha Hero Tools for ChatGPT

Below are 7 high-leverage Lusha tools exposed through the Truto MCP server. Truto generates the names, descriptions, and JSON Schemas dynamically based on Lusha's underlying API definitions.

lusha_contacts_search

Looks up up to 100 contacts by ID, LinkedIn URL, email, or name and company. This returns non-PII preview data (names, job titles, locations) without revealing emails or phones. It is highly useful for verifying contact existence before spending credits on full enrichment.

"Find the contact record for Jane Doe at Acme Corp using her LinkedIn URL, and tell me if Lusha has enough data available to reveal her email."

lusha_contacts_enrich

Reveals full contact data (emails, phones) for up to 100 Lusha contacts you have already identified via search. This endpoint actively charges credits per revealed email or phone.

"Take the contact ID you just found for Jane Doe and run an enrichment request to reveal her direct dial phone number and work email."

get_single_lusha_contact_enrich_job_by_id

Polls an asynchronous Lusha contact enrichment job. If the job status is processing, the LLM must inspect the retryAfter field and wait before calling this tool again.

"Check the status of enrichment job ID 'job-8492'. If it is still processing, tell me how many seconds we need to wait before polling again."

lusha_companies_enrich

Enriches up to 100 companies by ID to reveal firmographics, tech stack, funding, and social links. Premium fields (like intent and competitors) must be explicitly requested and will incur additional credit charges.

"Enrich the company profile for Acme Corp. Ensure you request the 'technologies' and 'intent' premium fields, and summarize their current tech stack."

lusha_contacts_signal_score

Scores up to 100 contacts based on their active buying signals, returning a score from 0 to 1. This is critical for filtering out cold prospects before executing expensive outreach sequences.

"Run a signal score analysis on this list of 10 contact IDs. Filter the results and only return the contacts with a buying signal score higher than 0.75."

lusha_contacts_lookalikes

Finds contacts similar to 5-100 seed contacts. Returns a dedupeSessionId alongside the results. The LLM must pass this ID back in subsequent calls to paginate through lookalikes without hitting duplicates.

"Generate a lookalike audience based on these 5 seed contact IDs. Give me the first 20 results, and make sure to capture the dedupe session ID for the next page."

list_all_lusha_account_usage

Retrieves a snapshot of the connected Lusha account's credit balance, rate limits, and plan details. Essential for agents to check runway before executing bulk operations.

"Check our Lusha account usage. How many 'reveal_email' credits do we have remaining for this billing cycle?"

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

Workflows in Action

Here is how an AI agent uses these tools to execute multi-step prospecting logic autonomously.

Scenario 1: Signal-Based Prospecting Pipeline

Sales teams need to identify which contacts within a target account are actively showing buying signals before spending credits to reveal their direct contact info.

"Find the VP of Engineering at TechGlobal, check if they have active buying signals above 0.8, and if so, enrich their profile to get their email address."

Execution Steps:

1. The agent calls lusha_contacts_search passing the title "VP of Engineering" and company "TechGlobal". Lusha returns a contact ID (e.g., cnt_9988) and preview metadata.
2. The agent calls lusha_contacts_signal_score passing the ID cnt_9988. Lusha returns a score of 0.85.
3. Recognizing the score meets the threshold, the agent calls lusha_contacts_enrich to reveal the contact's email address.
4. The agent formulates a final summary for the user containing the enriched PII.

sequenceDiagram
  participant ChatGPT as ChatGPT (Agent)
  participant MCP as Truto MCP
  participant Lusha as Lusha API
  ChatGPT->>MCP: Call lusha_contacts_search
  MCP->>Lusha: Proxy request
  Lusha-->>MCP: Return preview (cnt_9988)
  MCP-->>ChatGPT: JSON result
  ChatGPT->>MCP: Call lusha_contacts_signal_score
  MCP->>Lusha: Proxy request
  Lusha-->>MCP: Return score (0.85)
  MCP-->>ChatGPT: JSON result
  ChatGPT->>MCP: Call lusha_contacts_enrich
  MCP->>Lusha: Proxy request (costs credits)
  Lusha-->>MCP: Return enriched PII
  MCP-->>ChatGPT: JSON result

Scenario 2: Account Expansion via Lookalikes

Marketing teams often need to expand a list of known successful customers into a broader target audience while avoiding duplicate data extraction.

"Take these 3 seed company domains: stripe.com, twilio.com, and okta.com. Find 15 lookalike companies in Lusha. Enrich the top 3 lookalikes to find their total funding and tech stack."

Execution Steps:

1. The agent calls lusha_companies_lookalikes passing the three seed domains.
2. Lusha returns an array of company previews and a dedupeSessionId.
3. The agent selects the top 3 company IDs from the array.
4. The agent calls lusha_companies_enrich passing the 3 IDs, explicitly adding technologies and funding to the reveal array to authorize premium credit usage.
5. The agent parses the returned JSON schemas and provides a synthesized report on the target companies' infrastructure.

Moving from Prototypes to Production

Connecting ChatGPT to Lusha via Truto MCP completely bypasses the need to write custom REST wrappers, manage OAuth token refreshes, or manually map nested JSON response schemas. Truto dynamically derives the tool definitions directly from Lusha's API documentation, meaning your agent always has access to the most accurate endpoint definitions.

Because Truto normalizes Lusha's 429 errors into standard IETF headers, your agent architecture remains clean - your LLM simply reads the ratelimit-reset header and schedules its next tool call, while Truto ensures secure, stateless execution without caching your valuable CRM data at the edge.

Stop hand-coding API orchestration layers. Generate a secure, production-ready MCP server for Lusha in seconds.