---
title: "Connect Lettr to ChatGPT: Manage campaigns and audience marketing"
slug: connect-lettr-to-chatgpt-manage-campaigns-and-audience-marketing
date: 2026-11-13
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to build and configure a managed MCP server to connect Lettr to ChatGPT. Automate audience marketing, email campaigns, and bulk contact management."
tldr: "A technical guide to connecting Lettr to ChatGPT using an auto-generated MCP server. We cover Lettr API quirks, bulk contact creation limits, SparkPost idempotency, and how to execute multi-step campaign workflows via LLM."
canonical: https://truto.one/blog/connect-lettr-to-chatgpt-manage-campaigns-and-audience-marketing/
---

# Connect Lettr to ChatGPT: Manage campaigns and audience marketing


If you need to connect Lettr to ChatGPT to automate audience marketing, orchestrate email campaigns, or manage bulk contact lists, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between ChatGPT's function calls and Lettr's REST API. You can either [build and host this integration infrastructure yourself](https://truto.one/blog/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a managed platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Lettr to Claude](https://truto.one/connect-lettr-to-claude-design-templates-and-automate-delivery/) or explore our broader architectural overview on [connecting Lettr to AI Agents](https://truto.one/connect-lettr-to-ai-agents-sync-contact-data-and-track-engagement/).

Giving a Large Language Model (LLM) read and write access to an email marketing platform is an engineering risk. You have to handle bulk data limits, manage specific transactional transmission headers, and map complex payload structures. Every time Lettr adds a new endpoint or updates a schema, your custom server code must be updated, tested, and redeployed.

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

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Lettr API

Building a custom MCP server means owning the entire integration lifecycle. While the open MCP standard provides a predictable JSON-RPC 2.0 format for models to discover tools, implementing it against Lettr's specific architecture requires understanding its unique constraints. 

If you decide to build a custom Lettr MCP server, here are the specific integration challenges you must architect around:

### Strict Sandbox Write Limitations
Lettr explicitly blocks almost all `write` operations when using sandbox API keys. Endpoints like `POST /api/audience/contacts` or `POST /api/campaigns` will fail if your LLM attempts to use them outside of a production environment. If you build a custom server, you must inject dynamic environment awareness into your MCP tool schemas, or your AI agent will enter a hallucination loop trying to fix HTTP 403 Forbidden errors that are actually environment restrictions.

### Complex Bulk Matrix Constraints
Lettr handles bulk operations via highly specific matrix payloads. For example, the `POST /api/audience/contacts/lists/bulk` endpoint attaches contacts to lists by computing every combination of `contact_ids × list_ids`. Lettr strictly caps this at 1,000 contacts and 50 lists per request. If an LLM attempts to pass an array of 1,500 contacts, the API will reject it. Your integration layer must intercept these payloads, chunk the arrays perfectly, and paginate the bulk requests before forwarding them to Lettr.

### Underlying SparkPost Idempotency Rules
Because Lettr utilizes SparkPost for its core email transmission infrastructure, sending transactional emails requires specific idempotency handling. When an LLM triggers `POST /api/emails`, the server must supply an `Idempotency-Key` header. These keys are namespaced per Lettr API key and retained by SparkPost for exactly 24 hours. If your MCP server fails to handle retries correctly and drops the idempotency key, a simple network timeout could result in your LLM blasting a user with duplicate transactional emails.

## Step 1: Generate a Lettr MCP Server

Truto handles the Lettr API complexity by dynamically [generating tools](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) based on Lettr's endpoint schemas and documentation. You can spin up an MCP server scoped specifically to a single Lettr account in seconds.

First, connect Lettr as an Integrated Account in your Truto dashboard. Once connected, you can generate the MCP server URL in two ways:

### Option A: Via the Truto UI
1. Navigate to the **Integrated Accounts** page in the Truto dashboard.
2. Click on your connected Lettr account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restrict to specific methods like `read` or filter by tags like `campaigns`).
6. Copy the generated MCP server URL. Treat this URL like a secret password - it contains the cryptographic token required for access.

### Option B: Via the API
You can programmatically generate an MCP server for Lettr by passing the `integrated_account_id` to the Truto API. This is ideal for SaaS platforms provisioning agents for their end users.

