---
title: "Connect ContactOut to Claude: Find Decision Makers and Verify Emails"
slug: connect-contactout-to-claude-find-decision-makers-and-verify-emails
date: 2026-10-16
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to architect a managed MCP server to connect ContactOut to Claude. Automate decision-maker sourcing, bulk profile enrichment, and email verification."
tldr: "Give Claude secure access to ContactOut's API via a managed MCP server. This guide covers how to expose ContactOut's search, enrichment, and bulk verification endpoints to AI agents, handle credit-based API quotas, and execute complex B2B prospecting workflows using natural language."
canonical: https://truto.one/blog/connect-contactout-to-claude-find-decision-makers-and-verify-emails/
---

# Connect ContactOut to Claude: Find Decision Makers and Verify Emails


If your team uses ChatGPT, check out our guide on [connecting ContactOut to ChatGPT](https://truto.one/connect-contactout-to-chatgpt-search-leads-and-enrich-profiles/) or explore our broader architectural overview on [connecting ContactOut to AI Agents](https://truto.one/connect-contactout-to-ai-agents-automate-prospecting-and-data-sourcing/). 

Giving a Large Language Model (LLM) read and write access to an enterprise data intelligence platform like ContactOut is fundamentally an infrastructure challenge. You need a secure translation layer between Claude's function calling capabilities and ContactOut's complex REST API. This translation layer is defined by the Model Context Protocol (MCP). You can either [build, host, and maintain a custom MCP server yourself](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a [managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).

While the open MCP standard provides a predictable way for models to discover tools, implementing it against ContactOut's specific API topology requires mapping massive nested JSON schemas, managing a strict multi-tiered credit system, and orchestrating asynchronous polling jobs. Every time ContactOut updates an endpoint, adds a new filter parameter, or changes a schema constraint, a self-hosted MCP server requires code updates and redeployment.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for ContactOut, [connect it natively to Claude](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/), and execute complex B2B prospecting workflows using natural language.

> Want to give your AI agents secure, authenticated access to ContactOut 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 ContactOut API

A custom MCP server is essentially a [self-hosted integration proxy](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/). If you decide to build one for ContactOut, you own the entire integration lifecycle. ContactOut's API is built for high-volume data enrichment and lead sourcing, and its architectural quirks reflect that domain.

Here are the specific integration challenges you will face when mapping ContactOut endpoints to MCP tools:

### The Multi-Currency Credit Ledger
ContactOut does not just rate-limit requests; it deducts specific functional credits based on the *type* of data requested and found. A single API call might consume a mix of Search Credits, Email Credits, Phone Credits, and Verifier Credits.

For example, calling the `contact_out_people_enrich` endpoint costs 1 search credit automatically. If the endpoint successfully returns an email, it deducts an additional email credit. If it finds a phone number, it deducts a phone credit. An LLM has no inherent concept of financial API constraints. If you give Claude unfettered access to a generic Search tool and it decides to loop through 500 pages of results because of a vague prompt, it will rapidly deplete your organization's quota. You must strictly define your MCP tool descriptions to instruct the LLM on exactly *when* to execute expensive enrichment calls.

### Synchronous vs. Asynchronous Bulk Workflows
While single-profile lookups are synchronous, ContactOut handles bulk enrichment (up to 1,000 LinkedIn profiles) and bulk email verification (up to 100 emails) via asynchronous V2 endpoints. 

When you call `create_a_contact_out_email_verification_job`, ContactOut immediately returns a `202 Accepted` with a `job_id` and a status like `QUEUED`. LLMs are stateless by default and expect synchronous returns. To handle this via MCP, your server must expose paired tools: one to create the job, and another (`get_single_contact_out_email_verification_job_by_id`) for the LLM to explicitly poll. You have to write prompt instructions that teach the LLM the exact polling interval and state machine logic, otherwise, the agent will hallucinate a completed result instantly.

### Rate Limiting and Backoff Delegation
ContactOut enforces aggressive rate limits on aggressive endpoints (e.g., the People Search API is limited to 60 requests per minute). 

**Crucial architectural note:** Truto does not retry, throttle, or apply backoff on rate limit errors. When ContactOut's API returns an HTTP 429, Truto passes that error directly back to the caller. However, Truto normalizes the upstream rate limit information into standardized HTTP headers per the IETF specification (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller (your agent framework or Claude Desktop) is entirely responsible for interpreting these headers and executing exponential backoff. Do not rely on the MCP server to absorb rate limit spikes.

## Architecting the Managed MCP Server

Rather than hand-coding tool definitions, Truto derives them dynamically from existing data sources: the integration's resource definitions and the underlying API documentation. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring only well-described, LLM-ready endpoints are exposed.

You can generate an MCP server for ContactOut in two ways.

### Method 1: Via the Truto UI
1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected ContactOut instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server (set a name, select allowed methods, tags, and an optional expiration date).
5. Click **Create** and copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the API
For teams building programmatic AI environments, you can generate MCP servers dynamically. The Truto API validates that the integration has tools available, generates a secure cryptographically hashed token, stores the metadata in a distributed key-value store, and returns the endpoint.

```typescript
// POST /integrated-account/:id/mcp
{
  "name": "ContactOut ABM Agent Server",
  "config": {
    "methods": ["read", "create", "custom"],
    "tags": ["enrichment", "verification"]
  },
  "expires_at": "2026-12-31T23:59:59Z"
}
```

## Connecting the MCP Server to Claude

Because the MCP server URL contains a cryptographic token that encodes the account routing and tool configuration, the URL itself is the only configuration required by the client.

### Method A: Via the Claude UI (and ChatGPT)
If your organization uses Claude Desktop or ChatGPT's web interface:

**For Claude:**
1. Open Claude Settings → Integrations.
2. Click **Add MCP Server**.
3. Paste your Truto MCP URL and save.

**For ChatGPT:**
1. Navigate to Settings → Apps → Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, paste the Truto MCP URL.

### Method B: Via Manual Config File
If you are configuring a custom agent or managing Claude Desktop deployments via MDM, inject the configuration directly into `claude_desktop_config.json`:

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

Once connected, Claude dynamically requests `tools/list` and parses the JSON Schema definitions generated from ContactOut's documentation.

## ContactOut Hero Tools for Claude

By default, an LLM framework processes arguments as a flat JSON object. Truto automatically maps Claude's function call arguments to ContactOut's specific query parameters or JSON body fields based on the OpenAPI schema. 

Here are the most high-leverage tools available on the ContactOut MCP server:

### `contact_out_people_search_decision_makers`
This is the spearhead tool for Account-Based Marketing (ABM) workflows. It returns decision-makers at a specific company. You must pass at least one of `linkedin_url`, `domain`, or `name`. 

*Usage Note:* Costs 1 search credit per profile returned. Avoid setting `reveal_info=true` during initial discovery, as that will immediately burn email/phone credits for every result.

> "Find the VP of Engineering and the CTO at acme.com using the `contact_out_people_search_decision_makers` tool. Do not reveal contact info yet, just get me their LinkedIn URLs."

### `contact_out_people_enrich_by_linkedin_url`
Takes a single LinkedIn profile URL and returns the full ContactOut profile. If `profile_only` is false, it attempts to find and return associated emails and phone numbers.

*Usage Note:* Costs 1 email credit and 1 phone credit when contact data is found. If you only want the work history without the contact details, set `profile_only=true` (costs 1 search credit).

> "Take the LinkedIn URL for Acme's CTO that you just found, and use `contact_out_people_enrich_by_linkedin_url` to get their full profile, including their contact information."

### `contact_out_contacts_bulk_enrich`
Executes a synchronous V1 bulk lookup for up to 100 LinkedIn profiles simultaneously. 

*Usage Note:* This is highly efficient for LLM context windows compared to looping over individual URLs. Returns an object keyed by the requested URL containing emails (and phones if `include_phone=true`). Burns credits per successful find.

> "I have a list of 45 LinkedIn URLs. Pass them all to `contact_out_contacts_bulk_enrich` in a single request to get their email addresses. Return the results as a clean markdown table."

### `contact_out_companies_search`
Allows Claude to search for target accounts based on highly specific firmographics: name, domain, size, location, industry, technologies, revenue, and founding year.

*Usage Note:* Paging is handled by passing `page` in the body. Costs 1 search credit per company returned.

> "Use `contact_out_companies_search` to find SaaS companies based in London with a size of 50-200 employees that use Snowflake. Give me the top 10 results."

### `create_a_contact_out_email_verification_job`
Initiates an asynchronous bulk verification job for up to 100 email addresses to check deliverability. 

*Usage Note:* Returns a `job_id` and a `status`. The LLM must be instructed to save this `job_id` and poll the corresponding GET endpoint. Costs 1 verifier credit per email that resolves to valid, invalid, or accept_all.

> "Take this list of 50 scraped emails and pass them to `create_a_contact_out_email_verification_job`. Note the job ID it returns."

### `get_single_contact_out_email_verification_job_by_id`
Retrieves the results of an async verification job. 

*Usage Note:* Returns the `status` (which will be `DONE` when complete) and a `result` object mapping each email to its status (`valid`, `invalid`, `accept_all`, `disposable`, or `unknown`).

> "Check the status of the verification job using `get_single_contact_out_email_verification_job_by_id`. If it is DONE, filter out all emails that are not 'valid' and give me the final clean list."

For the complete tool inventory, including individual endpoint schemas and credit consumption rules, refer to the [ContactOut Integration Documentation](https://truto.one/integrations/detail/contactout).

## Workflows in Action

Giving Claude raw API tools is only half the battle. The true power of an MCP server is orchestrating multi-step workflows autonomously. Here are two concrete examples of how Claude executes domain-specific ContactOut tasks.

### Scenario 1: The Account-Based Sourcing Loop
A Sales Development Representative (SDR) needs to build a highly targeted outreach list based on firmographics, identify the key buyers, and extract their contact info without wasting credits on low-level employees.

> "Search ContactOut for companies in the 'cybersecurity' industry located in 'New York' with 50-200 employees. Pick the top 3 domains. For each domain, find decision makers with the title 'CISO' or 'Director of Security'. Finally, enrich only those specific individuals to get their work emails."

**Execution Steps:**
1. Claude calls `contact_out_companies_search` with the parameters `{ "industry": "cybersecurity", "location": "New York", "size": "50-200" }`.
2. The server returns a list of matching companies. Claude extracts the top 3 `domain` values.
3. Claude iterates through the domains, calling `contact_out_people_search_decision_makers` for each, passing the domain and querying for specific titles.
4. Claude aggregates the `linkedin_url` values from the decision-makers found.
5. Claude calls `contact_out_contacts_bulk_enrich` passing the array of LinkedIn URLs to retrieve the final email payload.

```mermaid
sequenceDiagram
    participant Claude as Claude Agent
    participant MCP as Truto MCP Server
    participant Upstream as ContactOut API

    Claude->>MCP: Call contact_out_companies_search
    MCP->>Upstream: POST /v1/companies/search
    Upstream-->>MCP: Returns list of domains
    MCP-->>Claude: JSON Array of Domains
    
    Claude->>MCP: Call contact_out_people_search_decision_makers
    MCP->>Upstream: POST /v1/decision_makers
    Upstream-->>MCP: Returns CISO Profiles
    MCP-->>Claude: JSON Array of LinkedIn URLs
    
    Claude->>MCP: Call contact_out_contacts_bulk_enrich
    MCP->>Upstream: POST /v1/contacts/bulk
    Upstream-->>MCP: Returns Contact Info
    MCP-->>Claude: Final List of Verified Emails
```

### Scenario 2: Asynchronous List Cleansing
A Marketing Ops manager has a CSV of raw, unverified lead emails from an old webinar and needs Claude to sanitize the list to protect domain sender reputation.

> "I have 85 emails from our legacy database. Verify all of them through ContactOut. Create the bulk job, check it until it's finished, and return only the emails marked strictly 'valid'."

**Execution Steps:**
1. Claude parses the emails and calls `create_a_contact_out_email_verification_job`, passing the array.
2. ContactOut returns a `job_id` (e.g., `job_9a8b7c`).
3. Claude waits briefly, then calls `get_single_contact_out_email_verification_job_by_id` with `job_9a8b7c`.
4. If the status is `QUEUED` or `PROCESSING`, Claude loops and calls the GET endpoint again.
5. Once the status is `DONE`, Claude processes the `result` map, discards `invalid`, `accept_all`, and `disposable` addresses, and presents the clean list to the user.

## Security and Access Control

When exposing a platform that costs actual money per API call to an autonomous LLM, access control is critical. Truto's MCP servers provide several layers of configuration to secure your ContactOut integration:

*   **Method Filtering:** Configure the `config.methods` array (e.g., `["read"]`) to restrict the LLM entirely to GET and LIST operations. This prevents the LLM from accidentally triggering POST requests that initiate expensive bulk jobs.
*   **Tag Filtering:** Use `config.tags` (e.g., `["verification"]`) to scope the server. If you only want an agent to do list cleansing, tag filtering hides the sourcing and company search endpoints, severely limiting the blast radius of LLM hallucinations.
*   **Expiration (`expires_at`):** You can generate time-bound MCP servers that self-destruct. The underlying distributed alarm service automatically cleans up the database record and key-value entries once the timestamp is reached.
*   **Secondary Authentication:** By setting `require_api_token_auth: true`, possession of the MCP URL is no longer sufficient. The connecting client must also pass a valid Truto API token in the Authorization header, preventing leaked URLs from being used.

## Moving Fast with Managed Infrastructure

Connecting ContactOut to Claude unlocks entirely new autonomous workflows for RevOps and SDR teams. Instead of clicking through UI dashboards or writing fragile Python scripts to poll bulk endpoints, your team can simply command Claude to build, verify, and format highly targeted prospect lists in minutes.

By leveraging a managed MCP server through Truto, you bypass the infrastructure tax. There is no server to host, no token refresh logic to write, and no OpenAPI schema to manually translate into tool definitions. The tools are generated dynamically, secured by standard HTTP access controls, and ready to be queried immediately.