---
title: "Connect MoltSets to Claude: Identify Companies and Verify Contact Info"
slug: connect-moltsets-to-claude-identify-companies-and-verify-contact-info
date: 2026-10-16
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect MoltSets to Claude using a managed MCP server. Identify companies, verify contact data, and automate B2B prospecting with AI agents."
tldr: "Connecting MoltSets to Claude allows AI agents to execute complex B2B prospecting workflows, verify contact data, and deanonymize IP addresses using managed MCP servers."
canonical: https://truto.one/blog/connect-moltsets-to-claude-identify-companies-and-verify-contact-info/
---

# Connect MoltSets to Claude: Identify Companies and Verify Contact Info


If your team needs to connect MoltSets to Claude to identify visiting companies, verify executive contact information, and automate B2B prospecting workflows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's internal tool-calling mechanics and the MoltSets REST API. You can either construct and maintain this infrastructure yourself, or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. 

If your team uses ChatGPT, check out our guide on [/connect-moltsets-to-chatgpt-discover-and-enrich-b2b-prospect-data/](https://truto.one/connect-moltsets-to-chatgpt-discover-and-enrich-b2b-prospect-data/) or explore our broader architectural overview on [/connect-moltsets-to-ai-agents-automate-prospecting-and-data-sourcing/](https://truto.one/connect-moltsets-to-ai-agents-automate-prospecting-and-data-sourcing/).

Giving a Large Language Model (LLM) read access to a specialized data enrichment ecosystem like MoltSets is an engineering challenge. You must handle complex token economies, map strictly defined search parameters to MCP tool definitions, and deal with plan-specific endpoint restrictions. Every time the vendor updates an endpoint or modifies the search schema, you must 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 MoltSets, 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 MoltSets and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the MoltSets 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 data enrichment APIs is painful. MoltSets is built to provide high-fidelity B2B firmographic and contact data, and its API reflects the complexity of managing that data access.

If you decide to [build a custom MoltSets 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:

**Complex Token Economics and Billing Logic**
MoltSets operates on a pay-per-hit token economy rather than simple API quotas. The API deducts one token when data is found, but a `not_found` miss is completely free. Furthermore, mobile phone lookups draw from an entirely separate "phone-token" balance. If an LLM simply hallucinates a loop to guess email structures, it could rapidly exhaust your paid token limits. A custom MCP server must constantly expose the `list_all_molt_sets_account` tool to the model so the agent can monitor its own token burn rate before executing bulk queries.

**Plan-Restricted Endpoints and Dynamic Failures**
Not all endpoints in the MoltSets API are available to all users. Operations like USA personal email lookups or mobile advertising ID (MAID) lookups are gated depending on your pricing tier. If an LLM attempts to call `molt_sets_ad_audiences_lookup_maid_by_email` on a restricted plan, the API will return a 403 `plan_restricted` error. Your MCP server must properly map these domain-specific HTTP exceptions into JSON-RPC error formats that Claude can parse, understand, and use to modify its execution plan.

**Strict Rate Limiting and IETF Compliance**
Data enrichment APIs strictly enforce rate limits to prevent aggressive scraping. When calling MoltSets, you will inevitably hit quotas. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the MoltSets API returns an HTTP 429 error, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) following the IETF spec. The LLM agent framework is entirely responsible for reading these headers and executing its own backoff strategy.

## Generating the MoltSets MCP Server

Truto's architecture eliminates the need to hand-code JSON-RPC handlers for MoltSets. Instead, [Truto dynamically generates MCP tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) based on the integration's internal schemas and documentation records. 

Each MCP server is scoped to a single integrated account and secured via a hashed cryptographic token stored in a distributed key-value edge runtime. You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Generating via the Truto UI

For teams who prefer a visual configuration process, you can generate the MCP server directly from your dashboard:

1. Navigate to the **Integrated Accounts** page in your Truto workspace.
2. Select your connected MoltSets account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., set an expiration date or require additional API token authentication).
6. Click Generate and copy the provided `https://api.truto.one/mcp/...` URL.

### Method 2: Generating via the REST API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically. The API validates the configuration, provisions the endpoint, and returns a ready-to-use URL.