```bash
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": "Lettr Marketing Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["campaigns", "audience", "emails"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API returns a JSON payload containing the `url` field (e.g., `https://api.truto.one/mcp/<token>`).

## Step 2: Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can plug it directly into your LLM environment. 

### Option A: Via the ChatGPT UI
If you are using ChatGPT (Pro, Plus, Business, Enterprise, or Education accounts), you can add the server directly via the interface:
1. Open ChatGPT and go to **Settings -> Apps -> Advanced settings**.
2. Enable the **Developer mode** toggle.
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. **Name**: Enter a recognizable name (e.g., "Lettr Marketing Engine").
5. **Server URL**: Paste the Truto MCP URL.
6. Click **Save**. ChatGPT will immediately execute an MCP `initialize` handshake and pull the Lettr tool definitions.

### Option B: Via Manual Config File
If you are running a custom AI agent framework, LangChain, or desktop clients that rely on configuration files, you can connect the server using the official MCP SSE transport module.

Add this to your MCP configuration JSON:

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

## Hero Tools for Lettr Automation

Truto [auto-generates dozens of tools](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) for the Lettr integration. Rather than overwhelming the LLM context window with every possible API endpoint, you should filter your MCP server to expose only the tools required for your specific use case. Here are the highest-leverage operations for marketing workflows.

### 1. List Campaigns
**Tool**: `list_all_lettr_campaigns`
This tool retrieves a paginated list of campaigns for the authenticated team. Crucially, Lettr embeds engagement stats directly in the response, allowing your LLM to immediately see open rates, click rates, and bounce data without making secondary requests.

> "Fetch the latest Lettr campaigns and summarize the engagement stats. Tell me which campaign had the highest open rate this week."

### 2. Create a Draft Campaign
**Tool**: `create_a_lettr_campaign`
This operation creates a draft campaign. The LLM can supply content via raw HTML (`html_content`) or use a pre-existing `template_id`. The LLM must ensure the specified sender email domain is verified in the Lettr account.

> "Draft a new Lettr campaign named 'Summer Product Update'. Use the template ID 88492 and set the sender to updates@ourdomain.com."

### 3. Send a Campaign
**Tool**: `lettr_campaigns_send`
This tool immediately dispatches a draft campaign by its ID. Lettr transitions the campaign status to `preparing` and handles the send asynchronously. The campaign must have a subject, sender email, and content to succeed.

> "Send the 'Summer Product Update' campaign draft we just created. Confirm once the dispatch command has been successfully submitted."

### 4. Bulk Create Contacts
**Tool**: `lettr_audience_contacts_bulk_create`
This endpoint creates up to 1,000 contacts in a single request. The LLM can pass detailed properties, lists, and topics for each contact array object, preventing the need for iterative, slow REST calls.

> "Take this list of 45 webinar attendees and bulk import them into Lettr as new audience contacts."

### 5. Bulk Subscribe to Topics
**Tool**: `lettr_audience_contact_topics_bulk_create`
This tool subscribes a matrix of contacts to specific topics. The LLM passes arrays of `contact_ids` and `topic_ids`. Lettr processes the matrix and returns the results, explicitly flagging pairs that were `already_subscribed`.

> "Take the 45 contacts we just created and bulk subscribe all of them to the 'Product Updates' topic ID."

### 6. Create a Sending Domain
**Tool**: `create_a_lettr_domain`
This operation registers a new sending domain. Lettr interfaces with SparkPost to provision the domain and stores it as approved by default (pending DNS verification checks). 

> "Register the domain 'marketing.acme.com' in Lettr as a new sending domain."

