---
title: "Connect Hunter to ChatGPT: Find Emails & Automate Outreach"
slug: connect-hunter-to-chatgpt-find-emails-automate-outreach
date: 2026-11-04
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "A technical guide to generating a secure, managed MCP server for Hunter using Truto, and connecting it to ChatGPT to automate email discovery and B2B outreach."
tldr: "Learn how to connect Hunter to ChatGPT using Truto's auto-generated MCP server. This guide covers bypassing Hunter API quirks, handling rate limits, filtering available tools, and orchestrating full-cycle B2B outreach workflows via natural language."
canonical: https://truto.one/blog/connect-hunter-to-chatgpt-find-emails-automate-outreach/
---

# Connect Hunter to ChatGPT: Find Emails & Automate Outreach


If you want to connect Hunter to ChatGPT so your AI agents can scrape domains for professional emails, verify deliverability, and orchestrate outbound outreach campaigns, 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 translates ChatGPT's JSON-RPC tool calls into standard HTTP requests against the Hunter API. You can spend weeks building, hosting, and managing this translation layer in-house, or you can use a managed platform like Truto to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). 

If your team uses Claude, check out our guide on [connecting Hunter to Claude](https://truto.one/connect-hunter-to-claude-research-domains-enrich-lead-data/) 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 sales intelligence platform like Hunter is an engineering challenge. The integration layer must handle complex nested data envelopes, map flat LLM arguments into highly specific query parameters, and securely manage API credentials. Every time the upstream schema changes or your team needs access to a new endpoint, your custom integration code must be updated, tested, and redeployed. 

This guide breaks down exactly how to use Truto to generate a managed MCP server for Hunter, connect it natively to ChatGPT, and execute full-cycle B2B 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 Hunter API

A custom MCP server is essentially a self-hosted API gateway. While the open MCP standard dictates how models discover tools, building those tools against Hunter's specific API design requires handling a number of sharp edges. 

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

### Strict Rate Limits and LLM Backoff Orchestration
Hunter aggressively rate-limits API usage to protect its database. Standard integration platforms often attempt to swallow rate limit errors by implementing automatic retry queues. Truto takes a different, explicitly architectural approach: **Truto does not retry, throttle, or apply backoff on rate limit errors.** 

When the Hunter API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the calling agent. Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). You must prompt your ChatGPT agent to read these headers and implement its own backoff logic. If you build your own server, you must parse Hunter's specific headers, map them to the MCP error response, and instruct the LLM on exactly how long to wait before trying to find an email address again.

### Opaque Data Envelopes and Flat LLM Arguments
Unlike APIs that return flat JSON objects, Hunter wraps its responses in heavily nested `data` and `meta` envelopes. For example, a domain search returns a list of contacts nested deep within a `data.emails` array, complete with confidence scores and external sources. 

Conversely, when ChatGPT invokes a tool, it passes all arguments as a single flat JSON object. Your MCP server must intelligently split these flat arguments into query schemas and body schemas. Truto handles this automatically during tool generation - extracting parameters from the LLM's flat input and injecting them into the proper HTTP request structures (URL parameters vs JSON body) based on the specific Hunter endpoint.

### Asynchronous Lead Upserts and Conflict Errors
Hunter's lead management API frequently relies on background processing queues. For example, if you attempt to bulk upsert leads, Hunter may return an HTTP 202 Accepted, meaning the job is queued but not complete. Worse, if multiple operations attempt to create leads simultaneously, Hunter will return an HTTP 409 Conflict with a `lead_creation_in_progress` error and a `Retry-After: 1` header. An LLM cannot natively understand that a 409 requires a 1-second pause before retrying unless you explicitly document this within the MCP tool description.

## How to Generate and Connect the Hunter MCP Server

Rather than hand-coding tool definitions, Truto's MCP architecture derives them dynamically. [Tools are generated from the integration's internal configuration resources and documentation records](https://truto.one/how-do-mcp-servers-auto-generate-tools-from-api-documentation/). If an endpoint is documented in Truto, it becomes an AI tool automatically.

Here is how to deploy a Hunter MCP server and attach it to ChatGPT.

### Step 1: Create the MCP Server

Every MCP server in Truto is scoped to a single Integrated Account (your authenticated connection to Hunter). You can generate the server via the UI or programmatically via the API.

**Option A: Via the Truto UI**
1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Hunter account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (name, allowed methods, tags, and optional expiry).
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3...`). Treat this URL as a secure credential.

**Option B: Via the Truto API**
For programmatic deployment, you can provision an MCP server by making a POST request to Truto. This is ideal if you are orchestrating infrastructure as code.

```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": "Hunter B2B Prospecting Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["leads", "campaigns", "discovery"]
    }
  }'
