---
title: "Connect Interseller to ChatGPT: Manage Campaigns and Track Results"
slug: connect-interseller-to-chatgpt-manage-campaigns-and-track-results
date: 2026-06-23
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Interseller to ChatGPT using a managed MCP server. Automate outreach workflows, verify prospect emails, and manage campaigns without writing custom integration code."
tldr: "Connect Interseller to ChatGPT via Truto's managed MCP server to give AI agents secure access to your outreach campaigns. Automate email validation, step-level reporting, and contact enrichment workflows."
canonical: https://truto.one/blog/connect-interseller-to-chatgpt-manage-campaigns-and-track-results/
---

# Connect Interseller to ChatGPT: Manage Campaigns and Track Results


You want to connect Interseller to ChatGPT so your AI agents can autonomously manage outreach campaigns, verify prospect emails, and compile deliverability reports. If your team uses Claude, check out our guide on [connecting Interseller to Claude](https://truto.one/connect-interseller-to-claude-lookup-leads-and-verify-pro-emails/) or explore our broader architectural overview on [connecting Interseller to AI Agents](https://truto.one/connect-interseller-to-ai-agents-automate-outreach-and-team-reports/).

Sales development and outreach execution represent some of the highest-leverage workflows for an AI agent. Giving a Large Language Model (LLM) read and write access to your Interseller instance allows it to bridge the gap between intent and execution. However, integrating a custom SaaS tool natively into ChatGPT is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/), or you use a managed infrastructure layer that handles the boilerplate for you.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Interseller, connect it [natively to ChatGPT](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex outreach workflows using natural language.

## The Engineering Reality of the Interseller API

A custom [MCP server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) is a self-hosted integration layer that translates an LLM's JSON-RPC tool calls into REST API requests. While Anthropic's open standard provides a predictable way for models to discover tools, implementing it against vendor APIs like Interseller brings unique operational hurdles.

If you decide to build a custom MCP server for Interseller, you are responsible for the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Interseller:

### Destructive Blacklist Updates
Interseller's domain and email blacklist system does not support additive operations. The endpoint to update the blacklist requires you to pass the *entire* list of domains and emails. It wipes the existing configuration and substitutes it with the provided array. If an LLM attempts to "add a domain to the blacklist" by merely sending the new domain to this endpoint, it will inadvertently delete your company's entire historical suppression list. Your MCP server must explicitly force the LLM to call the `GET` endpoint first, append the new domain to the array locally, and then execute the `PUT` operation with the complete dataset.

### Step-Level Statistical Isolation
Campaign reporting in Interseller is highly granular, but it does not aggregate exactly how an LLM expects. Step-level statistics (e.g., total, sent, viewed, replied) apply strictly per-step. If a prospect replies to the second step of a sequence, that reply does not retroactively count against the first step. If an LLM is asked to "summarize the total replies for the campaign," and it iterates through step statistics without understanding this isolation, it may present disjointed or seemingly conflicting conversion rates.

### Real-Time MX Validation Latency
Interseller provides endpoints to validate email addresses in real-time by performing MX lookups and SMTP handshakes. This is a powerful feature, but network-level validation introduces variable latency. If an LLM attempts to validate a large batch of emails sequentially in a single session, the cumulative latency will exceed the LLM framework's timeout window, resulting in a dropped connection and a hallucinated response.

### Rate Limits and 429 Handling
Interseller enforces strict rate limits to prevent abuse of their verification and outreach infrastructure. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Interseller API returns an HTTP 429, Truto passes that error straight to the caller. Truto normalizes the upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. Your AI agent is entirely responsible for implementing its own exponential backoff logic when iterating over large contact lists.

## Generating the Interseller MCP Server

Rather than hand-coding tool definitions for every Interseller endpoint, Truto generates them dynamically based on the integration's documented API resources. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM only accesses curated, AI-ready operations.

Each MCP server is scoped to a single integrated account. The generated URL contains a cryptographic token that handles routing and authentication natively.

### Method 1: Via the Truto UI

For teams managing integrations manually, you can generate a server directly from the dashboard.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Interseller instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select the desired configuration (name, allowed methods, tags, and optional expiry).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the API

For platform engineers building multi-tenant AI products, you can provision servers programmatically.

Make a POST request to `/integrated-account/:id/mcp`. The API validates the configuration, hashes the token via HMAC for secure KV storage, and returns a ready-to-use URL.

```bash
curl -X POST https://api.truto.one/integrated-account/acct_abc123/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Interseller Outreach Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["campaigns", "contacts"]
    }
  }'
```

```json
{
  "id": "mcp_xyz789",
  "name": "Interseller Outreach Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting Interseller to ChatGPT

Once you have your Truto MCP URL, you can connect it to your LLM client. Since the URL encapsulates the integrated account context, no additional authentication configuration is required on the client side (unless you explicitly enforce it).

### Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Enterprise, or Education, you can add the server natively.

1. In ChatGPT, navigate to **Settings → Apps → Advanced settings**.
2. Enable **Developer mode**.
3. Under **MCP servers / Custom connectors**, click add a new server.
4. Set the **Name** to "Interseller".
5. Paste your Truto MCP URL into the **Server URL** field.
6. Click **Save**.

ChatGPT will immediately run the `initialize` and `tools/list` JSON-RPC handshake to discover the available Interseller tools.

### Method B: Via Manual Config File

If you are deploying ChatGPT locally via a desktop client or integrating into a framework like Cursor or Claude Desktop, you must configure the MCP server using Server-Sent Events (SSE).

Update your MCP configuration file (typically `mcp.json` or `claude_desktop_config.json` depending on the client) with the following block:

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

## Hero Tools for Interseller

Truto automatically maps Interseller's API into a flat JSON-RPC namespace. Query parameters and body parameters are intelligently routed by the Truto Proxy API Handler based on the schema definition. Here are the 6 most powerful hero tools for automating Interseller workflows.

### 1. list_all_interseller_campaigns
Retrieves a list of all Interseller campaigns. This is the foundational tool for auditing active sequences, retrieving campaign IDs for deeper analysis, and checking high-level status.

**Usage note:** The LLM will automatically receive pagination cursors (`next_cursor`). The generated tool description explicitly instructs the model to pass this cursor back unchanged to traverse large campaign lists.

> "List all active Interseller campaigns and give me a summary table of their titles and creation dates."

### 2. get_single_interseller_campaign_step_stat_by_id
Retrieves detailed, step-level conversion metrics for a specific campaign. Returns an object keyed by step index containing sent, viewed, visited, and replied counts.

**Usage note:** This is critical for A/B testing analysis. Because statistics are isolated per-step, the LLM must use this tool to determine where prospect drop-off is occurring within a multi-touch sequence.

> "Fetch the step statistics for campaign ID 'cmp_987' and tell me which step has the highest reply rate."

### 3. create_a_interseller_email_personal_query
Executes a deep lookup to discover personal email addresses for a prospect based on fragmented identity data (e.g., name, company, LinkedIn URL, or GitHub URL).

**Usage note:** This tool requires at minimum one strong identifier. It returns an array of discovered email addresses. It is incredibly useful for enriching stale CRM leads before routing them to an active sequence.

> "Find the personal email addresses for the prospect with the LinkedIn URL 'linkedin.com/in/johndoe'."

### 4. create_a_interseller_email
Performs real-time validation on an email address. This tool executes MX testing, checks for disposable domains, and verifies SMTP reachability.

**Usage note:** The verdict returned will explicitly state if the email is safe to send to. Because this relies on external network operations, the LLM should be instructed to handle this tool sequentially rather than attempting massive concurrent batches to avoid timeouts.

> "Validate the email 'steve@interseller.io'. Check if the MX records are reachable and if it's a disposable address."

### 5. update_a_interseller_team_blacklist_by_id
Replaces the entire team blacklist with a new array of domains and email addresses. 

**Usage note:** As warned in the engineering reality section, this is a destructive replacement. A robust agent prompt must instruct the model to always execute `get_single_interseller_team_blacklist_by_id` first to maintain historical data.

> "Get the current Interseller blacklist, add 'competitor.com' to the array, and update the blacklist with the combined list."

### 6. list_all_interseller_contact_activities
Fetches the complete historical timeline of a contact's interactions, including messages sent, opens, replies, and meetings booked.

**Usage note:** This is the primary tool for generating context before an SDR takes over a manual reply. It provides the exact chronological sequence of events for a given `contact_id`.

> "Pull the activity history for contact ID 'cnt_456' and summarize their interactions over the last two weeks."

To view the complete inventory of available Interseller tools, including payload schemas and custom field handlers, visit the [Interseller integration page](https://truto.one/integrations/detail/interseller).

## Workflows in Action

When you combine these isolated tools into a multi-step execution plan, your AI agent transforms from a simple data fetcher into an autonomous sales operations engine. Here are two real-world workflows.

### Workflow 1: Prospect Enrichment and Deliverability Validation

SDRs waste hours manually guessing email permutations and running them through third-party validators. You can offload this entirely to ChatGPT.

> "I have a target prospect: Sarah Jenkins at Acme Corp (linkedin.com/in/sarahjenkins). Find her professional email, validate it to ensure it won't bounce, and tell me if she is safe to contact."

**Execution Steps:**
1. The agent calls `list_all_interseller_emails`, passing `name: "Sarah Jenkins"` and `url: "acme.com"`.
2. The agent parses the returned array of email permutations and selects the highest-ranked result based on the pattern match.
3. The agent calls `create_a_interseller_email` passing the selected email to run a real-time MX and SMTP handshake.
4. The agent analyzes the `verdict` and `valid_mx_records` boolean in the response.
5. The user receives a finalized, verified email address with confirmation that the SMTP server is actively accepting mail.

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

    User->>Agent: "Find and validate Sarah's email"
    Agent->>MCP: tools/call (list_all_interseller_emails)
    MCP->>Interseller: GET /emails/search
    Interseller-->>MCP: ["s.jenkins@acme.com"]
    MCP-->>Agent: JSON Result
    Agent->>MCP: tools/call (create_a_interseller_email)
    MCP->>Interseller: POST /emails (MX Check)
    Interseller-->>MCP: { verdict: "safe" }
    MCP-->>Agent: JSON Result
    Agent-->>User: "Email found and validated as safe."
```

### Workflow 2: Automated Campaign Triage

Sales managers need to quickly identify underperforming campaigns to prevent burning through leads with bad copy.

> "Review all active Interseller campaigns. Find the one with the lowest reply rate on step 1, list its title, and fetch the activity history of the most recently contacted lead in that campaign to see what went wrong."

**Execution Steps:**
1. The agent calls `list_all_interseller_campaigns` passing the `active: true` query parameter.
2. For each campaign ID returned, the agent calls `get_single_interseller_campaign_step_stat_by_id`.
3. The agent calculates the reply rate mathematically for `step_index: "0"` across all campaigns and identifies the worst performer.
4. The agent extracts a recent `contact_id` associated with that specific campaign (using internal logic or a subsequent contact list call).
5. The agent calls `list_all_interseller_contact_activities` to read the exact timeline of events for that user.
6. The user receives a diagnostic report pinpointing the failing campaign and a timeline showing that leads are opening the email but ignoring the call-to-action.

## Security and Access Control

Exposing an outreach engine to an autonomous LLM requires strict boundaries. Truto provides four layers of security to lock down your Interseller MCP server at the infrastructure level.

*   **Method Filtering (`config.methods`):** You can restrict an MCP server to specific operations. Setting the filter to `["read"]` ensures the LLM can query campaign stats and validate emails, but physically cannot update campaigns or modify the blacklist.
*   **Tag Filtering (`config.tags`):** You can scope tools by functional domain. If you only want the LLM to handle contact enrichment, you can filter by specific integration resource tags, completely hiding campaign-mutation endpoints from the model's context.
*   **Require API Token Auth (`require_api_token_auth`):** By default, possessing the MCP URL grants access. Enabling this flag forces the client to pass a valid Truto API token in the `Authorization` header, validating identity before the KV token is even checked.
*   **Time-to-Live (`expires_at`):** You can generate ephemeral MCP servers for temporary workflows. The system schedules a Cloudflare Durable Object alarm to automatically purge the database record and KV storage at the exact expiration time, leaving zero stale credentials.

## Stop Building Boilerplate

Writing JSON-RPC 2.0 handlers, managing OAuth state, parsing paginated REST responses, and mapping complex nested schemas is not a strategic use of your engineering team's time. Interseller's API is powerful, but its nuances require dedicated infrastructure to interface safely with AI agents.

Truto’s dynamically generated MCP servers give your LLMs raw, structured access to Interseller's entire operational surface area in seconds. You dictate the access rules; we handle the protocol, the proxying, and the infrastructure.

> Stop maintaining custom integration code. Generate secure, production-ready MCP servers for your AI agents today.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)