Connect Extole to ChatGPT: Manage Campaigns, Rewards & Assets

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

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. You can either spend weeks building, hosting, and securing a custom MCP server, 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 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.

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:

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:

{
  "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:

{
  "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:

{
  "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.

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.