Connect Dotdigital to Claude: Manage Omnichannel Campaigns & ROI

If your team uses ChatGPT, check out our guide on connecting Dotdigital to ChatGPT or explore our broader architectural overview on connecting Dotdigital to AI Agents.

If you need to connect Dotdigital to Claude to automate omnichannel marketing, query campaign ROI, manage CPaaS messaging, or sync massive Insight Data collections, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between Claude's LLM tool calls and Dotdigital's massive REST API surface.

You can either dedicate engineering sprints to building, hosting, and maintaining this infrastructure yourself, or you can use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

Giving a Large Language Model (LLM) read and write access to a sprawling marketing ecosystem like Dotdigital is an immense engineering challenge. You must handle OAuth 2.0 or API token lifecycles, map massive, variable JSON schemas to MCP tool definitions, and deal with Dotdigital's strict pagination and asynchronous polling requirements. Every time Dotdigital updates an endpoint or deprecates a resource, 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 for Dotdigital, connect it natively to Claude Desktop or Enterprise, and execute complex omnichannel workflows using natural language.

The Engineering Reality of the Dotdigital 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, the reality of implementing it against specialized marketing and CPaaS APIs is painful. Dotdigital is built to manage everything from simple email newsletters to complex SMS routing, transactional streams, and custom NoSQL-style "Insight Data" collections. Its API reflects that complexity.

If you decide to build a custom Dotdigital MCP server, here are the specific integration challenges you will face:

Asynchronous Polling and Job States Not all operations in Dotdigital are synchronous CRUD. When you want to upload a batch of custom user data into an Insight Data collection, or enroll a large segment of users into a marketing program, the API returns a 202 Accepted alongside an import ID. The operation happens in the background. An LLM natively assumes that a 200-range response means the data is immediately queryable. To make this work, your MCP server must expose explicit polling tools and inject schema descriptions that instruct the LLM to recursively check the import status until it hits a Finished or Failed state.

Schema Variability in Insight Data Dotdigital allows teams to define custom "Insight Data" collections. These act as arbitrary JSON stores attached to contacts or accounts. Because the schema is defined by the user inside Dotdigital, there is no static OpenAPI spec you can hand to Claude. If you hardcode your MCP tools, the LLM will hallucinate field names when trying to write data. A managed MCP approach solves this by delegating the execution to proxy handlers that pass the raw JSON directly, while allowing environment-level documentation overrides to define the exact shape of your specific collections.

Omnichannel Fragmentation Dotdigital treats different communication channels as entirely separate API domains. Sending a standard marketing email, dispatching an SMS campaign, and triggering a transactional email all require completely different endpoints, payload structures, and validation rules. An LLM cannot simply "send a message to a user." It must navigate the fragmentation between create_a_dotdigital_campaigns_send, create_a_dotdigital_sms_messages_send_to, and create_a_dotdigital_email. Providing a clean toolset requires precise tool naming conventions so the LLM understands exactly which channel it is invoking.

Step 1: Generating the Managed MCP Server for Dotdigital

Truto derives MCP tools dynamically from the underlying API documentation and integration configurations. When you connect a Dotdigital account, Truto's engine reads the available resources, checks the documentation gates, and builds the tool schemas automatically.

You can generate the MCP server via the Truto UI or programmatically via the REST API.

Method A: Via the Truto UI

This is the fastest path for internal teams setting up Claude Desktop.

1. Log into your Truto dashboard and navigate to the Integrated Accounts page for your Dotdigital connection.
2. Click on the MCP Servers tab.
3. Click Create MCP Server.
4. Configure your server. You can assign a human-readable name, restrict allowed methods (e.g., read only, or write only), and filter by tags (e.g., ["campaigns", "reporting"]). You can also set an expiration date if you want the server to self-destruct.
5. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method B: Via the Truto API

For platform engineers looking to provision MCP servers dynamically for end-users, you can use the REST API. This generates a cryptographically hashed token stored in distributed KV edge nodes.

