---
title: "Connect Extole to ChatGPT: Manage Campaigns, Rewards & Assets"
slug: connect-extole-to-chatgpt-manage-campaigns-rewards-assets
date: 2026-07-25
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Give your AI agents secure read and write access to your Extole instance using a managed MCP server. Manage rewards, generate shareables, and track campaigns."
tldr: "Learn how to securely connect Extole to ChatGPT using a managed MCP server. This guide covers the engineering realities of Extole's API, how to generate a secure MCP endpoint via Truto, and real-world workflows for automating referral marketing and reward fulfillment."
canonical: https://truto.one/blog/connect-extole-to-chatgpt-manage-campaigns-rewards-assets/
---

# Connect Extole to ChatGPT: Manage Campaigns, Rewards & Assets


If your team uses Claude instead, check out our guide on [connecting Extole to Claude](https://truto.one/connect-extole-to-claude-analyze-audiences-reports-referrals/) or explore our broader architectural overview on [connecting Extole to AI Agents](https://truto.one/connect-extole-to-ai-agents-automate-fulfillment-events-batches/).

Marketing and growth teams rely on Extole to power enterprise referral programs, track advocacy campaigns, and distribute rewards at scale. When you connect Extole to ChatGPT, you unlock the ability to automate reward fulfillment, generate localized influencer links, and analyze campaign performance using natural language. But giving a Large Language Model (LLM) read and write access to a complex marketing platform requires an integration layer that can translate agent intents into strict REST API calls.

To achieve this, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). You can either spend weeks [building, hosting, and securing a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or you can use a managed infrastructure platform like Truto to dynamically generate a secure, authenticated MCP server URL. 

This guide breaks down the engineering realities of the Extole API, exactly how to use Truto to generate a secure MCP server, how to connect it to ChatGPT, and how to execute complex marketing workflows using AI.

## The Engineering Reality of the Extole API

A custom MCP server is a self-hosted integration layer that sits between ChatGPT and your target SaaS platform. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable JSON-RPC interface for models to discover tools, implementing it against vendor APIs is an engineering grind.

If you decide to build a custom MCP server for Extole, you own the entire API lifecycle. You are not just building basic CRUD operations; you are navigating a platform built for highly concurrent, version-controlled marketing programs. Here are the specific integration challenges that make building a custom Extole connector painful:

### Raw vs. Built Component Representations
Extole enforces a strict separation between configuration and runtime evaluation. When an LLM requests a list of campaign components, calling the standard endpoints returns the "raw" definitions - which often contain unresolved variables, logic expressions, and uncompiled assets. If ChatGPT tries to analyze a campaign's live state using raw components, it will hallucinate based on incomplete data. Your MCP server must be intelligent enough to route read operations to Extole's "built" endpoints (e.g., fetching from `/v2/components/{id}/built` instead of `/v2/components/{id}`) to return fully evaluated runtime representations to the LLM.

### Campaign Versioning and Optimistic Locking
Extole campaigns are version-controlled to prevent live production issues. You cannot simply `PATCH` a live campaign. Modifying a campaign requires passing a specific version segment (`/version/{version}`) as an optimistic lock. If your AI agent tries to update a campaign without fetching and passing the latest version hash, the API will reject the request with a conflict error. Your custom server must manage this state retrieval automatically, or you must write exhaustive prompt instructions teaching the LLM how to perform optimistic locking.

### Asynchronous Report Polling
When marketing operations teams ask an AI to "generate a report on yesterday's referral conversions," the LLM cannot execute a single synchronous API call. Extole's reporting engine is asynchronous. Creating a report returns a `report_id` with a `PENDING` status. 

If your custom server doesn't provide a way to poll this status, the LLM will assume the report failed. 

```mermaid
sequenceDiagram
    participant ChatGPT
    participant MCP as Truto MCP
    participant Extole as Extole API

    ChatGPT->>MCP: Call create_a_extole_report
    MCP->>Extole: POST /v2/reports
    Extole-->>MCP: Returns report_id (PENDING)
    MCP-->>ChatGPT: Returns report_id
    Note over ChatGPT: Agent loops to poll status
    ChatGPT->>MCP: Call get_single_extole_report_by_id
    MCP->>Extole: GET /v2/reports/{id}
    Extole-->>MCP: Returns status: DONE
    MCP-->>ChatGPT: Returns download_url
```

### Rate Limits and 429 Errors
Extole aggressively protects its infrastructure from automated abuse. If an AI agent gets stuck in a loop while attempting to paginate through 10,000 person records, the API will return an HTTP 429 Too Many Requests. 

**Note on Truto's architecture:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Extole API returns a 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The LLM client or agent framework is entirely responsible for reading these headers and executing backoff logic.

## How Truto's Managed MCP Server Works

Truto eliminates the need to write custom integration code by dynamically generating MCP tools directly from Extole's API schemas and documentation. 

When you connect an Extole account, Truto's MCP Router translates the integration's documented endpoints into a JSON-RPC 2.0 interface. The generated MCP server is scoped specifically to a single Extole tenant account and authenticated via a cryptographic token in the URL. This token encodes the account ID, applies method and tag filters, and enforces optional expiration policies. 

Tools are never hardcoded or cached. They are built on-the-fly when ChatGPT requests a `tools/list` operation, ensuring that your AI agent always has access to the most up-to-date API schema.

## Creating the Extole MCP Server

You can generate an MCP server for Extole using either the Truto UI or the Truto REST API.

### Method 1: Via the Truto UI
For teams that prefer a visual interface, creating a server takes less than a minute:
1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Extole account.
3. Click on the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., filter by `read` or `write` methods, apply specific resource tags, or set an expiration date).
6. Copy the generated MCP server URL. You will use this to connect to ChatGPT.

