Connect UpLead to Claude: Enrich Profiles and Automate Prospecting

If your team needs to connect UpLead to Claude to automate B2B prospecting, scale data enrichment, or manage lead lists, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between Claude's natural language tool calls and UpLead'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 ChatGPT, check out our guide on /connect-uplead-to-chatgpt-search-prospects-and-manage-lead-lists/ or explore our broader architectural overview on /connect-uplead-to-ai-agents-scale-lead-pipelines-and-data-enrichment/.

Giving a Large Language Model (LLM) read and write access to a high-value data provider like UpLead is an engineering challenge. You have to handle API key lifecycles, map complex search schemas to MCP tool definitions, and deal with UpLead's strict API quotas and credit costs. Every time UpLead updates an endpoint or changes its filtering logic, 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 UpLead, connect it natively to Claude Desktop, and execute complex prospecting workflows using natural language.

The Engineering Reality of the UpLead 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 APIs is difficult. UpLead is built to deliver highly accurate firmographic and contact data, and its API reflects the complexity of querying massive databases.

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

Opaque Credit Consumption UpLead charges credits for data enrichment. An endpoint like up_lead_companies_enrich costs one credit per company record received. Other endpoints, like previewing contacts or doing quick searches, have varying or undocumented credit impacts. If you give an LLM unrestricted access to loop through an array of 500 company names, it can drain your account balance in minutes. Your MCP architecture needs a way to fetch the credit balance (list_all_up_lead_credits) and you must strictly prompt the LLM to verify limits before executing batch operations.

Inconsistent Payload Transports UpLead's search endpoints mix and match transport mechanisms for their parameters. For example, up_lead_people_quick_search expects text and filters in the query parameters and ignores JSON bodies. Conversely, up_lead_companies_quick_search expects a JSON body and paginates via body parameters. If you are handwriting an MCP server, you have to build conditional logic to format the LLM's flat argument object into the correct HTTP transport layer for every single tool. Truto handles this automatically by compiling UpLead's OpenAPI documentation into standardized JSON schemas, resolving where parameters belong at runtime.

Strict Rate Limiting and Error Handling UpLead enforces rate limits to protect its infrastructure. When building an integration layer, you must handle these limits predictably. Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API returns HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (or the LLM orchestration framework) is entirely responsible for retry and backoff logic. Truto does not automatically absorb rate limit errors, ensuring your system always knows exactly when it is being throttled.

How to Generate a Managed UpLead MCP Server

Instead of building a Node.js or Python server from scratch, you can use Truto to instantly generate a managed MCP server for any connected UpLead account. The server is dynamically built from UpLead's integration resources and documentation.

You can generate the server in two ways: via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are setting up an internal tool or testing locally, the UI is the fastest path.

1. Log into your Truto account and navigate to the integrated account page for your UpLead connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. For example, you can name it "UpLead Prospecting Bot" and restrict it to specific tags or read-only methods.
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto REST API

For production use cases where you are provisioning agents programmatically, you can generate MCP servers via a simple API call. The endpoint validates that the integration has tools available, generates a secure hashed token, stores it in distributed KV storage, and returns a ready-to-use URL.

POST /integrated-account/:id/mcp

{
  "name": "Claude Desktop UpLead Connection",
  "config": {
    "methods": ["read", "write", "custom"]
  }
}

Response:

