Connect ContactOut to ChatGPT: Search Leads & Enrich Profiles

If you want to connect ContactOut to ChatGPT so your AI agents can autonomously research accounts, build targeted lead lists, and enrich contact profiles with verified emails and phone numbers, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool-calling engine and ContactOut's specialized REST API.

If your team uses Claude, check out our guide on connecting ContactOut to Claude or explore our broader architectural overview on connecting ContactOut to AI Agents.

Giving a Large Language Model (LLM) unrestricted read and write access to a lead intelligence platform is an engineering challenge. ContactOut's API requires careful handling of credit consumption, complex pagination, and asynchronous bulk jobs. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM JSON arguments into ContactOut's specific payload structures, or you use a managed infrastructure layer.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for ContactOut, connect it natively to ChatGPT, and execute complex prospecting workflows using natural language.

The Engineering Reality of the ContactOut 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, implementing it against ContactOut's highly specific API introduces immediate friction.

If you decide to build a custom MCP server for ContactOut, you own the entire API lifecycle. Here are the specific integration challenges you must solve:

Multi-Dimensional Credit Consumption

Unlike standard B2B SaaS APIs where a request simply counts against a global rate limit, ContactOut implements a highly granular, multi-dimensional credit system. A single endpoint call - like enriching a profile - can dynamically consume different types of credits (Search, Email, Phone) depending on the actual payload returned. If the API finds an email, it deducts an email credit; if it finds a phone number, it deducts a phone credit.

If you point ChatGPT directly at the ContactOut API without wrapping it in a strictly constrained MCP server, a looping LLM can instantly drain your monthly credit balance by repeatedly querying missing profiles or hallucinating LinkedIn URLs. Your integration layer must explicitly instruct the LLM on how to verify credit limits (list_all_contact_out_usage_stats) before executing large batch jobs.

Asynchronous V2 Bulk Endpoints

While ContactOut provides synchronous single-profile lookups, enriching large lists (up to 1,000 URLs) requires their V2 Bulk API. This is not a simple request-response model. It requires creating an asynchronous job, capturing a job_id, and then either setting up a webhook listener or polling a secondary endpoint until the status returns DONE.

Teaching an LLM to handle asynchronous state management is difficult. Your MCP server must expose both the job creation tool and the job retrieval tool, alongside explicit instructions in the JSON Schema descriptions on how the LLM should poll the retrieval tool using the provided uuid.

Hard Rate Limits and 429 Handling

ContactOut enforces strict rate limits, such as a maximum of 60 requests per minute on the People Search endpoint. Truto handles this gracefully by passing the exact HTTP 429 response back to the caller, while normalizing the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification.

Crucially, Truto does not absorb, throttle, or automatically retry these requests. When the MCP client (ChatGPT) encounters a 429 error via the tool execution result, the LLM must be prompted to respect the backoff and retry later, or your application logic orchestrating the agent must handle the queueing.

Generating the ContactOut MCP Server

Truto derives MCP tools dynamically from ContactOut's resource definitions and human-readable documentation. Instead of hand-coding JSON-RPC endpoints, you authorize the connection, and Truto auto-generates the tools.

Each server is scoped to a single integrated account (your connected ContactOut instance) and uses a cryptographic token for authentication. You can create this server using either the Truto UI or the API.

Method 1: Via the Truto UI

For teams managing integrations manually, the UI provides a fast path to generating a server URL.

1. Log into your Truto dashboard and connect a new ContactOut account via the Integrated Accounts tab.
2. Provide your ContactOut API Key.
3. Navigate to the integrated account page for this specific connection.
4. Click the MCP Servers tab.
5. Click Create MCP Server.
6. Select your desired configuration. You can filter by methods (e.g., read, write) or by tags (e.g., people, enrichment).
7. Click Save and immediately copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For platform engineering teams dynamically spinning up agents per tenant, you can provision the MCP server programmatically via the Truto API.

Make an authenticated POST request to /integrated-account/:id/mcp. The API validates the configuration, generates a secure token stored in Cloudflare KV, and returns the ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/<CONTACTOUT_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ContactOut Sales Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["enrichment", "search", "usage"]
    }
  }'

The response returns the tokenized URL that ChatGPT requires to discover the auto-generated tools.