For a complete list of endpoints and JSON schema requirements, check out the full [Lettr integration documentation](https://truto.one/integrations/detail/lettr).

## Workflows in Action

AI agents excel at multi-step orchestration. By chaining Lettr tools together, an LLM can execute complex marketing logic from a single natural language prompt. Here are two real-world examples of how ChatGPT interacts with the Lettr MCP server.

### Scenario 1: Automated Campaign Generation and Dispatch
**User Prompt:**
> "Draft a new campaign called 'Q3 Feature Release' using our standard template ID 9912. Once it is created, dispatch the campaign immediately."

**Execution Steps:**
1. ChatGPT calls `create_a_lettr_campaign`, supplying the name, template ID, and required sender details.
2. The Lettr API responds with the new campaign object, including its unique `campaign_id`.
3. ChatGPT extracts the `campaign_id` and calls `lettr_campaigns_send` to trigger the asynchronous dispatch.
4. ChatGPT informs the user that the campaign is now in the `preparing` state.

```mermaid
sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT (Client)
    participant Truto as Truto MCP Server
    participant Lettr as Lettr API

    User->>ChatGPT: "Draft Q3 Feature Release..."
    ChatGPT->>Truto: call tool: create_a_lettr_campaign
    Truto->>Lettr: POST /api/campaigns
    Lettr-->>Truto: 201 Created (id: "cmp_abc123")
    Truto-->>ChatGPT: Tool Result: Success
    ChatGPT->>Truto: call tool: lettr_campaigns_send (id: "cmp_abc123")
    Truto->>Lettr: POST /api/campaigns/cmp_abc123/send
    Lettr-->>Truto: 200 OK (status: preparing)
    Truto-->>ChatGPT: Tool Result: Success
    ChatGPT-->>User: "Campaign created and dispatch triggered."
```

### Scenario 2: Audience Segmentation and Tagging
**User Prompt:**
> "Here are 30 new enterprise leads. Add them to Lettr, attach them to the 'Enterprise Prospects' list (ID 45), and subscribe them to the 'B2B Newsletter' topic (ID 12)."

**Execution Steps:**
1. ChatGPT maps the user's data into the required JSON array and calls `lettr_audience_contacts_bulk_create`.
2. Lettr processes the batch and returns an array of the 30 new `contact_ids`.
3. ChatGPT calls `lettr_audience_contact_lists_bulk_create`, passing the array of 30 `contact_ids` and the list ID 45.
4. ChatGPT calls `lettr_audience_contact_topics_bulk_create`, passing the same `contact_ids` array and the topic ID 12.
5. ChatGPT returns a summary of the successful bulk operations.

## Security and Access Control

Giving an LLM direct API access requires strict governance. Truto's MCP architecture enforces security at the token level, ensuring your LLM can only interact with the endpoints you explicitly allow.

*   **Method Filtering:** Use `config.methods` to restrict the server to specific HTTP verbs. You can set this to `["read"]` to allow ChatGPT to pull campaign analytics while completely blocking it from creating or deleting contacts.
*   **Tag Filtering:** Use `config.tags` to limit the functional scope. By setting tags to `["audience"]`, the MCP server will hide all campaign, domain, and webhook tools from the LLM, preventing accidental modifications to core infrastructure.
*   **API Token Authentication:** By enabling `require_api_token_auth: true`, the MCP endpoint will reject requests unless the client also passes a valid Truto API session token. This adds a second layer of security beyond the URL hash.
*   **Time-to-Live (TTL):** Set an `expires_at` timestamp when generating the server. Once the timestamp passes, the server URL automatically self-destructs. This is perfect for granting a temporary autonomous agent access to execute a specific background task.

## Handling Lettr Rate Limits

When writing custom integrations, dealing with HTTP 429 Too Many Requests errors is a massive time sink. 

**Factual note on how Truto handles rate limits:** Truto does not automatically retry, throttle, or apply backoff logic on rate limit errors. When the upstream Lettr API returns an HTTP 429, Truto passes that error directly through to the caller. However, Truto normalizes Lettr's upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. 

Because Truto normalizes these headers, your LLM framework (or standard API client) can implement a unified retry and backoff strategy that works across all connected APIs, without needing to write custom parsing logic for Lettr's specific rate limit header format.

## Wrap Up

Connecting Lettr to ChatGPT natively opens up powerful AI-driven marketing workflows. Instead of manually clicking through UI dashboards to segment lists, analyze campaign stats, or draft newsletters, you can orchestrate the entire Lettr platform using natural language.

By leveraging Truto's dynamic MCP server generation, you avoid writing boilerplate JSON-RPC handlers, mapping bulk data structures, or fighting with SparkPost idempotency rules. You configure the security scopes, copy the URL, and let the LLM do the rest.

> Ready to connect your AI agents to 100+ B2B SaaS platforms without writing integration code? Book a demo with Truto today.
>
> [Talk to us](https://truto.one/book-a-demo/)