Connect Campaign Monitor to ChatGPT: Run Email Campaigns and Lists

If you need to connect Campaign Monitor to ChatGPT to automate email marketing workflows, manage subscriber lists, or analyze campaign performance, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Campaign Monitor'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 Campaign Monitor to Claude or explore our broader architectural overview on connecting Campaign Monitor to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise email marketing platform requires strict constraints. You must handle complex payload requirements, manage nested client-level data hierarchies, and ensure the AI cannot accidentally blast unapproved campaigns to millions of users. Building custom tool definitions for every possible Campaign Monitor operation is a massive drain on engineering resources.

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

The Engineering Reality of the Campaign Monitor API

A custom MCP server is essentially a self-hosted integration middleware. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Campaign Monitor's specific API design patterns requires significant domain knowledge.

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

The Mandatory Client-Level Scope

Unlike standard SaaS platforms where an API key gives you flat access to "all campaigns" or "all subscribers," Campaign Monitor utilizes an agency-style data model. Almost every resource (lists, segments, templates, campaigns) is scoped to a specific ClientID.

If an LLM wants to list subscriber segments, it cannot just call GET /api/v3.3/segments.json. It must first fetch the clients associated with the account, extract the correct ClientID, and then call GET /api/v3.3/clients/{clientid}/segments.json. If you hardcode tools without handling this hierarchical dependency, your LLM will hallucinate invalid API paths or fail with missing required parameter errors.

Custom Field Complexities on Subscriber Lists

Campaign Monitor allows users to define highly specific custom fields for their subscriber lists. When writing to the API, these fields are not a simple key-value map. They require specific data typing (DataType), visibility settings (VisibleInPreferenceCenter), and predefined Options if the field is a MultiSelectOne or MultiSelectMany type.

Building an MCP tool to manage custom fields means your server must dynamically map the LLM's natural language requests into these rigid configuration objects. If an LLM attempts to add an option to a multi-select field without explicitly defining the KeepExistingOptions boolean, it could inadvertently wipe out all existing subscriber segmentation data.

The Campaign Draft-to-Send Lifecycle

Sending an email in Campaign Monitor is not a single API call. It is a multi-step state machine. A campaign must be created as a draft (create_a_campaign_monitor_campaign), optionally previewed via test emails (campaign_monitor_campaigns_send_preview), and finally scheduled for delivery (campaign_monitor_campaigns_send). Each state transition requires a different endpoint and payload structure. An LLM must be given discrete, well-documented tools for each step, along with explicit instructions on the required order of operations.

Creating the Campaign Monitor MCP Server

Truto eliminates the need to build tool schemas by dynamically generating them from the integration's underlying documentation and resource configurations. You can scope an MCP server to a specific Campaign Monitor account and selectively expose endpoints.

Here are the two ways to generate a Campaign Monitor MCP server using Truto.

Method 1: Via the Truto UI

For administrators and non-developers, the Truto dashboard provides a direct interface for generating MCP servers:

1. Log in to your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Campaign Monitor account (or connect a new one via the OAuth flow).
3. Click the MCP Servers tab on the account details page.
4. Click Create MCP Server.
5. Select your desired configuration. For example, you might restrict the server to only read methods to prevent accidental sends, or filter by tags like campaigns and lists.
6. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For developers integrating MCP server generation into their own application workflows, you can programmatically create a server using the Truto API. This requires your Truto API token and the integrated_account_id of the connected Campaign Monitor instance.

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": "Marketing Agent MCP",
    "config": {
      "methods": ["read", "write"],
      "tags": ["campaigns", "lists", "subscribers"]
    }
  }'

The API will return a JSON object containing the secure url.

{
  "id": "mcp_8f7e6d5c4b",
  "name": "Marketing Agent MCP",
  "config": { 
    "methods": ["read", "write"], 
    "tags": ["campaigns", "lists", "subscribers"] 
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0"
}

This URL is all the LLM client needs to discover tools, route requests, and handle Campaign Monitor authentication seamlessly.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP server URL, you must register it with your ChatGPT environment. You can do this through the ChatGPT user interface or via a local configuration file for programmatic agent setups.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts with Developer mode enabled:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is toggled on.
3. Scroll down to the MCP servers / Custom connectors section and click Add.
4. Enter a recognizable name (e.g., "Campaign Monitor by Truto").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately ping the server, execute the MCP handshake, and populate its context window with the available Campaign Monitor tools.

Method B: Via Manual Config File (JSON)

If you are running a custom desktop agent, Claude Desktop, or a local MCP proxy, you can register the server using a standard JSON configuration. Truto's endpoint natively supports Server-Sent Events (SSE).

Add the following block to your MCP configuration file (typically mcp_config.json or claude_desktop_config.json):

{
  "mcpServers": {
    "campaign-monitor": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0"
      ]
    }
  }
}