Connecting the MCP Server to ChatGPT

Once you have the Truto MCP server URL, connecting it to ChatGPT is straightforward. ChatGPT supports MCP through Custom Connectors.

Method 1: Via the ChatGPT UI

If you are a ChatGPT Plus, Pro, Team, or Enterprise user, you can add the server directly through the application settings.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Ensure that Developer mode is enabled.
3. Under the MCP servers or Custom connectors section, click Add new server.
4. Provide a recognizable name (e.g., "ContactOut Intelligence").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Add.

ChatGPT will immediately execute the initialize and tools/list JSON-RPC handshake against the Truto proxy, parsing the schemas and making the tools available for your active session.

Method 2: Via Manual Configuration File (Local Server Proxy)

If you are orchestrating local agents or prefer running ChatGPT's desktop client against a local config, you can use the official @modelcontextprotocol/server-sse wrapper to proxy standard IO to Truto's SSE / HTTP endpoints.

Update your MCP configuration file (typically located at ~/.config/openai/chatgpt_mcp_config.json depending on your desktop setup):

{
  "mcpServers": {
    "contactout_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<YOUR_TRUTO_TOKEN>"
      ]
    }
  }
}

Restart your client. The agent will read the JSON configuration, boot the proxy process, and ingest the ContactOut API tools.

ContactOut MCP Hero Tools

Truto maps the underlying ContactOut API into descriptive, LLM-friendly tools. Here are the highest-leverage operations for AI-driven prospecting.

Search People Profiles

Tool Name: contact_out_people_search

This is the core discovery engine. It allows ChatGPT to query ContactOut's massive database using precise filters like title, company, skills, and location. It returns metadata and profiles keyed by LinkedIn URL. Note that setting reveal_info=true will consume email/phone credits.

"Search ContactOut for people with the title 'Chief Information Security Officer' working at companies in the 'Financial Services' industry located in 'New York'. Return the first page of results."

Enrich by LinkedIn URL

Tool Name: contact_out_people_enrich_by_linkedin_url

This tool retrieves the full ContactOut profile for a specific LinkedIn URL. If contact data (emails/phones) is found, it consumes the respective credits. You can instruct the LLM to pass profile_only=true if you only need resume data without spending contact credits.

"Take this LinkedIn URL (https://linkedin.com/in/example) and enrich it using ContactOut to find their personal and work email addresses."

Bulk Contact Enrichment

Tool Name: contact_out_contacts_bulk_enrich

For high-volume operations, this V1 synchronous bulk endpoint accepts up to 100 LinkedIn profiles at once. It returns a map of emails and phones keyed by the requested URL. This is vastly more efficient for the LLM than looping over single requests, avoiding context bloat and rate limits.

"I have a list of 45 LinkedIn URLs. Run a bulk enrichment on all of them to extract their work emails. Do not include phone numbers to save credits."

Create Email Verification Job

Tool Name: create_a_contact_out_email_verification_job

ContactOut isn't just for discovery - it's also a verification engine. This tool starts an asynchronous bulk verification of up to 100 email addresses, returning a job_id.

"Submit this list of 50 newly discovered emails to the verification job queue. Give me the job ID so we can check the status in a moment."

Search Companies

Tool Name: contact_out_companies_search

Account-based marketing (ABM) starts here. The LLM can search for target accounts based on size, industry, technologies used, revenue, and founding year, before pivoting to find decision-makers at those companies.

"Find companies in the 'SaaS' industry that use 'Salesforce', have between 200 and 500 employees, and are based in the United Kingdom."

Track Usage and Quotas

Tool Name: list_all_contact_out_usage_stats

Given the strict credit economy of ContactOut, this administrative tool is critical. It returns the current month's usage across email, phone, and search quotas. You should prompt your agent to check this before executing large enrichment loops.

"Before we begin prospecting, check our current ContactOut usage stats. Tell me how many search and email credits we have remaining for this month."

For the complete tool inventory and granular schema details, visit the ContactOut integration page.

Workflows in Action

Once the MCP server is initialized, ChatGPT can chain these tools together to execute complex, multi-step prospecting logic.

Scenario 1: Automated Target Account Prospecting

A sales development representative wants to find new accounts matching their ideal customer profile (ICP) and immediately extract the contact info for the key buyers at those accounts.

