---
title: "Connect Interseller to ChatGPT: Manage Outreach and Prospect Data"
slug: connect-interseller-to-chatgpt-manage-outreach-and-find-prospect-data
date: 2026-06-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect Interseller to ChatGPT. Automate email lookups, sequence management, and campaign reporting using natural language."
tldr: "Connect Interseller to ChatGPT using a managed MCP server to automate email validation, prospect lookups, and campaign management. This guide covers UI and API setup, tool calling, and security controls."
canonical: https://truto.one/blog/connect-interseller-to-chatgpt-manage-outreach-and-find-prospect-data/
---

# Connect Interseller to ChatGPT: Manage Outreach and Prospect Data


If your sales or revenue operations team needs to connect Interseller to ChatGPT to automate email lookups, manage outreach sequences, or report on campaign performance, 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 translation layer between ChatGPT's tool calls and Interseller'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. 

If your team uses Claude, check out our guide on [connecting Interseller to Claude](https://truto.one/connect-interseller-to-claude-control-sequences-and-analyze-reports/) or explore our broader architectural overview on [connecting Interseller to AI Agents](https://truto.one/connect-interseller-to-ai-agents-automate-outreach-and-verify-emails/).

Giving a Large Language Model (LLM) read and write access to a high-volume outreach platform like Interseller is an engineering challenge. You have to map massive JSON schemas to MCP tool definitions, handle nested campaign statistics, and carefully manage rate limits to ensure your automated outreach doesn't get throttled. Every time Interseller updates an endpoint, 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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide) for Interseller, connect it natively to ChatGPT, and execute complex workflows using natural language.

## The Engineering Reality of the Interseller 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 vendor APIs is historically painful. If you decide to build a custom MCP server for Interseller, you own the entire API lifecycle. 

Here are the specific integration challenges that break standard CRUD assumptions when working with Interseller:

**Destructive Array Updates**
The Interseller API contains endpoints that do not behave additively. For example, updating the team blacklist (`update_a_interseller_team_blacklist_by_id`) requires passing an array of domains and emails. This operation wipes the existing blacklist and substitutes it entirely with the provided array. If an AI agent attempts to "add" a domain to the blacklist without first fetching the existing state and appending to it, it will inadvertently clear your entire organizational blocklist. Your MCP layer must explicitly define these operational constraints in the tool description to prevent catastrophic data loss.

**Nested Step-Level Statistics**
When querying campaign metrics, standard LLMs expect flat, aggregate data objects. However, Interseller separates campaign statistics from step-level statistics. The `get_single_interseller_campaign_step_stat_by_id` endpoint returns an object keyed dynamically by step index (e.g., "0", "1"). Furthermore, these metrics are strictly per-step - a reply to step 2 does not retroactively count against step 1. If your custom server does not map these dynamic keys into a predictable JSON schema, ChatGPT will hallucinate the performance of your individual sequence steps.

**Complex MX Validation States**
Prospect discovery requires real-time email validation. When verifying an email via `create_a_interseller_email`, the API performs real-time MX testing. The response is not a simple boolean; it includes a `verdict`, the `server` details, and a nested details object containing flags like `valid_mx_records`, `is_disposable`, and `is_free_service`. Your MCP server must properly expose this nested schema so the LLM can make intelligent decisions - for example, instructing the agent to drop prospects using disposable email addresses before adding them to a campaign.

**Strict Rate Limiting and 429 Errors**
Outreach platforms inherently enforce strict rate limits to prevent spam and abuse. When an LLM attempts to iterate through hundreds of contacts, it will hit these limits. **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the Interseller API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller - your AI agent or orchestrator - is entirely responsible for implementing the retry and exponential backoff logic based on these headers.

## Creating an Interseller MCP Server

Instead of building a JSON-RPC 2.0 handler from scratch, you can use Truto to dynamically generate an MCP server scoped to a specific Interseller account. Truto derives the tool definitions directly from the integration's documented endpoints, ensuring the LLM always has the correct query and body schemas.

You can create this MCP server using the Truto user interface or programmatically via the REST API.

### Method 1: Via the Truto UI

This method is ideal for one-off internal tools or rapid prototyping.

1. Log in to your Truto dashboard and navigate to the integrated account page for your connected Interseller instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server parameters (name, allowed methods, allowed tags, and expiration date).
5. Click Save. The dashboard will display a secure MCP server URL. Copy this URL - it contains the cryptographic token required for authentication.

### Method 2: Via the Truto API

For production use cases where you need to provision MCP servers dynamically for your end-users, you can create them via the API. This approach validates the configuration, generates a hashed token, and schedules an automatic cleanup alarm if an expiration date is provided.

Make a `POST` request to the `/integrated-account/:id/mcp` endpoint:

```typescript
const response = await fetch('https://api.truto.one/integrated-account/<INTERSELLER_ACCOUNT_ID>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Interseller Outreach Agent",
    config: {
      methods: ["read", "write"], // Filter out custom endpoints if desired
      tags: ["crm", "campaigns"]
    },
    expires_at: "2026-12-31T23:59:59Z" // Optional: auto-revoke access
  })
});

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

The returned URL is fully self-contained. It points directly to the JSON-RPC 2.0 router that handles MCP `initialize`, `tools/list`, and `tools/call` requests.

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP server URL, you must register it with your ChatGPT environment. The client will handle the standard MCP handshake, requesting the available capabilities and tool schemas.

### Method A: Via the ChatGPT UI (Custom Connectors)

If you are using ChatGPT Enterprise, Pro, or Team accounts with Developer Mode enabled, you can connect the server directly through the interface.

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Ensure **Developer mode** is toggled on.
3. Under the MCP servers or [Custom connectors](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto) section, click **Add new server**.
4. Enter a descriptive name (e.g., "Interseller Operations").
5. Paste the Truto MCP server URL into the **Server URL** field.
6. Click **Save**.

ChatGPT will immediately ping the server, list the available Interseller tools, and store their schemas in its context window.

### Method B: Via Manual Configuration File (Local Agents)

If you are running a local instance of Claude Desktop, Cursor, or a custom LangGraph framework that relies on standard MCP configuration files, you can wrap the Truto URL using the official Server-Sent Events (SSE) transport adapter.

Add the following block to your `mcp_config.json` file:

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

Restart your local client. It will initialize the SSE connection and pull the dynamically generated tools.

## Hero Tools for Interseller

Truto dynamically translates Interseller's REST API into an array of strictly typed MCP tools. The query and body parameters share a flat input namespace, which the Truto router seamlessly splits and maps to the underlying integration based on the documented schemas. 

Here are the most critical tools for automating outreach and prospecting.

### list_all_interseller_campaigns

This tool retrieves all active and archived Interseller sequences. It allows the LLM to search campaigns by title or filter by status to audit the organization's outbound strategy.

**Contextual Usage Notes:** The returned payload includes the `id`, `title`, `active` status, and `has_steps` boolean. Use this as the entry point whenever an agent needs to discover a campaign ID for further reporting or editing.

> "Fetch all active Interseller campaigns related to the 'Q3 Enterprise Expansion' initiative and summarize their current status."

### list_all_interseller_emails

This tool looks up professional email addresses for a prospect based on their name and company domain. It returns ranked results containing the email handle, pattern, and immediate MX validation flags.

**Contextual Usage Notes:** This is essential for automated SDR workflows. The AI agent must provide the `name` and `url` (domain). The response includes an array of potential matches. Instruct your LLM to always evaluate the `verdict` field before proceeding.

> "Find the professional email address for Jane Doe at acmecorp.com using Interseller, and return only the top-ranked result that passes MX validation."

### create_a_interseller_email

This endpoint performs a real-time validation test on an existing email address. It runs MX testing, checks for disposable domains, and verifies format.

**Contextual Usage Notes:** Use this tool to scrub your lead lists. Because this triggers an active network check on the target mail server, execution can take slightly longer. The LLM should evaluate `valid_mx_records`, `mx_reachable`, and `is_disposable` to determine lead quality.

> "Validate the email address john.smith@startup.io in Interseller. If it is marked as a disposable service or fails MX reachability, flag it for deletion."

### get_single_interseller_campaign_step_stat_by_id

This tool extracts deep, step-by-step performance metrics for a specific sequence. It returns an object keyed by the step index, providing exact counts for sent, viewed, clicked, and replied events per step.

**Contextual Usage Notes:** This solves the "aggregate reporting" problem. A reply to an email in step 2 is recorded under step 2's stats, not step 1's. This tool gives the AI the granular data needed to recommend A/B test adjustments to specific emails in the sequence.

> "Get the step-level statistics for the campaign ID 9a8b7c6d. Identify which step has the highest drop-off rate between 'viewed' and 'replied'."

### update_a_interseller_team_blacklist_by_id

This tool allows the agent to modify the organizational blacklist, preventing emails from being sent to specific domains or individuals.

**Contextual Usage Notes:** As noted in the Engineering Reality section, this operation is destructive. The `blacklist` parameter must contain the complete array of all restricted entities. You must explicitly prompt your agent to read the existing blacklist first via `get_single_interseller_team_blacklist_by_id`, append the new domain, and then execute this update.

> "Fetch the current Interseller team blacklist, append 'competitor.com' to the array, and then use the update tool to apply the new complete list."

### create_a_interseller_email_personal_query

This tool discovers personal email addresses (e.g., gmail.com, outlook.com) using alternative identifiers like a LinkedIn URL, GitHub URL, or phone number.

**Contextual Usage Notes:** Highly useful for developer relations or recruiting workflows. At a minimum, the LLM must supply either a specific social URL, a phone number, or a complex object containing the name, company, title, and location.

> "Query Interseller to find the personal email address associated with the LinkedIn profile URL https://linkedin.com/in/johndoe123."

For the full list of supported operations and exact JSON schema definitions, check out the [Interseller integration page](https://truto.one/integrations/detail/interseller).

## Workflows in Action

Connecting tools to an LLM is only useful if the agent can orchestrate complex, multi-step operations. Here is how specific revenue personas leverage the Interseller MCP server.

### 1. SDR/BDR: Prospect Discovery and Validation

When a BDR identifies a target account, they need to find the decision-maker, guess their email, validate it, and push it to a sequence. An AI agent handles this entire flow autonomously.

> "Find the email address for the VP of Engineering at TechGlobal (techglobal.com). Validate the result. If it passes MX testing and is not a catch-all, output the final email."

```mermaid
sequenceDiagram
    participant User
    participant ChatGPT as ChatGPT Agent
    participant TrutoMCP as Truto MCP Server
    participant Interseller as Interseller API

    User->>ChatGPT: "Find and validate email for VP at TechGlobal..."
    ChatGPT->>TrutoMCP: Call list_all_interseller_emails <br>(name: "VP Engineering", url: "techglobal.com")
    TrutoMCP->>Interseller: GET /emails/search
    Interseller-->>TrutoMCP: Returns ranked email patterns
    TrutoMCP-->>ChatGPT: Parsed JSON array
    ChatGPT->>TrutoMCP: Call create_a_interseller_email <br>(email: "vp@techglobal.com")
    TrutoMCP->>Interseller: POST /emails/verify
    Interseller-->>TrutoMCP: Verdict: valid, mx_reachable: true
    TrutoMCP-->>ChatGPT: Validation state object
    ChatGPT-->>User: "Found and verified: vp@techglobal.com"
```

**Execution Steps:**
1.  The agent calls `list_all_interseller_emails` passing the domain and target name.
2.  Interseller returns a list of pattern-matched emails based on historical accuracy.
3.  The agent extracts the top-ranked email and passes it to `create_a_interseller_email`.
4.  The server performs real-time SMTP/MX validation.
5.  The agent interprets the `is_disposable` and `valid_mx_records` flags and returns the verified contact to the user.

### 2. RevOps: Campaign Step Performance Audit

Revenue Operations teams must constantly tweak sequences. An AI agent can fetch granular data, compare open-to-reply ratios, and identify bottlenecks in a multi-step sequence.

> "Analyze the 'Outbound Cold 2026' campaign. Check the step-level statistics. Tell me which specific email step is causing the highest bounce rate or lowest reply rate."

```mermaid
sequenceDiagram
    participant User
    participant ChatGPT as ChatGPT Agent
    participant TrutoMCP as Truto MCP Server
    participant Interseller as Interseller API

    User->>ChatGPT: "Analyze 'Outbound Cold 2026' step stats..."
    ChatGPT->>TrutoMCP: Call list_all_interseller_campaigns <br>(search: "Outbound Cold 2026")
    TrutoMCP->>Interseller: GET /campaigns
    Interseller-->>TrutoMCP: Campaign array
    TrutoMCP-->>ChatGPT: Returns campaign ID (e.g., 88a9)
    ChatGPT->>TrutoMCP: Call get_single_interseller_campaign_step_stat_by_id <br>(id: "88a9")
    TrutoMCP->>Interseller: GET /campaigns/88a9/steps/stats
    Interseller-->>TrutoMCP: Nested stats keyed by step index
    TrutoMCP-->>ChatGPT: JSON stats object
    ChatGPT-->>User: "Step 3 has a 12% bounce rate. Step 1 has the highest reply rate at 4%."
```

**Execution Steps:**
1.  The agent searches for the campaign using `list_all_interseller_campaigns` to resolve the human-readable name to a system ID.
2.  Using that ID, the agent calls `get_single_interseller_campaign_step_stat_by_id`.
3.  The agent iterates through the dynamically keyed JSON response (Step 0, Step 1, Step 2).
4.  It calculates the delta between `viewed` and `replied` for each step and returns a comprehensive performance summary.

## Security and Access Control

Exposing your outbound email infrastructure to an autonomous model requires strict guardrails. Truto's MCP architecture provides several layers of control directly embedded in the server configuration:

*   **Method Filtering:** You can restrict the MCP server to read-only operations by setting `config.methods: ["read"]`. This prevents the agent from creating campaigns, modifying blacklists, or sending emails, limiting it to analytics and discovery.
*   **Tag Filtering:** Limit the scope of the server by specific resource tags. For example, using `config.tags: ["campaigns"]` ensures the agent can only interact with sequence definitions and not administrative user settings or webhooks.
*   **API Token Authentication:** By default, possessing the MCP URL grants access. By enabling `require_api_token_auth: true`, the client must also pass a valid Truto API token in the authorization header. This prevents unauthorized execution even if the server URL leaks in logs.
*   **Automatic Expiration:** You can assign an `expires_at` timestamp when generating the server. Once the deadline is reached, the underlying KV store automatically purges the token, and a Durable Object alarm cleans up the database record, instantly revoking the LLM's access.

## Automate Outreach Intelligence

Connecting Interseller to ChatGPT transforms your outbound strategy from manual clicking into an intelligent, conversational workflow. By leveraging a managed MCP server, you eliminate the overhead of writing custom integration code, untangling nested API responses, and maintaining OAuth state.

Your engineers shouldn't be writing retry loops for rate-limited prospecting endpoints. They should be building core product features while managed infrastructure handles the API translation layer.

> Stop hand-coding vendor integrations. Generate secure, fully managed MCP servers for Interseller and 100+ other enterprise platforms in minutes with Truto.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)