---
title: "Connect Hightouch to ChatGPT: Sync Data, Models & Marketing Sends"
slug: connect-hightouch-to-chatgpt-sync-data-models-marketing-sends
date: 2026-10-22
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Hightouch to ChatGPT using a managed MCP server. Execute marketing campaigns, trigger data syncs, and manage audience models via AI."
tldr: "Connect Hightouch to ChatGPT using Truto's auto-generated MCP servers. This guide shows how to securely expose Hightouch data syncs, IDR pipelines, and marketing campaigns to AI agents using natural language without maintaining custom integration code."
canonical: https://truto.one/blog/connect-hightouch-to-chatgpt-sync-data-models-marketing-sends/
---

# Connect Hightouch to ChatGPT: Sync Data, Models & Marketing Sends


If you want to connect Hightouch to ChatGPT to execute data syncs, orchestrate Identity Resolution (IDR) pipelines, and trigger marketing campaigns using natural language, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This infrastructure layer acts as the translation engine between ChatGPT's JSON-RPC tool calls and the Hightouch REST API. You can either spend weeks building, hosting, and maintaining a custom MCP server, or you can use a managed integration platform like Truto to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) in seconds.

If your team uses Claude, check out our guide on [connecting Hightouch to Claude](https://truto.one/connect-hightouch-to-claude-control-id-resolution-decision-logic/) or explore our broader architectural overview on [connecting Hightouch to AI Agents](https://truto.one/connect-hightouch-to-ai-agents-manage-events-syncs-destinations/).

Giving a Large Language Model (LLM) read and write access to a Reverse ETL platform like Hightouch is a massive engineering challenge. You are essentially giving an AI agent the keys to your data warehouse and downstream marketing automation platforms. You have to handle complex asynchronous job polling, stateful draft approvals, and polymorphic destination configurations. Every time a developer adds a new sync or updates an audience model in Hightouch, your custom server code must be updated and redeployed. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Hightouch, [connect it natively to ChatGPT](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex data activation 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 Hightouch API

Building a custom MCP server is essentially building and hosting a custom integration layer. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable mechanism for models to discover and invoke tools, implementing it against Hightouch's highly specialized API surface requires significant domain expertise.

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

### The Sync Draft State Machine
In Hightouch, updating a sync configuration is not a simple `PATCH` request that takes effect immediately. Because changes to data pipelines can have massive downstream consequences, Hightouch utilizes a draft and approval system. When you want to change a sync, you create a sync draft. That draft enters a `pending` state and must go through a review and approval process. To programmatically approve a draft via the API, you must pass specific `expectedDraftVersion` and `expectedResourceVersion` payload parameters to guarantee you aren't overwriting concurrent changes. An LLM cannot simply "update a sync"—your MCP server must guide the LLM through creating a draft, retrieving the version vectors, and executing the approval step.

### Asynchronous Identity Resolution and Audience Sizing
Many of Hightouch's most critical operations—such as computing the size of an audience model or running Identity Resolution (IDR) graph reprocessing—are asynchronous jobs. When you trigger a model size computation, the API does not return the size. It returns a `jobId`. Your MCP server must expose tools that allow the LLM to trigger the job, capture the ID, and subsequently poll a status endpoint (e.g., `get_single_hightouch_model_size_by_id`) until the job reaches a terminal state. Without strict schema definitions and clear tool descriptions, LLMs will constantly hallucinate synchronous responses for async workflows.

### Rate Limits and the Lack of Upstream Buffering
Data activation platforms enforce strict rate limits to protect underlying data warehouse compute. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Hightouch API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller—in this case, your AI agent or MCP client—is entirely responsible for reading these headers and implementing its own retry and backoff logic. Do not assume the integration layer will magically absorb rate limit spikes.

## Generating a Hightouch MCP Server

To connect Hightouch to ChatGPT, you first need an MCP server scoped to a specific Hightouch workspace. Truto generates this dynamically based on the integrated account.

### Method 1: Via the Truto UI (No-Code)

For administrators and product managers who want to provision an MCP server without writing code, the Truto dashboard provides a direct configuration interface.

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Hightouch account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can apply method filters (e.g., restricting the server to `read` operations only) and tag filters (e.g., only exposing tools related to `syncs` or `models`).
6. Click **Generate** and securely copy the resulting MCP server URL.

### Method 2: Via the Truto API (Programmatic)

For engineering teams building multi-tenant AI applications, you can [provision MCP servers programmatically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). This ensures that every customer in your platform gets an isolated, securely scoped set of Hightouch tools.

Make an authenticated `POST` request to the Truto API, passing your specific `integrated_account_id`:

```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": "ChatGPT Hightouch Server",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["syncs", "models", "campaigns"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API will return a JSON object containing the secure MCP `url`. This single URL handles all routing, token resolution, and authentication. Treat it as a highly sensitive secret.

```json
{
  "id": "mcp_abc123",
  "name": "ChatGPT Hightouch Server",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6...",
  "expires_at": "2026-12-31T23:59:59.000Z"
}
```

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP server URL, you must register it with ChatGPT. The MCP standard ensures that ChatGPT will automatically handshake with the server, request the `tools/list`, and understand the required JSON schemas for execution.

### Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts, you can connect remote MCP servers directly through the interface.

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support is gated behind this toggle).
3. Under the **MCP servers / Custom connectors** section, click to add a new server.
4. **Name:** Enter a descriptive name (e.g., "Hightouch Data Sync").
5. **Server URL:** Paste the Truto MCP URL generated in the previous step.
6. Click **Save**. ChatGPT will immediately ping the endpoint, negotiate capabilities, and load the Hightouch tools into your workspace.

### Method B: Via Manual Config File (SSE)

If you are deploying a custom agentic application or running a localized testing environment that bridges into ChatGPT, you can connect the Truto MCP server via a Server-Sent Events (SSE) proxy configuration file.

Create an `mcp-config.json` file to route traffic through the official MCP SSE transport utility:

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

Restart your agent framework or local environment, and it will read the configuration, establish the SSE connection to the Truto URL, and surface the Hightouch tools.

## Hightouch Hero Tools for ChatGPT

Truto automatically derives tool definitions from the underlying integration documentation. Here are the highest-leverage Hightouch operations you can expose to ChatGPT to automate data activation.

### Trigger a Data Sync
**Tool:** `hightouch_syncs_trigger`

This tool allows the LLM to force an immediate run of an existing Hightouch sync. It returns the `syncRunId`, `status`, and execution timestamps. If a sync is already running, the system automatically queues the subsequent run.

> "Trigger a run for the Salesforce Account Enrichment sync (sync_id: 84729). Let me know the status of the run once it has been successfully enqueued."

### Execute an API-Triggered Campaign
**Tool:** `hightouch_campaigns_trigger`

Use this tool to start an API-triggered marketing campaign for specific recipients. This is critical for programmatic marketing operations, bypassing scheduled batches in favor of real-time event-driven activation.

> "Start the 'Q4 Enterprise Webinar Invite' campaign (campaign_id: 11223) and send it to the following recipient handles: user1@example.com and user2@example.com."

### Define a New Data Model
**Tool:** `create_a_hightouch_model`

This tool creates a new underlying data model (audience definition) in the Hightouch workspace. The LLM must provide the model name, slug, query type, and the ID of the data warehouse source it is querying against.

> "Create a new Hightouch model named 'High Intent Churn Risk' with the slug 'high-intent-churn-risk'. Set the queryType to SQL and assign it to source ID 405. The model is not a schema."

### Check Model Audience Size
**Tool:** `get_single_hightouch_model_size_by_id`

Because computing the size of an audience requires querying the data warehouse, checking model size is an async operation. After triggering a model size computation, the LLM uses this tool to check the status and retrieve the final row count.

> "Check the status of the model size computation job (jobId: 98765) for the 'High Intent Churn Risk' model. If it is finished, tell me how many users are in the audience."

### Approve a Pending Sync Draft
**Tool:** `hightouch_sync_drafts_approve`

This tool is required to finalize changes to a sync. Because Hightouch protects data integrity via drafts, the LLM must supply the `expectedDraftVersion` and `expectedResourceVersion` to ensure no race conditions occur during approval.

> "Approve the pending sync draft (draft_id: 5543) for the Salesforce Account Enrichment sync. Ensure you pass the expected draft version 2 and resource version 5 to validate the change."

### Trigger Identity Resolution (IDR) Reprocessing
**Tool:** `hightouch_idrs_trigger`

This tool triggers a new Identity Resolution run for a specific IDR graph in Hightouch. It returns the run ID, allowing the LLM to track the progress of profile unifications across disparate data sources.

> "Trigger a new Identity Resolution run for our B2B Customer Graph (graph_id: 102). Return the run ID so we can monitor the unification process."

For a complete list of endpoints, required parameters, and JSON schema definitions, view the [Hightouch integration page](https://truto.one/integrations/detail/hightouch).

## Workflows in Action

When you connect Hightouch to ChatGPT using Truto's MCP server, the LLM can chain multiple tool calls together to orchestrate sophisticated data engineering and marketing operations.

### Scenario 1: Marketing Audience Sizing and Campaign Execution

A marketing operations manager wants to verify the size of a specific audience before blindly firing off an API-triggered email campaign to ensure they don't exceed their email provider's tier limits.

> "We need to send the 'Q4 Webinar' campaign (ID: 884). First, check the audience size for the 'Target Enterprise Users' model (ID: 211) using the recent computation job (ID: 554). If the audience size is under 5,000, go ahead and trigger the campaign send for those recipients."

```mermaid
sequenceDiagram
    participant User as Marketing Ops
    participant ChatGPT as ChatGPT (Client)
    participant MCP as Truto MCP Server
    participant Hightouch as Hightouch API

    User->>ChatGPT: "Check model 211 size (job 554). If < 5000, trigger campaign 884."
    
    ChatGPT->>MCP: Call get_single_hightouch_model_size_by_id(id: 554, model_id: 211)
    MCP->>Hightouch: GET /models/211/sizes/554
    Hightouch-->>MCP: { "status": "completed", "size": 4250 }
    MCP-->>ChatGPT: Tool Result: size is 4250
    
    Note over ChatGPT: Evaluates condition: 4250 < 5000 is True.
    
    ChatGPT->>MCP: Call hightouch_campaigns_trigger(campaign_id: 884, recipients: [...])
    MCP->>Hightouch: POST /campaigns/884/trigger
    Hightouch-->>MCP: { "status": "queued", "sendId": "snd_123" }
    MCP-->>ChatGPT: Tool Result: Campaign queued
    
    ChatGPT-->>User: "The audience size is 4,250. The campaign has been successfully triggered."
```

**Step-by-step breakdown:**
1. ChatGPT calls `get_single_hightouch_model_size_by_id` to retrieve the results of the async sizing job.
2. The MCP server returns the payload showing the audience size is 4,250.
3. ChatGPT evaluates the logical condition defined in the prompt (is it under 5,000?).
4. Because the condition is met, ChatGPT calls `hightouch_campaigns_trigger` to execute the API send.

### Scenario 2: Data Engineering Sync Approval Workflow

A data engineer asks ChatGPT to review the pending changes on a critical Salesforce sync, approve the draft to merge the changes, and force an immediate manual sync run.

> "Review the pending sync draft (draft_id: 34) for our Salesforce Account sync (sync_id: 99). If it looks correct, approve it using expected draft version 3 and resource version 8, then trigger the sync to run immediately."

```mermaid
sequenceDiagram
    participant User as Data Engineer
    participant ChatGPT as ChatGPT (Client)
    participant MCP as Truto MCP Server
    participant Hightouch as Hightouch API

    User->>ChatGPT: "Review draft 34 for sync 99. Approve and run it."
    
    ChatGPT->>MCP: Call get_single_hightouch_sync_draft_by_id(id: 34, sync_id: 99)
    MCP->>Hightouch: GET /syncs/99/drafts/34
    Hightouch-->>MCP: { "status": "pending", "draftVersion": 3, "resourceVersion": 8 }
    MCP-->>ChatGPT: Tool Result: Draft details
    
    ChatGPT->>MCP: Call hightouch_sync_drafts_approve(sync_id: 99, draft_id: 34, ...)
    MCP->>Hightouch: POST /syncs/99/drafts/34/approve
    Hightouch-->>MCP: { "status": "approved" }
    MCP-->>ChatGPT: Tool Result: Draft approved
    
    ChatGPT->>MCP: Call hightouch_syncs_trigger(sync_id: 99)
    MCP->>Hightouch: POST /syncs/99/trigger
    Hightouch-->>MCP: { "syncRunId": "run_999" }
    MCP-->>ChatGPT: Tool Result: Sync enqueued
    
    ChatGPT-->>User: "Draft 34 has been approved and the Salesforce sync is now running (run_999)."
```

**Step-by-step breakdown:**
1. ChatGPT calls `get_single_hightouch_sync_draft_by_id` to inspect the pending changes and verify state.
2. ChatGPT calls `hightouch_sync_drafts_approve`, passing the strict versioning requirements (`expectedDraftVersion` and `expectedResourceVersion`) to prevent concurrent overwrites.
3. Upon successful approval, ChatGPT calls `hightouch_syncs_trigger` to force the sync to push data to Salesforce immediately.

## Security and Access Control

Connecting an LLM to your data activation platform requires strict governance. Truto provides several configuration layers at the MCP server level to ensure your ChatGPT sessions only have access to what they explicitly need.

*   **Method Filtering:** Constrain the MCP server to specific HTTP methods. Passing `methods: ["read"]` ensures the LLM can query models and view sync statuses, but absolutely cannot trigger campaigns, approve drafts, or alter data pipelines.
*   **Tag Filtering:** Limit the surface area by functional group. Configuring the server with `tags: ["syncs", "models"]` completely hides downstream destination configuration and billing endpoints from the model's context window.
*   **Expiration Controls:** Use the `expires_at` attribute to generate short-lived, ephemeral MCP server URLs for contractor access or temporary auditing workflows. Once the timestamp passes, the server self-destructs.
*   **Mandatory API Authentication:** By setting `require_api_token_auth: true`, possession of the MCP URL is no longer sufficient. The connecting client (ChatGPT) must also pass a valid Truto API bearer token in the headers, adding a robust second layer of authentication.

## Moving Beyond Point-to-Point Scripts

Building a custom MCP server for Hightouch forces your engineering team into a perpetual cycle of maintaining API specifications, mapping complex draft workflows, and updating schema definitions every time the vendor alters an endpoint. By leveraging Truto's auto-generated MCP infrastructure, you abstract away the entirety of the integration maintenance lifecycle.

Your engineers can focus on building sophisticated data warehouse logic and multi-agent workflows, while Truto handles the secure routing, token lifecycles, and tool generation required to connect Hightouch to ChatGPT.