### Method 2: Via the Truto API
For infrastructure-as-code deployments or dynamic provisioning, you can generate an MCP server programmatically. Make an authenticated `POST` request to the Truto API:

```bash
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": "Extole Marketing Ops AI",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["campaigns", "rewards", "reports"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API will return a database record containing your unique, secure server URL:

```json
{
  "id": "mcp_abc123",
  "name": "Extole Marketing Ops AI",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["campaigns", "rewards", "reports"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can expose Extole's capabilities to ChatGPT.

### Method A: Via the ChatGPT UI
If you are using ChatGPT Enterprise or an account with Developer mode enabled:
1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** on.
3. Under the custom connectors section, click to add a new server.
4. Enter a name (e.g., "Extole Automation").
5. Paste your Truto MCP Server URL into the **Server URL** field.
6. Click **Save**. ChatGPT will immediately handshake with the server and load the Extole tools.

### Method B: Via Manual Config File
If you are running a custom client, Claude Desktop, or a local agent framework that requires standard MCP configuration files, you can connect using the Server-Sent Events (SSE) transport adapter:

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

If you configured your MCP server with `require_api_token_auth: true` for enterprise security, you must pass your Truto API key in the headers:

```json
{
  "mcpServers": {
    "extole-secure": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890",
        "--header",
        "Authorization: Bearer YOUR_TRUTO_API_KEY"
      ]
    }
  }
}
```

## Extole Hero Tools for AI Agents

Truto exposes every documented endpoint on the Extole API, but some operations provide significantly more leverage for agentic workflows. Here are the core "hero tools" your AI agent will rely on.

### 1. `create_a_extole_campaign_live`
Setting a campaign live transitions it from a draft/test phase into production. The AI must pass the specific campaign ID and version hash to satisfy Extole's optimistic locking.

> "Find the 'Holiday Referral 2026' campaign, identify the latest draft version, and push it live to production."

### 2. `create_a_extole_person_shareable`
Generates a unique referral link or shareable code for a specific person. This is critical for influencer onboarding or customer support workflows where agents need to quickly issue tracking links.

> "Generate a new referral share link for user 89441120 and configure it with the 'VIP_Partner' label."

### 3. `list_all_extole_rewards`
Allows the LLM to search and filter the reward ledger. It can query by state (e.g., `PENDING`, `FULFILLED`, `FAILED`), campaign, or specific email addresses to reconcile payouts.

> "List all rewards currently in a FAILED state from the past 7 days and format them into a markdown table."

### 4. `create_a_extole_custom_reward_fulfilled`
When an external system (like a fulfillment house or manual finance process) issues a reward, this tool updates Extole to mark the custom reward as fulfilled, completing the lifecycle.

> "Mark reward ID 7738291 as fulfilled and append the partner reward ID 'TXN-9901A' as a reference."

### 5. `create_a_extole_person_membership`
Adds a participant to a specific target audience. This is used to dynamically inject users into targeted campaign segments based on external behavioral data.

> "Add the user with person ID 99281 to the 'High Value Advocates' audience list."

### 6. `create_a_extole_report`
Submits an asynchronous report generation request. The LLM must supply a report type (e.g., `campaign_performance`) and parameter criteria.

> "Run a standard campaign performance report for all Q3 campaigns. Let me know when the report ID is generated."

For a complete list of available Extole endpoints and their required JSON schemas, visit the [Extole integration page](https://truto.one/integrations/detail/extole).

## Workflows in Action

Giving ChatGPT access to these tools allows you to replace complex, multi-tab operations with simple natural language prompts.

### Workflow 1: End-of-Month Reward Reconciliation
Customer Success and Finance teams spend hours every month manually reviewing failed reward fulfillments. You can delegate this entire process to ChatGPT.

> **User Prompt:** "Find all pending and failed rewards from the 'Summer Promo' campaign. For any failed rewards, re-verify the criteria and mark them as fulfilled using our bulk exception code 'MANUAL-AUG-26'. When done, generate a reward activity report and give me the report ID."

**Agent Execution Steps:**
1. Calls `list_all_extole_rewards` filtering by `state: FAILED` and `campaign_id`.
2. Iterates over the returned array of failed rewards.
3. Calls `create_a_extole_custom_reward_fulfilled` in a loop, passing the `reward_id` and the `message: MANUAL-AUG-26` exception code.
4. Calls `create_a_extole_report` requesting a reward reconciliation report format.
5. Reads the response and returns the `report_id` to the user.

**Result:** The finance team avoids manual UI clicking. The LLM successfully reconciled the ledger and initiated the audit report in seconds.

### Workflow 2: VIP Influencer Onboarding
When a high-profile influencer signs up, marketing operations needs to add them to a VIP segment and instantly provide them with a custom sharing link.

> **User Prompt:** "We just signed a new influencer. Create a new person profile for 'influencer@example.com'. Add them to the 'VIP Tier' audience, and generate a custom shareable link for them to use immediately."

**Agent Execution Steps:**
1. Calls `create_a_extole_person` with the provided email address.
2. Reads the returned `person_id` from the response.
3. Calls `create_a_extole_person_membership` passing the new `person_id` and the predefined `audience_id` for the VIP Tier.
4. Calls `create_a_extole_person_shareable` using the `person_id` to generate the referral link.
5. Returns the generated link and confirmation to the user.

**Result:** A multi-step onboarding process that usually requires navigating three different Extole console pages is completed autonomously by the LLM in one continuous execution chain.

## Security and Access Control

When connecting ChatGPT to a production marketing environment, security is non-negotiable. Truto's MCP servers provide granular access controls to ensure your AI agents operate safely:

*   **Method Filtering:** Restrict servers to specific operations. By passing `methods: ["read"]` during creation, you ensure the LLM can pull reports and read configurations, but cannot physically issue rewards or alter campaigns.
*   **Tag Filtering:** Limit the server's scope to specific functional areas. Applying `tags: ["reporting"]` will isolate the LLM entirely from campaign management endpoints.
*   **Require API Token Auth:** By setting `require_api_token_auth: true`, possession of the MCP URL is no longer enough to execute commands. The client must also present a valid Truto session or API token, preventing unauthorized access if the URL leaks.
*   **Expiration (TTL):** Use the `expires_at` field to create temporary, short-lived MCP servers. This is perfect for giving a contractor or a temporary AI agent time-boxed access to Extole without leaving lingering API keys active.

## Automate Marketing Operations Without the Code

Connecting Extole to ChatGPT allows you to transform static marketing infrastructure into an intelligent, conversational system. By utilizing Truto's managed MCP servers, you bypass the massive engineering overhead of dealing with raw vs. built schema variants, asynchronous polling, and complex optimistic locking mechanics.

Your engineers shouldn't be writing boilerplate JSON-RPC handlers. They should be building your core product. Truto handles the translation layer, ensuring that your AI agents interact with Extole reliably, securely, and exactly as documented.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"}  
Want to give your AI agents secure, managed access to Extole and 100+ other enterprise SaaS platforms? Book a technical deep dive with our engineering team today.  
:::
