Connect Chameleon to ChatGPT: Analyze User Journeys and Survey Data

If you need to connect Chameleon to ChatGPT to automate user journey analysis, extract microsurvey feedback, or segment your product audiences, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Chameleon's REST API. You can either build, host, 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 Chameleon to Claude or explore our broader architectural overview on connecting Chameleon to AI Agents.

Giving a Large Language Model (LLM) read and write access to a digital adoption platform (DAP) like Chameleon is a serious engineering challenge. You have to handle complex segmentation filters, manage dual identifier spaces, and map highly nested analytics payloads into a format the model can reliably interact with. Every time a new custom property is introduced into your product data, your static integration code has to be updated.

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

The Engineering Reality of the Chameleon API

A custom MCP server is essentially a self-hosted API gateway. While the open MCP standard provides a predictable way for ChatGPT to discover tools, implementing it against Chameleon's specific API surface is exceptionally painful for engineering teams.

If you decide to build a custom MCP server for Chameleon, you own the entire lifecycle. Here are the specific integration challenges you will face:

The Dual Identifier System

Chameleon user profiles and companies exist across a dual identifier space. Records have an internal Chameleon id as well as your own custom uid (and often an email). When an LLM wants to retrieve a profile, your custom MCP server must dynamically figure out whether the LLM generated a Chameleon ID, a raw UID string, or an email address, and route the request to the correct endpoint (/profiles/{id} vs /profiles/search). If your tool schemas do not strictly define these mutually exclusive inputs, the LLM will mix them up and trigger endless 400 Bad Request errors.

Complex Segmentation Filter Payloads

Chameleon's power lies in its segmentation engine. To query profiles or companies, you cannot simply pass query parameters like ?plan=enterprise. Instead, you must construct deeply nested JSON Segmentation filter expressions representing "and/or" logic across properties, experience interactions, and events. Expecting an LLM to reliably generate this bespoke JSON format from scratch is a recipe for hallucinations. Your server must carefully type-check the LLM's output against Chameleon's specific operator definitions before forwarding the request.

Asynchronous Bulk Operations

Chameleon handles large-scale updates (like tagging thousands of profiles) via asynchronous bulk imports. When an LLM wants to tag a list of users extracted from a survey, it cannot simply make a synchronous POST request and get the updated records back. The API requires submitting an import job, receiving a job ID, and polling for completion status. Forcing an AI agent into a long-polling loop consumes massive amounts of context window and token budget.

Chameleon to ChatGPT Quickstart Guide

To bypass these architectural hurdles, you can use Truto to generate a managed MCP server. This abstracts the authentication refresh cycles and schema mapping, giving ChatGPT immediate access to Chameleon.

Step 1: Connect Chameleon as an Integrated Account

First, you need to establish a secure connection between Truto and Chameleon.

1. In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account.
2. Select Chameleon from the integration directory.
3. Enter your Chameleon API token and complete the connection flow.
4. Truto securely stores the credentials. Note the integrated_account_id generated upon completion.

Step 2: Generate the MCP Server

Truto creates MCP servers by dynamically converting Chameleon's API documentation and endpoint definitions into JSON-RPC tools. You can create this server via the Truto UI or programmatically via the API.

Option A: Via the Truto UI

1. Navigate to the integrated account page for your Chameleon connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tags like profiles and surveys).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<secure-token>).

Option B: Via the API You can generate the MCP server programmatically by making a POST request. This is useful for multi-tenant applications dynamically spinning up servers per user.

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": "Chameleon Analytics Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["profiles", "surveys", "tours"]
    }
  }'

The response returns the secure URL required by the MCP client.

Step 3: Connect the Server to ChatGPT

With the URL in hand, you must now instruct ChatGPT to consume the tools.

Option A: Via the ChatGPT UI (Developer Mode)

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "Chameleon Data") and paste the Truto MCP server URL.
5. Save the configuration. ChatGPT will immediately perform the initialization handshake and discover the available Chameleon tools.

Option B: Via Manual Config File If you are running a local ChatGPT-compatible agent framework or client, you can use the standard Server-Sent Events (SSE) transport configuration:

{
  "mcpServers": {
    "chameleon": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_SECURE_TOKEN>"
      ]
    }
  }
}

Hero Tools for Chameleon Workflows

Truto exposes the entirety of the Chameleon API, but certain endpoints provide massive leverage for AI agents analyzing user behavior. Here are the core tools your agent will rely on.

Search User Profiles

Tool name: chameleon_profiles_search

This is the workhorse for audience discovery. It accepts segmentation filter expressions to find profiles matching specific criteria, such as users on a "Pro" plan who logged in within the last 30 days but never completed the onboarding tour.

"Find all user profiles belonging to the 'Enterprise' plan who have not been seen in the last 14 days, and return their custom properties."

List Tour Interactions

Tool name: list_all_chameleon_tour_interactions

This tool retrieves the exact engagement state of a specific tour. It allows the agent to see who started, completed, or exited a product tour, along with timestamps and goal completions.

"Pull the interaction data for the 'New Dashboard Overview' tour (ID: 55432) and show me the list of users who exited the tour before completion."

Retrieve Survey Responses

Tool name: list_all_chameleon_survey_responses

This tool allows the agent to ingest raw feedback from microsurveys, including NPS scores, button clicks, and free-text comments, making it perfect for AI-driven sentiment analysis.

"Get the last 100 responses for our Q3 NPS survey. Extract the free-text comments and give me a summary of the most common complaints."

Create a Delivery

Tool name: create_a_chameleon_delivery

This tool directly triggers a specific experience (a tour or survey) to a targeted user profile, bypassing the standard segmentation rules for highly personalized, agent-driven interventions.