```

The API provisions a secure token in Truto's edge KV storage and returns a `url` field. This single URL handles all routing and authentication.

### Step 2: Connect the Server to ChatGPT

Once you have the URL, you must register it as a custom connector in ChatGPT. ChatGPT will hit the `/initialize` endpoint, read the generated JSON Schema for the Hunter tools, and make them available to your agent.

**Option A: Via the ChatGPT UI**
1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Ensure **Developer mode** is enabled (required for MCP custom connectors).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name the connection (e.g., "Hunter Prospecting (Truto)").
5. Paste the Truto MCP URL into the Server URL field and save.

**Option B: Via Manual Config File (For localized or scripted environments)**
If you are running local agents or testing via CLI tools that parse MCP configurations, you can use the Server-Sent Events (SSE) proxy command provided by the MCP SDK.

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

## Hero Tools for Hunter Automation

Truto exposes dozens of endpoints for Hunter, but AI agents are most effective when utilizing high-leverage discovery and enrichment tools. Here are the core hero tools you should expose to ChatGPT.

### list_all_hunter_domain_searches
This tool is the foundation of account-based prospecting. It searches Hunter's index for all professional email addresses associated with a specific company domain. It returns an array of contacts, including names, positions, seniority, and a confidence score for deliverability.

**Contextual usage notes:** This tool is strictly a `GET` request. It returns a heavy, nested `data` object. Instruct ChatGPT to extract the `emails` array and filter out low-confidence scores before taking further action.

> "Search for email addresses associated with 'acmecorp.com'. Filter the results to only show contacts with a 'director' or 'vp' seniority level and a confidence score higher than 85." 

### list_all_hunter_email_finders
When you know exactly who you want to reach but lack their contact information, this tool bridges the gap. It takes a full name (or first and last name) combined with a company domain, or a raw LinkedIn handle, and returns the best matching email address.

**Contextual usage notes:** You must supply either a `linkedin_handle` or a combination of domain and name. The API automatically triggers Hunter's proprietary algorithms to deduce the most likely email pattern.

> "Find the professional email address for 'Jane Doe' who works at 'piedpiper.com'. If you find it, confirm the sources where this email was discovered."

### list_all_hunter_email_verifiers
Before adding an email to an automated outreach sequence, you must verify its deliverability to protect your sending reputation. This tool runs a live SMTP check and syntax validation on a provided email.

**Contextual usage notes:** Returns a verification result under the `data` field indicating if the address is `valid`, `invalid`, or `accept_all`. 

> "Run a verification check on 'j.smith@initech.com'. Tell me if the address is safe to send to, or if the server is configured as an accept-all domain."

### list_all_hunter_people_finds
This tool flips the script: instead of finding an email from a name, it enriches a known email address into a full personal profile. It returns the person's name, current position, employer details, location, and related social media profiles.

**Contextual usage notes:** Essential for writing highly personalized outreach copy. Pass the email address, and instruct ChatGPT to use the enriched data (like location or job title) to draft a custom message.

> "Take the email 'alex@globex.com' and pull their enriched profile. Use their current job title and location to draft a short, 3-sentence cold email introducing our new analytics software."

### create_a_hunter_lead
Once a prospect is verified, this tool writes the record into your Hunter CRM backend. It accepts custom attributes, confidence scores, and department tags.

**Contextual usage notes:** If the API returns a 409 Conflict with `lead_creation_in_progress`, the LLM must pause and retry. Truto handles the authentication, but the agent handles the business logic.

> "Create a new lead in our Hunter account for 'Erlich Bachman' at 'aviato.com'. Include his email 'erlich@aviato.com' and tag the lead under the 'Engineering' department."

### hunter_campaigns_start
This executes the final step of the automation pipeline. It takes an existing, configured draft campaign in Hunter and starts the sequence, initiating the actual dispatch of emails to the campaign's recipients.

**Contextual usage notes:** Only campaigns owned by the API key user or a team admin can be started. Use this tool carefully, as it triggers real-world outbound emails.

> "Look up the campaign ID for the 'Q4 Enterprise Outreach' campaign and start it so the emails begin sending to the enrolled leads."

To view the complete inventory of available API endpoints, request body schemas, and JSON property types, review the full [Hunter integration page](https://truto.one/integrations/detail/hunter).

## Workflows in Action

Connecting a single tool is useful, but MCP servers unlock their true value when an AI agent chains multiple tools together to orchestrate complex business logic. Here are two real-world workflows that ChatGPT can execute autonomously using the Truto Hunter MCP server.

### Workflow 1: The Automated SDR (Account Enrichment & Lead Gen)

A sales development representative needs to find decision-makers at a target company, verify their contact information, and push the clean data into the CRM. 

**The Prompt:**
> "I need to build a prospect list for 'cyberdyne.com'. Search their domain for employees in the 'Engineering' department. Take the top 3 results, verify their email deliverability, and for any email that comes back as 'valid', create a new lead in our system with their name and email."

**How the Agent Executes:**
1. **`list_all_hunter_domain_searches`**: ChatGPT calls the domain search tool, passing `cyberdyne.com` and filtering the `department` for engineering roles.
2. **Data Parsing**: The agent receives the heavily nested `data` array, extracts the email addresses, and drops any that have a low initial confidence score.
3. **`list_all_hunter_email_verifiers`**: ChatGPT loops through the top 3 emails, calling the verifier tool for each one to check live deliverability.
4. **`create_a_hunter_lead`**: For every payload that returns `valid`, the agent invokes the create lead tool, passing the extracted `first_name`, `last_name`, and `email` to push the clean record into the Hunter backend.
5. **Response**: ChatGPT replies to the user: *"I found 3 engineering contacts at Cyberdyne. Two passed verification (Miles and Sarah). I have created them as leads in your Hunter account. The third email failed verification and was discarded."*

```mermaid
sequenceDiagram
    participant User
    participant Agent as AI Agent (ChatGPT)
    participant Truto as Truto MCP Server
    participant Hunter as Hunter API
    
    User->>Agent: "Find engineers at cyberdyne.com, verify, and save leads."
    Agent->>Truto: call list_all_hunter_domain_searches {domain: "cyberdyne.com"}
    Truto->>Hunter: GET /v2/domain-search?domain=cyberdyne.com
    Hunter-->>Truto: 200 OK (List of contacts)
    Truto-->>Agent: JSON Result
    
    loop For top 3 contacts
        Agent->>Truto: call list_all_hunter_email_verifiers {email: contact.email}
        Truto->>Hunter: GET /v2/email-verifier?email=...
        Hunter-->>Truto: 200 OK (Status: valid)
        Truto-->>Agent: JSON Result
        
        opt If Valid
            Agent->>Truto: call create_a_hunter_lead {email, first_name}
            Truto->>Hunter: POST /v2/leads
            Hunter-->>Truto: 201 Created
            Truto-->>Agent: JSON Result
        end
    end
    
    Agent-->>User: "2 valid leads successfully created."