Request:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Dotdigital Omnichannel Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["campaigns", "insight_data", "sms"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Response:

{
  "id": "mcp-7f8a9b2c",
  "name": "Dotdigital Omnichannel Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["campaigns", "insight_data", "sms"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This URL is fully self-contained. The token in the path encapsulates the tenant isolation, the underlying OAuth/API keys, and the tool filtering configurations.

Step 2: Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can plug it into Claude. All communication happens over HTTP POST via JSON-RPC 2.0.

Method A: Via the Claude UI

If you are using Claude for Enterprise or Claude Team, administrators can add custom connectors directly in the interface.

1. In Claude, navigate to Settings → Integrations (or Connectors).
2. Click Add MCP Server or Add custom connector.
3. Paste the Truto MCP URL into the Server URL field.
4. Give it a descriptive name like "Dotdigital (Truto)".
5. Click Add. Claude will instantly send an initialize request to the server, negotiate protocol versions, and fetch the list of available Dotdigital tools.

(Note: If you are using ChatGPT's Advanced Settings -> Developer Mode, the process is virtually identical).

Method B: Via the Config File (Claude Desktop)

If you are running Claude Desktop locally for development, you can mount the server via your configuration file using Server-Sent Events (SSE).

Open your claude_desktop_config.json (located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add:

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

Restart Claude Desktop. The agent will immediately parse the dynamically generated JSON schemas for Dotdigital's endpoints, automatically understanding which fields are required and how to handle pagination cursors.

Dotdigital Hero Tools

Truto automatically translates Dotdigital's REST resources into snake_case MCP tools. Here are the highest-leverage tools available for AI orchestration.

create_a_dotdigital_campaigns_send_time_optimised

Triggers an email campaign send that leverages Dotdigital's internal machine learning to optimize the delivery time based on when each specific contact is most likely to open it.

"Send the 'Q4 Product Update' campaign (ID: 1109432) to the 'Active Enterprise Users' address book, but make sure to use time-optimized sending so it hits their inboxes at the best possible hour."

dotdigital_insight_data_imports_bulk_update

Bulk imports custom JSON records into a contact-scoped or account-scoped Insight Data collection asynchronously. This allows you to push complex telemetry or CRM data into Dotdigital for advanced segmentation.

"Take this list of 50 recent e-commerce transactions and bulk import them into the 'PurchaseHistory' insight data collection. Let me know the import job ID so we can track its completion."

create_a_dotdigital_sms_campaign

Creates a new SMS campaign for mobile outreach. Crucial for omnichannel orchestration when email open rates are insufficient.

"Draft a new SMS campaign named 'Flash Sale Reminder'. The message should say 'Our 24-hour flash sale ends soon! Use code FLASH20 at checkout.' Make sure short link tracking is toggled on."

create_a_dotdigital_programs_enrolment

Enrolls contacts or entire address books into an automated marketing program. Processing happens asynchronously.

"Enroll contact ID 993841 and contact ID 993842 into the 'Welcome Series Onboarding' program (ID: 442). Give me the enrollment ID so we can verify they were processed."

list_all_dotdigital_campaigns_metrics

Fetches deep ROI and engagement metrics (unique opens, clicks, revenue, conversion rates) for sent campaigns over a specific date range.

"Pull the campaign metrics for all campaigns sent between October 1st and October 31st. I want to see a table comparing the unique opens, total clicks, and generated revenue for each campaign."

create_a_dotdigital_chat_message

Sends a CPaaS (Communications Platform as a Service) message into a live chat or omnichannel conversation stream.

"Send a message into chat ID 'chat-98765' saying that an agent is currently reviewing their account and will be with them in 2 minutes."

To view the complete inventory of available endpoints, schemas, and return types, visit the Dotdigital integration page.

Workflows in Action

Giving Claude access to individual tools is useful, but the real power of MCP lies in multi-step orchestration. Here is how Claude handles complex Dotdigital workflows autonomously.

Workflow 1: The Asynchronous Insight Data Pipeline

Marketing teams often need to ingest massive amounts of external data (like recent product usage telemetry) into Dotdigital's Insight Data collections to build dynamic segments. Because this operation is asynchronous, Claude must trigger the import and then poll the status.

"Take this JSON array of 500 recent user logins and bulk import them into the 'ProductTelemetry' insight data collection. Wait until the import is finished, and let me know if any records failed."

sequenceDiagram
    participant User as User
    participant Agent as AI Agent (Claude)
    participant Truto as Truto MCP Server
    participant Dotdigital as Dotdigital API

    User->>Agent: "Bulk import telemetry and report status..."
    Agent->>Truto: Call dotdigital_insight_data_imports_bulk_update
    Truto->>Dotdigital: POST /v2/insight-data/imports
    Dotdigital-->>Truto: 202 Accepted (importId: 1045)
    Truto-->>Agent: Returns importId 1045 and status 'NotFinished'
    
    loop Polling until Complete
        Agent->>Truto: Call get_single_dotdigital_insight_data_import_by_id (id: 1045)
        Truto->>Dotdigital: GET /v2/insight-data/imports/1045
        Dotdigital-->>Truto: 200 OK (status: 'Finished', failures: 0)
        Truto-->>Agent: Returns final status
    end
    
    Agent-->>User: "Import 1045 is complete. 500 records processed, 0 failures."

What happens:

1. Claude parses the user's data and calls dotdigital_insight_data_imports_bulk_update.
2. The server returns an importId.
3. Claude reads the tool description, understands it must poll for completion, and repeatedly calls get_single_dotdigital_insight_data_import_by_id.
4. Once the status hits Finished, Claude parses the failure count and reports back to the user.

Workflow 2: Omnichannel Campaign Rollout & ROI Tracking

When launching a major update, growth teams rely on multi-channel strategies and immediate feedback loops. Claude can orchestrate the creation of both email and SMS campaigns, schedule them, and later check the revenue impact.

"Create an email campaign called 'Black Friday Teaser' using this HTML content. Then create an SMS campaign with the same name. Send the email using the time-optimized send feature to address book 54321. Finally, check the campaign metrics for last week's 'Early Bird' campaign and tell me how much revenue it generated."

What happens:

1. Claude calls create_a_dotdigital_campaign with the provided HTML and required parameters.
2. Claude calls create_a_dotdigital_sms_campaign to set up the mobile counterpart.
3. Claude executes create_a_dotdigital_campaigns_send_time_optimised, passing the newly created email campaign ID and the target address book.
4. Claude calls list_all_dotdigital_campaigns_metrics, passing the date range for the previous week, and filters the result to find the "Early Bird" campaign, extracting the revenue attribute to summarize for the user.

Security and Access Control

Exposing an omnichannel marketing platform to an autonomous AI requires strict access constraints. Truto's MCP architecture provides robust security controls at the token level, ensuring Claude only does exactly what you permit.

• Method Filtering: Use config.methods during server creation to restrict operations. Passing ["read"] completely blocks Claude from mutating data or triggering email sends, limiting it purely to reporting and auditing.
• Tag Filtering: Use config.tags to limit the server's scope to specific functional areas. For example, applying ["reporting"] ensures the agent can only access analytics tools, not contact deletion or SMS configuration.
• Additional Authentication (require_api_token_auth): By default, the MCP URL is secured by an embedded cryptographic hash. For elevated security environments, setting require_api_token_auth: true forces the client to pass a valid Truto API session token in the authorization header, ensuring the URL alone cannot be exploited.
• Time-to-Live (expires_at): You can generate ephemeral servers by setting an ISO datetime expiration. Once expired, a Durable Object alarm automatically tears down the edge KV entries, permanently killing the connection.

A Note on Rate Limits and Resiliency

Dotdigital enforces strict API quotas, especially on heavy analytical endpoints or rapid transactional sends. It is important to understand that Truto does not automatically retry, throttle, or apply exponential backoff when rate limits are exceeded.

When Dotdigital returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the calling agent. However, Truto normalizes the upstream rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). This allows the LLM framework (or your custom MCP client) to read the exact reset time and intelligently pause execution before retrying. Managing retry logic and backoff delays is the responsibility of the caller.

Moving Past Manual Campaign Ops

Connecting Dotdigital to Claude transforms a static API into an intelligent marketing assistant. By leveraging MCP, you eliminate the need to write custom integration scripts for every new campaign rollout or data import workflow.

Truto abstracts the underlying API authentication, dynamically derives the required tool schemas, and manages the secure connection state—allowing your AI agents to immediately start analyzing ROI, triggering omnichannel sends, and managing custom segments without engineering overhead.