"Trigger a delivery for the 'Feature Deep Dive' tour to the user with the ID 'usr_998877'. Set the delivery window to start immediately."

Update a Tour

Tool name: update_a_chameleon_tour_by_id

This administrative tool allows the agent to publish, unpublish, or modify the environments and tags attached to a specific tour.

"Unpublish the 'Legacy Navigation Walkthrough' tour immediately by setting its published_at value to null."

Bulk Update Tags

Tool name: chameleon_tags_bulk_update

This tool allows the agent to apply or remove tags across multiple experiences in a single request, keeping your Chameleon dashboard organized as campaign themes evolve.

"Apply the tag 'q4-marketing-push' to the following three tour IDs: 112, 115, and 119."

Note: This is just a fraction of the available endpoints. For the complete list of supported operations and schema requirements, view the Chameleon integration page.

Workflows in Action

Once connected, ChatGPT can orchestrate complex analytical and operational workflows across your DAP data. Here are two practical examples.

Scenario 1: Auditing Onboarding Drop-offs and Re-engaging

A product manager wants to understand why users are failing to activate and wants to intervene.

"Look at the 'Welcome to Pro' tour (ID: 9942). Find users who exited before completion in the last 48 hours. For each of those users, trigger a delivery of the 'Pro Features Micro-Survey' (ID: 2210)."

Step-by-step execution:

1. Query interactions: ChatGPT calls list_all_chameleon_tour_interactions for tour ID 9942, filtering the logic in memory to identify records where state is exited within the specified timeframe.
2. Extract profiles: The model extracts the profile_id for each matching interaction record.
3. Trigger interventions: ChatGPT loops through the extracted IDs, calling create_a_chameleon_delivery for each profile, passing the model ID for the microsurvey.

The user gets back a summary confirming the exact number of users who dropped off and a confirmation that the follow-up survey has been queued for delivery to each profile.

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant Truto as Truto (MCP Server)
    participant Chameleon as Chameleon API

    User->>ChatGPT: "Find drop-offs and send survey..."
    ChatGPT->>Truto: Call list_all_chameleon_tour_interactions
    Truto->>Chameleon: GET /tours/9942/interactions
    Chameleon-->>Truto: Return interaction logs
    Truto-->>ChatGPT: Return MCP Tool Response
    
    loop For each exited profile
        ChatGPT->>Truto: Call create_a_chameleon_delivery
        Truto->>Chameleon: POST /deliveries
        Chameleon-->>Truto: 201 Created
        Truto-->>ChatGPT: Return Delivery ID
    end
    
    ChatGPT-->>User: "Found 12 drop-offs. Surveys scheduled."

Scenario 2: NPS Survey Analysis and Segmentation

A customer success lead wants to isolate unhappy customers based on recent feedback.

"Analyze the recent responses for the 'Q2 Satisfaction' microsurvey. Find all users who left a score of 6 or below, extract their profile IDs, and look up their company domains. Give me a table of the results."

Step-by-step execution:

1. Fetch responses: ChatGPT calls list_all_chameleon_survey_responses to retrieve the latest raw submissions.
2. Identify detractors: The LLM parses the response payloads, filtering for scores representing 6 or lower.
3. Enrich data: For each detractor, ChatGPT calls chameleon_profiles_get_id to retrieve the full profile object, expanding the company data to extract the domain.

The user receives a perfectly formatted markdown table detailing the dissatisfied users, their specific feedback comments, and the domains of the accounts they belong to.

Security and Access Control

Giving an AI agent access to user profile data requires strict boundary management. Truto's MCP implementation provides several layers of access control out of the box:

• Method Filtering: When creating the MCP server, you can restrict it to specific HTTP verbs. Setting methods: ["read"] ensures the agent can query profiles and interactions but physically cannot update records or trigger deliveries.
• Tag Filtering: You can restrict the tool list to specific domain areas by utilizing config.tags. For example, setting tags to ["surveys"] will hide all administrative endpoints related to environment configurations or billing.
• Time-to-Live (TTL): By supplying an expires_at timestamp during server creation, you can generate ephemeral MCP servers. Once the timestamp passes, the server URL is automatically invalidated.
• Strict Identity Enforcement: By enabling require_api_token_auth, you force the client connecting to the MCP server to provide a valid Truto API token in the Authorization header. The URL alone is no longer enough, ensuring only authenticated systems can invoke the tools.

Architecting for Rate Limits and Pagination

When deploying AI agents to analyze vast datasets, API limits become a critical engineering constraint.

Factual note on rate limits: Truto does not automatically retry, throttle, or apply backoff logic when an upstream API hits a limit. If the Chameleon API returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the caller (your LLM client).

Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The system calling the MCP server - whether that is a LangGraph orchestration layer, a custom script, or ChatGPT - is entirely responsible for detecting the error, reading the reset header, and executing the appropriate retry or backoff logic.

Furthermore, for pagination, Truto dynamically injects explicit limit and next_cursor schemas into list endpoints. The descriptions explicitly instruct the LLM to pass cursor values back unchanged, ensuring the model can navigate through thousands of Chameleon profile records without hallucinating pagination tokens.

Stop Writing Point-to-Point API Code

Connecting ChatGPT to Chameleon shouldn't require your engineering team to spend weeks studying segmentation payload schemas, dealing with dual identifier resolutions, or maintaining fragile API models.

By leveraging Truto's managed MCP servers, you can instantly turn your product documentation into perfectly typed JSON-RPC tools. Your AI agents get secure, filterable access to Chameleon's underlying data, and your engineers get to focus on core product architecture.