Restart your agent client to initialize the connection.

Hero Tools for Campaign Monitor

Truto automatically generates highly descriptive, snake_case tools based on the Campaign Monitor API schema. By parsing documentation records, Truto injects explicit schema instructions - such as telling the LLM to pass pagination cursors back unmodified - ensuring the model understands how to interact with the API correctly.

Here are the highest-leverage tools available for Campaign Monitor workflows.

list_all_campaign_monitor_clients

Because almost all Campaign Monitor resources require a client_id, this tool is the mandatory starting point for any agentic workflow. It returns a list of clients under the account, allowing the LLM to map a human-readable company name to the necessary system ID.

"I need to send an email for the 'Acme Corp' client. List all clients in the account, find the ID for Acme Corp, and save it for the next steps."

create_a_campaign_monitor_list

This tool allows the agent to build new subscriber segments on the fly. It requires the client_id, a Title, and an UnsubscribeSetting (which the schema restricts to valid enum values like AllClientLists or OnlyThisList).

"Create a new subscriber list called 'Q4 Webinar Attendees' for the Acme Corp client. Set the unsubscribe setting so that if they opt out, they only opt out of this specific list, not the whole account."

create_a_campaign_monitor_campaign

This is the core tool for generating email drafts. It accepts raw HTML, subject lines, and sender details. The LLM can dynamically write the HTML content, inject it into the payload, and target it at specific ListIDs or SegmentIDs.

"Draft a new campaign for the Acme Corp client called 'October Newsletter'. The subject line should be 'Your Monthly Tech Update'. Write a brief, professional HTML email body welcoming users to October, and attach it to the Q4 Webinar Attendees list ID."

campaign_monitor_campaigns_send_preview

Before executing a massive mail blast, an agent should always trigger a test email. This tool sends the drafted campaign to a specified list of internal preview recipients, automatically populating personalization tags with fallback values.

"Take the draft campaign ID we just created and send a preview email to marketing-approval@acmecorp.com so the team can review the rendering."

campaign_monitor_campaigns_send

This tool transitions a draft campaign into an active send state. It can schedule the email for immediate delivery or a future timestamp, and requires a confirmation email address to notify the user when the blast is complete.

"The preview was approved. Schedule the October Newsletter campaign to send immediately, and send the delivery confirmation receipt to admin@acmecorp.com."

campaign_monitor_campaigns_summary

Once a campaign is sent, this tool retrieves the high-level engagement metrics. It returns aggregated counts for opens, unique opens, clicks, unsubscribes, and spam complaints.

"Fetch the performance summary for the 'September Update' campaign. Calculate the open rate and click-to-open rate based on the total recipients, and summarize the results."

To view the complete inventory of available tools, including detailed schema requirements for segments, templates, transactional emails, and journey management, visit the Campaign Monitor integration page.

Workflows in Action

Individual tool calls are useful, but MCP servers unlock their true value when an LLM chains multiple tools together to accomplish complex, multi-step workflows. Here are two real-world examples of how ChatGPT can orchestrate Campaign Monitor.

Workflow 1: End-to-End Campaign Drafting and Previewing

A marketing manager wants to draft a new promotional email and send a test copy to their internal team without logging into the Campaign Monitor interface.

"Find the client ID for 'Stark Industries'. Once you have it, create a new subscriber list called 'Holiday Promo 2026'. Then, draft a new campaign targeting that list with the subject 'Early Access: Holiday Deals'. Write a 2-paragraph HTML email offering a 20% discount code. Finally, send a preview of that draft to tony@stark.com."

Execution Steps:

1. list_all_campaign_monitor_clients: The agent fetches all clients and extracts the client_id for Stark Industries.
2. create_a_campaign_monitor_list: The agent uses the client_id to generate the 'Holiday Promo 2026' list and captures the returning ListID.
3. create_a_campaign_monitor_campaign: The agent generates the HTML, sets the subject line, applies the client_id and ListIDs, and creates the draft. It captures the new campaign_id.
4. campaign_monitor_campaigns_send_preview: The agent invokes the preview endpoint using the campaign_id and targets the requested email address.

Result: The user receives confirmation in the chat interface that the list is built, the draft is saved, and a test email is sitting in their inbox ready for review.