```

### Workflow 2: Orchestrating an Outbound Campaign

A RevOps manager wants to find a specific executive, draft highly personalized copy based on their background, enroll them in a campaign, and trigger the send.

**The Prompt:**
> "Find the email address for 'John Hammond' at 'ingen.com'. Enrich his profile to see his location and current job title. Add him as a recipient to campaign ID '88421'. Once he is enrolled, start the campaign."

**How the Agent Executes:**
1. **`list_all_hunter_email_finders`**: ChatGPT queries the finder tool with the name and domain to secure the exact email format.
2. **`list_all_hunter_people_finds`**: The agent passes the discovered email to the enrichment tool, pulling back the executive's location and social metadata.
3. **`create_a_hunter_campaign_recipient`**: Using the verified email, the agent calls the recipient creation tool, pushing the contact into the specified campaign ID.
4. **`hunter_campaigns_start`**: Finally, the agent invokes the start campaign tool to change the status of the sequence from draft to active.

## Security and Access Control

Exposing an outbound email platform like Hunter to an autonomous AI agent carries inherent risk. You do not want a hallucinating model accidentally deleting your entire leads list or triggering campaigns prematurely. [Truto provides strict, server-side guardrails](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/) that are enforced before the request ever reaches the proxy API.

*   **Method Filtering (`config.methods`)**: You can restrict an MCP server to specific HTTP verbs. By setting `methods: ["read"]`, Truto will filter out all `create`, `update`, and `delete` operations during tool generation. The LLM simply will not see them.
*   **Tag Filtering (`config.tags`)**: You can scope the server to specific functional areas. Passing `tags: ["discovery"]` ensures the LLM can search domains and verify emails, but cannot touch the `campaigns` or `leads` resources.
*   **Secondary Authentication (`require_api_token_auth`)**: By default, the MCP URL carries authentication. If you toggle this flag to `true`, the standard Truto session middleware runs. The MCP client (ChatGPT) must pass a valid Truto API bearer token to execute tools, preventing unauthorized URL sharing.
*   **Ephemeral Access (`expires_at`)**: You can assign an ISO datetime to the server. Truto's edge KV storage will automatically drop the token at the expiration time, and a Durable Object alarm will purge the database record, cleanly revoking the LLM's access.

## Focus on the Workflow, Not the Wrapper

Building an integration layer for AI agents is a trap. If you spend your engineering cycles parsing Hunter's generic data envelopes, mapping LLM arguments into nested JSON arrays, and manually building JSON-RPC tool schemas, you are building infrastructure, not a product.

By using Truto to generate a managed MCP server, you abstract away the API layer entirely. Your agents get immediate, secure, and fully documented access to Hunter's endpoints, allowing your team to focus exclusively on prompt engineering, agent orchestration, and shipping real business value.

> 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/)