---
title: "Connect Hunter to Claude: Research Domains & Enrich Lead Data"
slug: connect-hunter-to-claude-research-domains-enrich-lead-data
date: 2026-11-04
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect Hunter to claude using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows."
canonical: https://truto.one/blog/connect-hunter-to-claude-research-domains-enrich-lead-data/
---

# Connect Hunter to Claude: Research Domains & Enrich Lead Data


If your team needs to connect Hunter to Claude to automate account-based marketing (ABM), enrich lead lists, or [discover decision-maker contact info at scale](https://truto.one/connect-hunter-to-chatgpt-find-emails-automate-outreach/), 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 secure translation layer between Claude's [function-calling capabilities](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) and Hunter'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 in seconds. 

If your team uses ChatGPT, check out our [guide on connecting Hunter to ChatGPT](https://truto.one/connect-hunter-to-chatgpt-find-emails-automate-outreach/) or explore our broader architectural [overview on connecting Hunter to AI agents](https://truto.one/connect-hunter-to-ai-agents-scale-lead-lists-sales-sequences/).

Giving a Large Language Model (LLM) read and write access to a lead generation platform like Hunter is an engineering challenge. You have to handle API key lifecycles, map Hunter's specific JSON schemas to MCP tool definitions, and deal with strict search quota rate limits. Every time Hunter introduces a new endpoint or modifies how they return confidence scores, 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 Hunter, connect it natively to Claude Desktop, and execute complex prospecting workflows using natural language.

> Want to give your AI agents secure, authenticated access to Hunter 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 Hunter 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 data APIs is painful. Hunter is built to process massive amounts of unstructured domain and identity data. Its API reflects that complexity.

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

**Rate Limits and Quota Management**
Hunter enforces strict rate limits and usage quotas based on your subscription tier. Unlike some platforms that might queue requests, when an upstream API returns an HTTP 429 rate limit error, 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 spec. Truto does not retry, throttle, or apply backoff on these errors - the caller (your orchestration code or the agent) is fully responsible for handling the retry and backoff logic. If your Claude agent decides to loop through 500 domains in one go, you will hit HTTP 429s, and your MCP server must expose those limits back to the model gracefully.

**Concurrency Locks on Lead Creation**
Hunter employs specific concurrency controls when modifying CRM data. For example, if you attempt to create or upsert a lead while another background process is doing the same for that team, the API will return a 409 Conflict with a `lead_creation_in_progress` error and a `Retry-After: 1` header. An LLM cannot simply guess this behavior. Your MCP tool schemas must instruct Claude on how to handle these specific 409 responses, wait the required second, and retry the payload.

**Opaque Confidence Scoring and Status Mapping**
When verifying emails or discovering contacts, Hunter returns detailed `confidence_score` integers alongside specific status enums (`valid`, `accept_all`, `invalid`, `webmail`, `disposable`). If an MCP tool simply dumps the raw JSON back to Claude, the LLM often misinterprets an `accept_all` response (where a server accepts all mail but might silently drop it) as a guaranteed "valid" email. Your MCP integration layer must strictly define these enums in the JSON schemas so the LLM understands the exact deliverability risk of a given contact.

## Generating the Hunter MCP Server

To bypass these API hurdles, Truto dynamically derives MCP tool definitions directly from Hunter's underlying resources and documentation. A tool only appears in the MCP server if it has a corresponding, validated schema. 

Each MCP server is scoped to a single connected Hunter account. The server URL contains a cryptographically hashed token that encodes which account to use, what tools to expose, and when the server expires. This means the URL alone is enough to authenticate and serve tools - no additional configuration needed on the client side.

You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

For teams who prefer a visual setup:

1. Log into your Truto dashboard and navigate to the integrated account page for your Hunter connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can filter tools by method (e.g., only allow `read` tools to prevent accidental lead creation) or by specific tags.
5. Click Generate, and copy the resulting MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For developers automating infrastructure, you can generate the MCP server dynamically by sending a POST request to Truto.

**Endpoint:** `POST /integrated-account/:id/mcp`

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Hunter Lead Research Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["domain_search", "enrichment"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API responds with your configuration and the secure connection URL:

```json
{
  "id": "mcp-req-789",
  "name": "Hunter Lead Research Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can plug it directly into your Claude environment. 

### Method 1: Via the Claude UI

If you are using Claude for Web or Enterprise:

1. In Claude, navigate to **Settings -> Integrations -> Add MCP Server** (Note: this exact path may vary based on your Claude tier, e.g. ChatGPT uses Settings -> Connectors -> Add).
2. Paste your `https://api.truto.one/mcp/a1b2c3d4e5f6...` URL into the Server URL field.
3. Give it a recognizable name like "Hunter Lead Engine".
4. Click **Add**. Claude will instantly execute a JSON-RPC handshake, pull the available Hunter tools, and make them available for your chat sessions.

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

If you are building locally with Claude Desktop, you connect the server by updating your configuration file (`claude_desktop_config.json`). Since Truto's MCP servers communicate over HTTP Server-Sent Events (SSE), you will use the official `@modelcontextprotocol/server-sse` wrapper.

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

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

Restart Claude Desktop. The Hunter tools will immediately appear in your available integrations list.

## Essential Hunter Tools for Claude

Truto maps Hunter's API endpoints into flat, descriptive snake_case tools. Here are six high-leverage hero tools your AI agents can use to automate prospecting.

### 1. Domain Search (`hunter_domains_search`)

This tool searches Hunter's index for email addresses published for a specific company domain. It returns discovered emails along with names, job positions, confidence scores, and the public sources where the data was found.

> "Claude, run a domain search on 'stripe.com'. Return the top 5 engineering contacts along with their confidence scores and public sources."

### 2. Find Specific Emails (`list_all_hunter_email_finders`)

Instead of a broad domain search, this tool finds a specific professional email address by combining a company domain with a full name (or first/last name), or by using a LinkedIn handle.

> "Claude, use the email finder tool to track down the contact address for John Doe at acmecorp.com. If the confidence score is below 70, let me know."

### 3. Verify Email Deliverability (`list_all_hunter_email_verifiers`)

This tool verifies the deliverability of an email address. It returns a result wrapper containing the status (`valid`, `accept_all`, etc.) and a breakdown of the specific verification checks performed (e.g., SMTP check, format check).

> "Claude, take this list of 10 scraped emails and run them through the Hunter verifier. Flag any that return an 'accept_all' status so we know they carry bounce risk."

### 4. Enrich Person Data (`list_all_hunter_people_finds`)

When you only have an email address, this tool enriches the record. It returns the enriched person record including their name, position, employer, location, phone number, and related social profiles.

> "Claude, I just got an inbound lead from jsmith@techstartup.io. Use the people enrichment tool to find their job title, location, and LinkedIn profile."

### 5. Enrich Company Data (`list_all_hunter_companies_finds`)

This tool takes a raw domain and returns an enriched company record. It provides firmographic data including industry, company size, location, technologies used, funding rounds, and social profiles.

> "Claude, enrich the domain 'vercel.com'. Summarize their industry, estimated employee count, and the technologies they use on their site."

### 6. Bulk Upsert Leads (`hunter_leads_bulk_upsert`)

This tool creates or updates up to 100 Hunter leads in a single call, matching on the `email` field. Because each lead is written in its own transaction, one malformed record will not cancel the rest of the batch.

> "Claude, take the 20 validated engineering contacts we just found, format them into the required schema, and bulk upsert them into our Hunter leads list."

For the complete tool inventory - including campaign management, sequence tracking, and account statistics - visit the [Hunter integration page](https://truto.one/integrations/detail/hunter).

## Workflows in Action

Giving Claude access to individual endpoints is useful, but the real power of MCP is multi-step [agentic orchestration](https://truto.one/connect-hunter-to-ai-agents-scale-lead-lists-sales-sequences/). Here is how Claude combines these tools to automate complex revenue operations.

### Scenario 1: Account-Based Marketing (ABM) Discovery

**The Prompt:**
> "Claude, we are targeting 'databricks.com'. First, enrich the company to confirm their size and industry. Next, run a domain search to find their marketing leadership. Finally, verify the emails you find and give me a summary of only the 'valid' contacts."

**How the Agent Executes:**

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude
    participant Truto as Truto MCP
    
    User->>Claude: "Target databricks.com..."
    Claude->>Truto: call ["list_all_hunter_companies_finds"]<br>(domain: databricks.com)
    Truto-->>Claude: Returns firmographics, size, tech stack
    Claude->>Truto: call ["hunter_domains_search"]<br>(domain: databricks.com, department: marketing)
    Truto-->>Claude: Returns list of emails, names, roles
    Claude->>Truto: call ["list_all_hunter_email_verifiers"]<br>(Loop through discovered emails)
    Truto-->>Claude: Returns status (valid/invalid/accept_all) for each
    Claude-->>User: Summarizes final, verified ABM list
```

**The Result:** 
Claude reads the firmographic data, understands the company size, isolates the marketing department via the domain search parameters, and systematically verifies the output. The user gets a highly qualified, zero-bounce contact list ready for outreach.

### Scenario 2: Automated Inbound Enrichment and CRM Sync

**The Prompt:**
> "Claude, I have a CSV text block of 50 recent webinar signups (mostly just emails). Enrich each person to get their job title and company info. If they are Director-level or above, bulk upsert them into our Hunter leads list."

**How the Agent Executes:**

```mermaid
flowchart TD
    A["Parse CSV text block"] --> B["Iterate through 50 emails"]
    B --> C["Call 'list_all_hunter_people_finds'"]
    C --> D{"Is position<br>Director or higher?"}
    D -- Yes --> E["Format lead payload"]
    D -- No --> F["Discard/Skip"]
    E --> G["Call 'hunter_leads_bulk_upsert'"]
    G --> H["Report success/failure array back to user"]
```

**The Result:** 
Claude acts as an automated data enrichment pipeline. It maps the unstructured CSV text into JSON parameters, calls the people enrichment tool, evaluates the returned `position` strings against the user's criteria, constructs a bulk JSON array, and pushes the qualified leads back into the Hunter CRM ecosystem.

## Security and Access Control

Exposing your Hunter account to an AI model requires strict governance. Truto's MCP servers enforce security at the infrastructure layer:

*   **Method Filtering:** Restrict servers to specific operations. For example, pass `methods: ["read"]` during server creation to give Claude read-only access to domain search, ensuring it cannot accidentally delete or overwrite existing leads.
*   **Tag Filtering:** Group tools by functional area. You can restrict an MCP server to only expose resources tagged with `enrichment` while hiding `campaigns` and `sequences`.
*   **Extra Authentication:** Enable `require_api_token_auth` on the MCP token. This forces the client to provide a valid Truto API token in the `Authorization` header, ensuring possession of the URL alone is not enough to access your Hunter data.
*   **Automatic Expiration:** Set an `expires_at` timestamp. Truto will automatically clean up the database record and expire the token via a scheduled Durable Object alarm, perfect for granting temporary access to contractors or isolated agent runs.

## Strategic Wrap-Up

Connecting Hunter to Claude via a managed MCP server transforms LLMs from passive text generators into active revenue engines. Instead of manually exporting CSVs from domain searches, cleaning them in Excel, and uploading them to email verification tools, your team can instruct AI agents to handle the entire lifecycle autonomously.

By leveraging Truto's dynamic tool generation, you offload the massive technical debt of tracking Hunter's API changes, maintaining pagination logic, and writing custom schema wrappers. You focus on engineering the AI prompts and workflows; Truto ensures the underlying API integrations execute reliably and securely.