{
  "id": "mcp_token_8f92b...",
  "name": "Claude Desktop UpLead Connection",
  "config": {
    "methods": ["read", "write", "custom"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

This URL contains a cryptographic token that securely identifies the exact UpLead account to query. It acts as both the endpoint and the authentication key for the MCP protocol.

Connecting the UpLead MCP Server to Claude

Once you have your Truto MCP URL, you need to connect it to your LLM client. Claude and ChatGPT both support MCP, allowing them to discover and execute the tools dynamically.

Method 1: Via the UI (ChatGPT / Claude Web)

If you are using an LLM provider that supports adding connectors via their web interface (like ChatGPT Developer Mode or Claude's web settings):

1. In your LLM interface, navigate to Settings -> Integrations (or Connectors).
2. Click Add MCP Server or Add custom connector.
3. Paste the Truto MCP URL you generated in the previous step.
4. Click Add. The client will perform the MCP initialize handshake and automatically list the available UpLead tools.

Method 2: Via the Claude Desktop Config File

If you are using Claude Desktop for local agentic workflows, you can connect the server via your claude_desktop_config.json file using Server-Sent Events (SSE).

Locate your configuration file:

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the following configuration, replacing the URL with your specific Truto MCP endpoint:

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

Restart Claude Desktop. The application will connect to the Truto router, request the tools/list, and populate Claude's context window with the UpLead capabilities.

UpLead Hero Tools for Claude

Truto automatically translates UpLead's endpoints into descriptive, snake_case tools with strict JSON schemas. Because UpLead charges credits for data retrieval, it is critical to use the right tools for the right jobs.

Here are the most powerful tools your agent will have access to:

list_all_up_lead_credits

Description: Retrieves the remaining credit balance of the connected UpLead account. This is a critical operational tool. You should instruct your agent to call this before executing batch enrichment tasks to ensure you do not fail mid-run.

"Check my UpLead account and tell me exactly how many credits I have remaining before we start our prospecting run."

up_lead_companies_enrich

Description: Looks up a detailed UpLead company profile by domain, company name, or UpLead company ID. A domain gives the most precise match. This returns firmographic data including address, size, revenue, industry, SIC/NAICS codes, and social URLs. Note: Costs one credit per company record received.

"Take the domain 'stripe.com' and use UpLead to find their total revenue, employee headcount, and primary industry."

up_lead_people_enrich

Description: Looks up a specific professional by email, by first and last name plus domain, or by ID. Returns their title, job function, management level, email status, phone numbers, and LinkedIn URL. Note: Costs one credit per valid contact received.

"Enrich the profile for John Doe at acmecorp.com. I need his direct phone number, exact job title, and LinkedIn URL."

up_lead_people_pro_search

Description: Executes a highly filtered search for contacts based on domains, job functions, titles, locations, industry, company size, and revenue. This is your primary list-building tool. Note: Requires Professional, Elite, or Enterprise plans. Costs one credit per contact returned.

"Find 15 contacts who hold a 'VP of Sales' or 'Director of Sales' title at software companies located in California with over $10M in revenue."

up_lead_people_enrich_with_company

Description: A combined operation that looks up a contact and their associated company from an email address. This returns the contact payload plus an embedded company object with the full firmographic profile.

"I have an inbound lead from jane.smith@techflow.io. Enrich this email to give me both her professional profile and the full firmographic data on Techflow."

up_lead_list_contacts_add

Description: Adds an array of UpLead contact IDs to a saved UpLead list. This allows the LLM to prospect, evaluate candidates, and save the winners directly to a list in your account for later export or CRM syncing.

"Take the contact IDs we just found for the marketing directors, and add them to the UpLead list ID 89123."

To view the full inventory of tools and their JSON schemas, visit the UpLead integration page.

Workflows in Action

Once Claude is equipped with UpLead tools via MCP, you can chain operations together to automate tedious revenue operations.

Scenario 1: Account-Based Marketing (ABM) Enrichment

The Goal: The user has a target account and wants to find the right decision-maker, evaluate the company size, and get contact info.

"Find the company profile for 'vercel.com'. Then, find the VP of Marketing at that company and enrich their contact info to give me their email and LinkedIn."

How the agent executes this:

1. Calls up_lead_companies_enrich with the domain vercel.com to confirm company details and fetch the UpLead company ID.
2. Calls up_lead_people_search passing the domain vercel.com and the title filter VP of Marketing.
3. Extracts the specific contact ID from the search results.
4. Calls up_lead_people_enrich using that contact ID to spend the credit and retrieve the email, phone, and LinkedIn URL.

The user receives a concise summary of Vercel's firmographics alongside the direct contact details for their target buyer.

sequenceDiagram
  participant Claude as Claude Desktop
  participant Truto as Truto MCP
  participant UpLead as UpLead API
  Claude->>Truto: call up_lead_companies_enrich (domain: vercel.com)
  Truto->>UpLead: GET /v2/companies
  UpLead-->>Truto: JSON (Company data)
  Truto-->>Claude: formatted tool result
  Claude->>Truto: call up_lead_people_search (title: VP of Marketing)
  Truto->>UpLead: GET /v2/people-search
  UpLead-->>Truto: JSON (Contact list)
  Truto-->>Claude: formatted tool result
  Claude->>Truto: call up_lead_people_enrich (id)
  Truto->>UpLead: GET /v2/people
  UpLead-->>Truto: JSON (Enriched profile)
  Truto-->>Claude: formatted tool result

Scenario 2: Budget-Aware List Building

The Goal: The user wants to build a list of prospects without accidentally exhausting their UpLead credit limit.

"Check our UpLead credit balance. If we have more than 50 credits, do a pro search for IT Directors in the healthcare industry in Texas. Return the first 20 results, and add them to list ID 55432."

How the agent executes this:

1. Calls list_all_up_lead_credits to check the current balance.
2. Reads the response. If credits > 50, it proceeds.
3. Calls up_lead_people_pro_search with parameters for industry: healthcare, location: Texas, title: IT Director, and a limit of 20.
4. Extracts the returned contact_ids from the payload.
5. Calls up_lead_list_contacts_add passing the list_id and the array of contact_ids.

The user gets a confirmation that the balance was checked, the search was executed, and the prospects were safely stored in their UpLead account.

flowchart TD
    A["Claude Tool Call<br>list_all_up_lead_credits"] --> B{"Credits > 50?"}
    B -- Yes --> C["Claude Tool Call<br>up_lead_people_pro_search"]
    B -- No --> D["Return error to user"]
    C --> E["Extract contact_ids"]
    E --> F["Claude Tool Call<br>up_lead_list_contacts_add"]

Security and Access Control

When exposing powerful data APIs to autonomous agents, security is paramount. A leaked API key can result in thousands of dollars in unwanted API consumption. Truto's MCP architecture mitigates this by providing granular access controls at the server level.

• Method Filtering: You can configure the MCP server to only allow read operations. This prevents the LLM from accidentally calling delete_a_up_lead_list_by_id or making unauthorized writes to your CRM configurations.
• Tag Filtering: You can restrict the LLM's scope to specific functional areas. For example, you can create a server that only exposes tools tagged with prospecting and hides tools related to account administration.
• Additional Authentication: By enabling require_api_token_auth, you force the client to provide a valid Truto API token in addition to the server URL. This prevents unauthorized access if the MCP URL is leaked in internal logs.
• Ephemeral Access: You can set an expires_at datetime on the MCP token. Once the timestamp passes, the server URL instantly self-destructs, terminating the agent's access to the API.

Strategic Wrap-Up

Connecting UpLead to Claude via MCP turns a static LLM into an autonomous prospecting engine. By using Truto to generate a managed MCP server, you eliminate the need to write custom integration code, handle complex pagination schemas, or manually orchestrate API token lifecycles.

Your engineers can focus on prompt engineering and agent orchestration, while Truto ensures the underlying API communication is secure, predictable, and fully documented.