```typescript
// POST /integrated-account/:id/mcp
const response = await fetch(
  'https://api.truto.one/integrated-account/moltsets_acc_123/mcp', 
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: "MoltSets Lead Enrichment Agent",
      config: {
        methods: ["read", "custom"]
      },
      expires_at: "2026-12-31T23:59:59Z"
    })
  }
);

const mcpServer = await response.json();
console.log(mcpServer.url); 
// Output: https://api.truto.one/mcp/a1b2c3d4e5f6...
```

## Connecting the MCP Server to Claude

Once your MCP server URL is provisioned, you must connect it to Claude. The server is entirely self-contained - the URL payload encodes the tenant routing and authentication data. You can connect it visually or via local configuration.

### Method 1: Via the Claude UI

If you are using the Claude web application or enterprise environment, you can attach the server directly through the interface:

1. Open Claude and navigate to **Settings**.
2. Click on **Integrations** or **Connectors** (depending on your plan tier).
3. Click **Add MCP Server**.
4. Paste your Truto MCP URL into the endpoint field.
5. Click **Add**. Claude will immediately execute an `initialize` handshake and request the `tools/list`.

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

For local development or dedicated agent environments, you can configure Claude Desktop to connect via Server-Sent Events (SSE).

Open your `claude_desktop_config.json` file (typically located in `~/Library/Application Support/Claude/` on macOS or `%APPDATA%\Claude\` on Windows) and add the following JSON block:

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

Restart Claude Desktop. The application will detect the configuration, establish the SSE connection, and dynamically load the MoltSets tools.

## Hero Tools for MoltSets Automation

Truto automatically derives tool schemas from the MoltSets REST API documentation. When the LLM calls a tool, the input is passed directly to the native API, meaning there is no loss of fidelity or missing query parameters. Here are the highest-leverage tools available for MoltSets.

### Search the People Database
**Tool:** `list_all_molt_sets_search_people`

This tool allows the agent to search the global professional database by name, title, employer, seniority, industry, or location. It returns ranked profiles containing the individual's business email and company domain. It requires at least one positive filter.

> "Find the VP of Engineering or CTO at companies in the telecommunications sector located in Austin, Texas. Limit the search to 10 results and extract their business emails."

### Search the Company Database
**Tool:** `list_all_molt_sets_search_companies`

Allows the LLM to query firmographic data based on parameters like domain, industry, headcount, revenue, or NAICS code. This is essential for building account-based marketing (ABM) target lists before searching for individual stakeholders.

> "Generate a list of B2B SaaS companies in London with an estimated headcount between 50 and 200 employees."

### Lookup Business Profiles by LinkedIn URL
**Tool:** `molt_sets_business_profiles_lookup_by_linkedin`

This tool extracts a complete professional profile from a LinkedIn URL. It returns the name, title, location, employer firmographics, and both business and personal emails with associated risk scores. A successful lookup costs 1 token.

> "Take this list of 5 LinkedIn profile URLs, run a lookup for each, and extract their current employer and verified business email addresses."

### Lookup Companies by IP Address
**Tool:** `molt_sets_companies_lookup_by_ip`

This operation deanonymizes website traffic by identifying the company domain behind an IPv4 address. It is crucial for inbound sales teams looking to see which enterprises are browsing their marketing site.

> "We just logged traffic from 198.51.100.42. Run an IP lookup to find out what company owns this address, then pull a brief summary of what they do."

### Lookup Verified Work Emails
**Tool:** `molt_sets_emails_lookup_business_by_linkedin`

Retrieves the verified work email for a specific LinkedIn profile. This strictly returns business addresses, ensuring your agent only pulls data suitable for B2B outreach campaigns.

> "Find the verified business email address for the LinkedIn URL I just provided. If it returns successfully, draft a cold outreach email pitching our security product."

### Check Account Token Balances
**Tool:** `list_all_molt_sets_account`

Retrieves your MoltSets account plan, subscription status, standard token balance, phone-token balance, and live fair-use headroom. This tool is free to call and is essential for preventing the LLM from executing commands when quotas are depleted.

> "Check my MoltSets account status. How many tokens do I have left for the current billing cycle, and am I authorized to perform personal email lookups on this tier?"

To view the complete schema details and the full inventory of MoltSets tools, visit the [MoltSets integration page](https://truto.one/integrations/detail/moltsets).

## Workflows in Action

Connecting MoltSets to Claude allows you to chain multiple API calls together into autonomous workflows. The LLM can interpret data, make routing decisions, and format outputs entirely on its own.

### Scenario 1: IP-Based Deanonymization and Target Sourcing

Inbound sales teams often log IP addresses of anonymous website visitors but struggle to manually identify the company and find the right buyer. Claude can automate this entirely.

> "I noticed high-intent traffic from IP address 203.0.113.88 on our pricing page. First, identify the company associated with this IP. Once you know the company domain, search their employee database for anyone with the title 'Chief Information Security Officer' or 'VP of Security'. Output their names and verified business emails in a markdown table."

**How the agent executes this:**
1. Calls `molt_sets_companies_lookup_by_ip` passing `ip: "203.0.113.88"`.
2. Receives the company firmographics (e.g., Acme Corp, `acme.example.com`).
3. Calls `list_all_molt_sets_search_people` passing `employer: "acme.example.com"` and `title: "Chief Information Security Officer OR VP of Security"`.
4. Formats the returned profile data and verified business emails into the requested markdown table.

```mermaid
sequenceDiagram
participant User as User Prompt
participant Claude as Claude Desktop
participant MCP as Truto MCP Server
participant Upstream as MoltSets API

User->>Claude: Identify IP 203.0.113.88 and find security leads
Claude->>MCP: Call molt_sets_companies_lookup_by_ip
MCP->>Upstream: GET /v1/companies/ip
Upstream-->>MCP: Company domain (acme.example.com)
MCP-->>Claude: JSON response
Claude->>MCP: Call list_all_molt_sets_search_people
MCP->>Upstream: GET /v1/search/people?employer=acme.example.com
Upstream-->>MCP: Contact data and emails
MCP-->>Claude: JSON response
Claude-->>User: Renders markdown table of prospects
```

### Scenario 2: Token-Aware Bulk Enrichment

When enriching large lists of URLs, an agent must be mindful of your paid API quotas. Claude can check your balance before deciding how many profiles to process.

> "I have a list of 25 LinkedIn URLs from yesterday's webinar. First, check my MoltSets account balance. If I have fewer than 10 tokens remaining, warn me and stop. If I have more than 10 tokens, run a lookup on the first 5 URLs to find their verified work emails and current job titles."

**How the agent executes this:**
1. Calls `list_all_molt_sets_account` to read the remaining standard token balance.
2. Evaluates the response. Assuming the balance is 500, it proceeds.
3. Iterates through the first 5 URLs, calling `molt_sets_business_profiles_lookup_by_linkedin` for each.
4. Compiles the job titles and business emails into a clean summary, conserving the remaining tokens.

## Security and Access Control

When exposing data enrichment platforms to LLMs, you must strictly control what the model is allowed to do. Truto provides several architectural layers of access control for MCP servers:

*   **Method Filtering:** Use `config.methods` to restrict the server to specific operation types. For example, setting `methods: ["read"]` ensures the agent can query data but cannot trigger billing plan changes or account mutations.
*   **Tag Filtering:** Use `config.tags` to group tools. If your MoltSets instance is tagged, you can scope an MCP server to only expose tools tagged with `prospecting`, hiding administrative tools entirely.
*   **Require API Token Auth:** By setting `require_api_token_auth: true`, the bare URL is no longer sufficient to access the tools. The client must attach a valid Truto API token in the Authorization header, preventing unauthorized internal usage if the URL leaks.
*   **Automated Expiration:** Set an `expires_at` ISO datetime when generating the server. Once the timestamp is reached, the distributed edge runtime automatically drops the token and schedules a cleanup alarm to purge the database record, instantly revoking the LLM's access.

## Strategic Wrap-Up

Connecting MoltSets to Claude transforms raw API endpoints into autonomous data sourcing agents. Instead of forcing sales development reps to manually cross-reference IP addresses, LinkedIn profiles, and email verification tools, you can instruct Claude to execute the entire prospecting lifecycle using natural language. 

By leveraging Truto's managed MCP architecture, engineering teams bypass the burden of OAuth lifecycles, JSON-RPC protocol maintenance, and schema mapping. The LLM interacts directly with the native MoltSets resources, gracefully reading standardized rate limit headers and navigating the token economy, while your team maintains absolute cryptographic control over what the agent can access.