"Find 10 mid-sized healthcare companies in Texas. Once you have them, find the VP of IT or CIO at each company. Finally, run a bulk enrichment to get their verified work emails."

Execution Steps:

1. ChatGPT calls contact_out_companies_search with parameters industry="Healthcare", location="Texas", and size="51-200".
2. The model extracts the domains/names of the returned companies.
3. ChatGPT calls contact_out_people_search_decision_makers iteratively or batches queries using the domains and title="VP of IT" or title="CIO".
4. The model extracts the resulting LinkedIn URLs.
5. ChatGPT calls contact_out_contacts_bulk_enrich passing the array of LinkedIn URLs to retrieve contact data efficiently.
6. The LLM formats the final list of verified prospects into a markdown table for the user.

sequenceDiagram
    participant User
    participant ChatGPT
    participant Truto as Truto MCP
    participant ContactOut as ContactOut API

    User->>ChatGPT: "Find healthcare targets..."
    ChatGPT->>Truto: call tool `contact_out_companies_search`
    Truto->>ContactOut: GET /v2/companies/search
    ContactOut-->>Truto: JSON response (companies)
    Truto-->>ChatGPT: Parsed schema
    
    ChatGPT->>Truto: call tool `contact_out_people_search_decision_makers`
    Truto->>ContactOut: GET /v2/people/decision_makers
    ContactOut-->>Truto: JSON response (LinkedIn URLs)
    Truto-->>ChatGPT: Parsed schema

    ChatGPT->>Truto: call tool `contact_out_contacts_bulk_enrich`
    Truto->>ContactOut: POST /v1/contacts/bulk_enrich
    ContactOut-->>Truto: JSON response (Emails)
    Truto-->>ChatGPT: Final enriched data
    ChatGPT-->>User: Markdown Table of Prospects

Scenario 2: List Cleaning and Asynchronous Verification

A marketing operations manager has a raw CSV of emails from a recent webinar and needs to verify their deliverability before launching a campaign to protect their sender reputation.

"I have a list of 85 emails from yesterday's event. Submit them to ContactOut for bulk email verification. Wait a few seconds, then fetch the results. Filter out any emails marked as 'invalid' or 'disposable' and give me the clean list."

Execution Steps:

1. ChatGPT calls create_a_contact_out_email_verification_job passing the array of email strings in the body.
2. The API returns a status (e.g., QUEUED) and a job_id.
3. ChatGPT pauses, then calls get_single_contact_out_email_verification_job_by_id using the returned ID.
4. If the status is not DONE, the LLM infers it must try again. Once DONE, it parses the result map.
5. ChatGPT cross-references the map, stripping out any addresses flagged as invalid or disposable.
6. The model outputs the sanitized list ready for campaign import.

Security and Access Control

When exposing a credit-heavy API like ContactOut to an autonomous model, securing the connection is non-negotiable. Truto provides multiple layers of control at the MCP server level:

• Method Filtering: Limit the server strictly to non-destructive operations. Passing methods: ["read"] during server creation ensures the LLM can only query data, never execute bulk modifications or spend credits via POST if restricted.
• Tag Filtering: Restrict tool discovery to specific domains. Using tags: ["verification"] ensures the LLM only sees tools related to email verification, completely hiding the broader search and enrichment endpoints.
• API Token Authentication: By setting require_api_token_auth: true, possession of the MCP URL alone is insufficient. The client (e.g., a custom LangChain wrapper rather than standard ChatGPT) must pass a valid Truto API token in the Authorization header.
• Time-To-Live (TTL): Pass an expires_at ISO datetime when generating the server. Truto uses Cloudflare KV and Durable Objects to automatically destroy the server token when time expires, ideal for short-lived agent sessions.

Strategic Architecture for Prospecting Agents

Connecting ContactOut to ChatGPT transforms the LLM from a passive text generator into an active, outbound pipeline engine. By utilizing Truto's dynamic MCP server generation, you bypass the massive engineering overhead of maintaining API schemas, managing authentication tokens, and normalizing nested JSON-RPC payloads.

Instead of fighting with rate limits and asynchronous polling architecture in your own middleware, your engineering team can focus entirely on prompt engineering, agent orchestration, and defining the specific business logic that turns raw ContactOut data into closed-won revenue.