sequenceDiagram
    participant User
    participant ChatGPT as ChatGPT (MCP Client)
    participant Truto as Truto MCP Server
    participant CampaignMonitor as Campaign Monitor API

    User->>ChatGPT: "Create Holiday Promo list, draft campaign, send preview..."
    
    ChatGPT->>Truto: call list_all_campaign_monitor_clients
    Truto->>CampaignMonitor: GET /api/v3.3/clients.json
    CampaignMonitor-->>Truto: [{ClientID, Name: "Stark Industries"}]
    Truto-->>ChatGPT: ClientID: abc-123

    ChatGPT->>Truto: call create_a_campaign_monitor_list
    Truto->>CampaignMonitor: POST /api/v3.3/clients/abc-123/lists.json
    CampaignMonitor-->>Truto: ListID: list-789
    Truto-->>ChatGPT: Success (ListID: list-789)

    ChatGPT->>Truto: call create_a_campaign_monitor_campaign
    Truto->>CampaignMonitor: POST /api/v3.3/clients/abc-123/campaigns.json
    CampaignMonitor-->>Truto: CampaignID: camp-456
    Truto-->>ChatGPT: Success (CampaignID: camp-456)

    ChatGPT->>Truto: call campaign_monitor_campaigns_send_preview
    Truto->>CampaignMonitor: POST /api/v3.3/campaigns/camp-456/sendpreview.json
    CampaignMonitor-->>Truto: HTTP 200 OK
    Truto-->>ChatGPT: Success

    ChatGPT-->>User: "The list is created, the campaign is drafted, and the preview email has been sent!"

Workflow 2: Post-Campaign Analytics and List Hygiene

A marketing ops lead needs to report on a recent send and clean up their suppression list based on bounces.

"Find the 'September Update' campaign for the Acme Corp client. Fetch the summary stats for it. Then, get a list of all the email addresses that hard bounced on that campaign, and add them to the account's global suppression list so we don't email them again."

Execution Steps:

1. list_all_campaign_monitor_clients: The agent retrieves the Acme Corp client_id.
2. campaign_monitor_campaigns_list_sent: The agent searches the sent campaigns to find the campaign_id matching 'September Update'.
3. campaign_monitor_campaigns_summary: The agent pulls the top-level stats (opens, clicks, total bounced) and presents them to the user.
4. campaign_monitor_campaigns_bounces: The agent fetches the detailed, paginated list of bounced subscribers for that specific campaign, filtering for hard bounces.
5. campaign_monitor_suppression_list_suppress: The agent takes the array of bounced email addresses and posts them to the client's suppression endpoint.

Result: The user gets a concise analytics report in the chat interface, and the account's suppression list is automatically updated without requiring manual CSV exports.

Handling Rate Limits at the Edge

When AI agents execute multi-step workflows or iterate through paginated list data, they can rapidly consume API quotas. It is critical to understand how the infrastructure handles these limits.

Truto does not silently retry, throttle, or apply arbitrary backoff queues to rate limit errors. When the upstream Campaign Monitor API returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the caller (the LLM client).

To ensure the agent has the necessary context to recover gracefully, Truto normalizes the upstream rate limit information into standardized IETF headers on the response:

• ratelimit-limit: The total requests allowed in the current window.
• ratelimit-remaining: The number of requests left.
• ratelimit-reset: The timestamp when the quota refreshes.

Because Truto passes these details through transparently, the caller (or the agent framework) is fully responsible for implementing its own retry or backoff logic based on real-time quota data.

Security and Access Control

Exposing an email marketing platform to an LLM introduces obvious risks. You do not want an AI hallucinating a request that deletes your primary subscriber list or sends a half-finished draft to your entire customer base.

Truto provides several configuration layers at the MCP server level to constrain agent capabilities:

• Method Filtering: Configure the server with config.methods: ["read"] to strictly limit the LLM to get and list operations. This creates a read-only server perfect for analytics gathering, ensuring the AI cannot execute create, update, or delete actions.
• Tag Filtering: Restrict access to specific functional areas using config.tags. By configuring tags like ["reports", "analytics"], the LLM will only see tools related to campaign summaries, completely hiding tools related to list creation or template editing.
• Additional Authentication: Enable config.require_api_token_auth to enforce a dual-layer security model. In addition to possessing the MCP server URL, the client must pass a valid Truto API token in the Authorization header, ensuring only authenticated systems can invoke tools.
• Time-to-Live (TTL): Set an expires_at ISO datetime when generating the server. Once the timestamp is reached, Truto automatically destroys the token in the distributed KV store and schedules a durable cleanup task, terminating the LLM's access permanently.

Stop manually writing integration scripts to pull Campaign Monitor data. By generating an MCP server through Truto, you give ChatGPT secure, structured, and compliant access to your marketing data in minutes, transforming point-to-point API calls into autonomous agentic workflows.