Connect ElasticEmail to ChatGPT: Manage Email Campaigns and Contacts

If you need to connect ElasticEmail to ChatGPT to orchestrate massive email campaigns, clean up bounce lists, or provision sending domains, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and ElasticEmail's REST API. 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 ElasticEmail to Claude or explore our broader architectural overview on connecting ElasticEmail to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise email service provider (ESP) like ElasticEmail is a massive engineering challenge. You have to handle complex nested payloads for transactional sends, map flat LLM outputs to specific recipient arrays, and deal with strict deliverability operations. Every time you need a new API endpoint exposed to your agent, custom server code must be updated, redeployed, and tested.

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

The Engineering Reality of the ElasticEmail 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 ElasticEmail's specific API quirks is exceptionally painful.

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

Segmented Suppressions vs Standard Contacts

Unlike simple CRM platforms where a contact record has a straightforward status field, ElasticEmail decouples standard contact management from deliverability lists (suppressions). Querying a contact via GET /contacts/{email} will tell you if they exist in your marketing lists, but it won't inherently give you the full context of why an email bounced. To properly orchestrate list hygiene, your MCP server must expose entirely separate tools for the suppressions endpoints (bounces, complaints, unsubscribes) and map that logic back to your contact deletion workflows.

Subaccount Context Switching

For agencies or multi-brand enterprises, ElasticEmail relies heavily on subaccounts. Managing credits, adjusting daily send limits, or updating email settings requires orchestrating calls across the /subaccounts endpoints. Your AI agent needs tools that are specifically scoped to manage these subaccounts. If your custom MCP server doesn't properly map subaccount IDs into the path parameters of your tool definitions, your LLM will hallucinate account targets and potentially alter the billing limits of the wrong client.

Flat Input Namespace vs Nested API Payloads

When an LLM calls a tool via the MCP protocol, all arguments arrive as a single, flat JSON object. However, ElasticEmail's transactional sending endpoint (POST /emails/transactional) requires a deeply nested payload - separating Recipients arrays, Content objects (which contain nested Body parts for HTML and PlainText), and Options for tracking.

Truto's MCP architecture automatically handles this flat-to-nested mapping. It takes the query and body schemas from the underlying ElasticEmail API documentation and derives exactly which LLM arguments belong in the query string versus the nested request body, without any manual data mapping required on your end.

Rate Limits and 429 Backoffs

ElasticEmail enforces strict rate limits depending on your account tier and reputation. It is critical to note that Truto does not automatically retry, throttle, or absorb rate limit errors.

When ElasticEmail returns an HTTP 429 Too Many Requests response, Truto immediately passes that error back to the calling client (ChatGPT). However, Truto normalizes the upstream rate limit information into standardized HTTP headers per the IETF specification (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (or your orchestrator framework) is fully responsible for reading these headers and implementing the appropriate retry and exponential backoff logic.

Generating Your ElasticEmail MCP Server

Truto's MCP server generation is fully dynamic and documentation-driven. Rather than hand-coding tool definitions, Truto derives them from ElasticEmail's underlying resource definitions and API schemas.

You can spin up an MCP server for an authenticated ElasticEmail account using either the Truto Dashboard or the Truto API.

Method 1: Via the Truto UI

If you are provisioning access for an internal operations team, the UI is the fastest path:

1. Navigate to the Integrated Accounts page in the Truto dashboard.
2. Select your connected ElasticEmail account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tags like campaigns).
6. Click save and copy the generated MCP server URL.

Method 2: Via the Truto API

For platform teams embedding AI agents into a broader SaaS application, you will want to programmatically generate MCP servers. You do this by making a POST request to the Truto API.

The API generates a cryptographically secure token, stores it with built-in expiration rules, and returns a ready-to-use URL.

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": "ElasticEmail Marketing Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["campaigns", "contacts", "emails"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response will return the configuration and the secure endpoint:

{
  "id": "mcp_abc123",
  "name": "ElasticEmail Marketing Assistant",
  "config": {
    "methods": ["read", "write"],
    "tags": ["campaigns", "contacts", "emails"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Treat this url as a sensitive credential. It contains the routing and authentication token required to execute tools against that specific ElasticEmail account.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with your LLM client. You can do this natively in the ChatGPT interface or via a manual configuration file for custom desktop clients.

Method A: Via the ChatGPT UI

If you are using a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can add the server directly to your workspace:

1. Open ChatGPT and go to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is enabled.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Set the Name to something recognizable (e.g., "ElasticEmail Ops").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately perform a protocol handshake, pull the available ElasticEmail tools, and make them available to your agent.

Method B: Via Manual SSE Configuration

If you are testing locally or using a different framework that requires a configuration file (like Claude Desktop or a custom LangChain orchestrator), you can connect using the official MCP SSE (Server-Sent Events) transport.

Add the following to your MCP configuration file:

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

Hero Tools for ElasticEmail

When the LLM connects, it receives a curated list of tools derived from the ElasticEmail API. Here are the highest-leverage operations your agent can perform.

Create a Contact

Tool: create_a_elastic_email_contact

Adds new contacts to your underlying ElasticEmail lists. The LLM must construct the payload based on the JSON schema, matching fields for email, name, and consent status. This is the foundation of any automated lead routing workflow.

"I just got a new lead from the webinar. Add sarah.connor@example.com to the 'Q3 Webinar Attendees' list. Set her first name to Sarah and mark her consent status as explicitly granted."

Send a Transactional Email

Tool: elastic_email_emails_send_transactional

Allows the LLM to trigger direct, transactional emails. Because Truto handles the nested schema requirements, the LLM simply fills out the flat arguments, and the proxy API maps it into the correct Content and Recipients blocks required by ElasticEmail.

"Draft a welcome email for our new user, John Doe (john@example.com). Use the subject line 'Welcome to our platform!' and include a short HTML body with a link to our getting started guide. Send it immediately."

Create an Email Campaign

Tool: create_a_elastic_email_campaign

Drafts and queues a new marketing campaign. This tool is perfect for agents acting as automated marketing assistants, where they draft the copy, select the recipient lists, and stage the campaign for processing.

"Create a new email campaign called 'Black Friday Teaser'. Target the 'Highly Engaged' list. The content should be a plain text email letting them know a major sale is dropping tomorrow."

Retrieve Campaign Statistics

Tool: elastic_email_statistics_campaigns

Returns detailed counter metrics for your campaigns, including total emails sent, delivered, bounced, opened, and clicked. The LLM can ingest these metrics to calculate engagement rates and recommend follow-up actions.

"Pull the statistics for all our recent campaigns. Identify which campaign had the highest open rate, and tell me the total number of bounces across all sends."

Manage Bounce Suppressions

Tool: elastic_email_suppressions_get_bounces

Retrieves the list of email addresses that have bounced. This is critical for automated list hygiene. By pairing this tool with the contact deletion tool, an agent can autonomously maintain your sender reputation.

"Fetch the current list of bounce suppressions. For every email on that list, write a summary of the bounce reason and the date it was added."

Bulk Update Subaccount Credits

Tool: elastic_email_subaccounts_bulk_update

For agency administrators, this tool adds or subtracts email credits for a specific subaccount. It is invaluable for automated billing orchestration or usage-based tiering.

"The client 'Acme Corp' just paid their invoice for the premium tier. Add 50,000 email credits to their subaccount (ID: acme-sub-123)."

To view the complete inventory of available endpoints, schemas, and required properties, visit the ElasticEmail integration page.

Workflows in Action

MCP servers shine when LLMs string together multiple tool calls to accomplish complex, multi-step tasks. Here are two real-world scenarios for ElasticEmail.

Scenario 1: Autonomous Deliverability Hygiene

Sender reputation is everything. If you continuously email bounced addresses, your domain will get blacklisted. You can ask ChatGPT to clean your lists automatically.

"Audit our ElasticEmail account for deliverability issues. Fetch all recent bounces, and then locate and delete those specific contacts from our active directory so we don't email them again."

How the agent executes this:

1. elastic_email_suppressions_get_bounces: The agent queries the suppression list to retrieve all email addresses that have hard-bounced.
2. Data Processing: The LLM parses the response, extracting the specific email addresses.
3. delete_a_elastic_email_contact_by_id: The agent loops through the extracted emails, calling this tool for each one to scrub them from the active ElasticEmail contact directory.

What the user gets back: A conversational confirmation detailing exactly how many bounces were found and confirming their removal from the active contact lists, ensuring high deliverability for the next send.

Scenario 2: End-to-End Campaign Deployment

Marketers spend hours moving copy from Google Docs into their ESP. ChatGPT can handle the entire drafting and staging process in one go.

sequenceDiagram
    participant User
    participant ChatGPT as ChatGPT (MCP Client)
    participant Truto as Truto Managed MCP
    participant EE as ElasticEmail API

    User->>ChatGPT: "Create a new list for VIPs, add Dave, and send a promo campaign."
    
    ChatGPT->>Truto: call tool: create_a_elastic_email_list<br>{"ListName": "VIP Customers"}
    Truto->>EE: POST /lists
    EE-->>Truto: 200 OK (List Data)
    Truto-->>ChatGPT: Tool Result

    ChatGPT->>Truto: call tool: create_a_elastic_email_contact<br>{"Email": "dave@example.com"}
    Truto->>EE: POST /contacts
    EE-->>Truto: 200 OK (Contact Data)
    Truto-->>ChatGPT: Tool Result

    ChatGPT->>Truto: call tool: create_a_elastic_email_campaign<br>{"Name": "VIP Promo"...}
    Truto->>EE: POST /campaigns
    EE-->>Truto: 200 OK (Campaign Data)
    Truto-->>ChatGPT: Tool Result
    
    ChatGPT-->>User: "The VIP list is created, Dave is added, and the campaign is staged."

"Create a new contact list called 'May 2026 VIPs'. Add dave@example.com to it. Then, draft a new campaign called 'VIP Early Access', targeting that new list, with a plain text email offering them a 20% discount."

How the agent executes this:

1. create_a_elastic_email_list: The agent provisions the new empty list.
2. create_a_elastic_email_contact: The agent adds the specific email address, appending it to the newly created list.
3. create_a_elastic_email_campaign: The agent constructs the campaign payload, drafts the 20% discount copy, and targets the new list ID.

What the user gets back: A complete summary of the newly staged campaign. The user just needs to log into ElasticEmail to review the final draft and hit send.

Security and Access Control

When providing an LLM with access to your marketing infrastructure and customer data, security is paramount. Truto provides several architectural layers to lock down your ElasticEmail MCP server:

• Method Filtering (config.methods): You can restrict the server to specific operation types. Setting "methods": ["read"] ensures the LLM can only query statistics and view contacts, but completely prevents it from executing create, update, or delete actions (like accidentally sending a campaign to 10,000 people).
• Tag Filtering (config.tags): Scope the agent's access to specific resource domains. By restricting tags to ["statistics"], the agent can pull campaign performance reports but cannot access the contacts or domains endpoints.
• Secondary Authentication (require_api_token_auth): By default, the cryptographically generated MCP URL is the only secret needed to connect. By enabling this flag, clients must also pass a valid Truto API token in the Authorization header, preventing unauthorized execution even if the URL leaks.
• Automatic Expiration (expires_at): You can set a strict time-to-live for the server. Once the timestamp passes, background cleanup processes automatically invalidate the token and delete the server configuration.

Conclusion

Integrating ElasticEmail with ChatGPT unlocks massive operational leverage for your marketing and deliverability teams. Instead of clicking through dashboards to audit bounces or compile campaign statistics, your team can orchestrate these workflows conversationally.

By leveraging Truto to generate your MCP servers, you bypass the friction of writing custom integration code, managing OAuth state, and mapping complex nested payloads. You get a secure, filtered, and fully managed connection to ElasticEmail in minutes.