---
title: "Connect Chameleon to Claude: Manage Onboarding and Audience Segments"
slug: connect-chameleon-to-claude-manage-onboarding-and-audience-segments
date: 2026-10-04
author: Roopendra Talekar
categories: ["AI & Agents"]
excerpt: "A complete engineering guide to connecting Chameleon to Claude using Truto's managed MCP servers. Automate onboarding, analyze NPS surveys, and sync user segments."
tldr: "Learn how to build a managed MCP server for Chameleon, connect it to Claude Desktop, and automate product adoption workflows like user progress resets and targeted tour deliveries using natural language."
canonical: https://truto.one/blog/connect-chameleon-to-claude-manage-onboarding-and-audience-segments/
---

# Connect Chameleon to Claude: Manage Onboarding and Audience Segments

**Chameleon in Claude, in about a minute.** The best way to connect Chameleon to Claude is Elaichi: connect Chameleon to Elaichi once, then add Elaichi to Claude as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect Chameleon.** Connect Chameleon once in Elaichi. Claude never gets more access than you have.
3. **Add Elaichi to Claude.** In Claude, open Customize, then Connectors, press Add and paste https://api.elaichi.ai/mcp. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=chameleon) · [Chameleon on Elaichi](https://elaichi.ai/connectors/chameleon/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=chameleon)

*Building Chameleon into your own product? The guide below is for you.*

---

If your team needs to connect Chameleon to Claude to manage user onboarding flows, analyze Microsurvey responses, or segment product audiences, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's tool-calling capabilities and Chameleon's REST API. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [/connect-chameleon-to-chatgpt-analyze-user-journeys-and-survey-data/](https://truto.one/connect-chameleon-to-chatgpt-analyze-user-journeys-and-survey-data/) or explore our broader architectural overview on [/connect-chameleon-to-ai-agents-automate-user-events-and-deliveries/](https://truto.one/connect-chameleon-to-ai-agents-automate-user-events-and-deliveries/).

Giving a Large Language Model (LLM) read and write access to a product adoption platform like Chameleon is an engineering challenge. You have to handle API authentication, map complex [JSON schemas to MCP tool definitions](https://truto.one/auto-generating-mcp-tools-from-openapi-specs-an-end-to-end-architecture-guide/), and deal with domain-specific payload requirements. Every time Chameleon updates an endpoint or adds a new parameter, 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 Chameleon, connect it natively to Claude Desktop, and execute complex onboarding workflows using natural language.

> Want to give your AI agents secure, authenticated access to Chameleon and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Chameleon 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 B2B APIs is painful. Chameleon is built to orchestrate product tours, surveys, and launchers across fragmented user bases. Its API reflects that deep domain complexity.

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

**Destructive Operations Require Context**
Chameleon maintains two entirely different concepts of deletion for a user profile, and an LLM must understand the difference to avoid catastrophic data loss. The standard `delete` operation (`chameleon_profiles_delete_id`) actually just *clears* a user's state - resetting their browser properties, removing event history, and reverting their tour progress so they can experience onboarding again. The profile itself remains. Conversely, the `forget` operation is a permanent, irreversible GDPR/CCPA purge. If you expose a generic "Delete User" tool to an LLM without strict schema descriptions, the model will inevitably trigger the wrong endpoint.

**Prefix-Based Mutation Logic**
Many Chameleon resources, such as Tours and Tooltips, use highly specific string manipulation to handle relationships. For example, if you want to attach a Tour to a specific Environment (a `url_group_id`), you must patch the tour record and prefix the ID with a `+` (e.g., `+env_123`). To remove it, you use a `-` (e.g., `-env_123`). LLMs struggle with these non-standard REST patterns unless the tool descriptions are explicitly engineered to explain this exact syntax.

**Complex Segmentation Filters**
Querying users or companies in Chameleon isn't a matter of simple query string parameters. The `chameleon_profiles_search` endpoint requires nested Segmentation filter expressions. You must pass JSON objects defining match conditions on custom properties (e.g., `role`, `plan`), experience interactions (e.g., `completed a tour`), combined with nested `AND/OR` operators. Translating a natural language request like "Find admins who abandoned the new dashboard tour" into Chameleon's specific filter schema requires incredibly detailed MCP tool definitions.

## Generating a Managed MCP Server for Chameleon

Instead of building a Node.js or Python server from scratch to wrap these API quirks, you can use Truto to dynamically generate a compliant MCP server scoped specifically to your connected Chameleon account.

Truto's architecture is dynamic and documentation-driven. It reads the integration's configuration and instantly [compiles a complete JSON-RPC 2.0 endpoint](https://truto.one/auto-generating-mcp-tools-from-openapi-specs-an-end-to-end-architecture-guide/). You can provision this server in two ways.

### Method 1: Via the Truto UI

For internal workflows, IT admins, and quick prototyping, the easiest way to generate your server is directly through the dashboard:

1. Navigate to the **Integrated Accounts** page in your Truto environment and select your active Chameleon connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can optionally restrict the server to specific HTTP methods (like `read` only) or specific functional tags.
5. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto REST API

If you are building an AI agent platform and need to programmatically provision MCP servers for your own customers, you can use the Truto API. This validates the integration, provisions a hashed token in Cloudflare KV for edge authentication, and returns a ready-to-use URL.

Make a `POST` request to `/integrated-account/:id/mcp`:

```bash
curl -X POST https://api.truto.one/integrated-account/{account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Chameleon Support Agent MCP",
    "config": {
      "methods": ["read", "write"]
    }
  }'
```

**Example Response:**
```json
{
  "id": "mcp-789-xyz",
  "name": "Chameleon Support Agent MCP",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

This URL is fully self-contained. It encodes the tenant routing and the authentication credentials required to execute actions against Chameleon.

## Connecting the Chameleon MCP Server to Claude

Once you have your Truto MCP URL, you can connect it directly to your LLM framework of choice. Because Truto standardizes the JSON-RPC communication, no additional backend code is required.

### Method A: Via the Claude Desktop UI (or ChatGPT)

If your organization uses Claude Desktop (or ChatGPT Enterprise/Pro), you can add the server directly through the application settings.

**For Claude Desktop/Web:**
1. Open Claude and navigate to **Settings**.
2. Go to **Integrations** (or **Connectors** in the Enterprise view).
3. Click **Add MCP Server** or **Add custom connector**.
4. Paste the Truto MCP URL and click **Add**.

**For ChatGPT (Developer Mode):**
1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Enable the **Developer mode** toggle.
3. Under **MCP servers / Custom connectors**, add a new server.
4. Name it (e.g., "Chameleon via Truto") and paste the URL. 

### Method B: Via Manual Configuration File

If you are running Claude Desktop locally or managing configurations via MDM, you can directly edit the `claude_desktop_config.json` file. 

Because Truto exposes an HTTP endpoint, you will use the official `@modelcontextprotocol/server-sse` package to act as a transport bridge between Claude's stdio requirements and Truto's Server-Sent Events/HTTP interface.

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

Restart Claude Desktop. The model will automatically send an `initialize` request to the server, [negotiate protocol versions](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/), and ingest all available Chameleon tools.

## High-Leverage Chameleon Tools for AI Agents

Truto automatically generates tools for every documented Chameleon endpoint. When the LLM requests the tool list (`tools/list`), Truto formats the integration's query and body schemas into standard JSON Schema format, injecting necessary LLM instructions (like explicit cursor handling for pagination).

Here are 6 high-leverage hero tools your agents can use immediately.

### 1. `chameleon_profiles_search`

This tool allows the LLM to search for specific user profiles using Chameleon's complex Segmentation filter expressions. It is vital for identifying cohorts based on behavior or custom attributes.

> "Find all users in the 'Enterprise' plan segment who have not been seen in the last 30 days and list their email addresses."

### 2. `update_a_chameleon_tour_by_id`

This tool allows agents to modify existing product tours. Crucially, the Truto schema instructs the LLM on how to use the `+` and `-` prefix logic to attach or detach environments and tags, or how to publish the tour by passing a timestamp.

> "Publish the 'Dashboard 2.0 Walkthrough' tour and attach it to the staging environment using the environment ID env_8829."

### 3. `list_all_chameleon_survey_responses`

Customer support and product AI agents can use this tool to pull raw feedback data from Microsurveys. It returns the button clicked, text inputs, and associated profile IDs.

> "Get the latest responses for our Q3 NPS survey. Summarize the text comments from anyone who gave a score of 6 or below."

### 4. `create_a_chameleon_delivery`

Deliveries allow you to bypass standard segmentation and force an Experience (a tour or survey) to trigger for one specific user. This is excellent for support workflows where an agent wants to manually push a tutorial to a confused user.

> "Trigger the 'Advanced Analytics Tutorial' delivery for user ID 99281 so it appears the next time they log in."

### 5. `chameleon_profiles_delete_id`

As detailed earlier, this tool resets a user profile's state without permanently deleting their record. It clears browser properties, event history, and tour progress.

> "Reset the onboarding progress for user profile ID 5519 so they can go through the initial product setup flow again."

### 6. `chameleon_search_items_upsert`

This tool interacts with the Chameleon HelpBar. Agents can use it to dynamically index new help center articles or knowledge base entries so they appear in the in-app search.

> "Add a new search item to the HelpBar titled 'Configuring SSO' with the URL to our new documentation page."

*To view the complete inventory of available endpoints and their exact JSON schemas, visit the [Chameleon integration page](https://truto.one/integrations/detail/chameleon).* 

## Workflows in Action

Connecting tools to an LLM is only half the battle. The real value of an MCP server is enabling the model to orchestrate multi-step workflows autonomously. Here are two real-world scenarios showing how Claude navigates the Chameleon API via Truto.

### Scenario 1: Resetting User State for Support

Customer support teams frequently need to reset a user's product tour progress if the user got stuck or skipped the tutorial by accident. Instead of logging into the Chameleon dashboard and manually finding the user, a support agent can ask Claude to handle it.

> "A user emailed us from jdoe@example.com saying they accidentally closed the onboarding tour and don't know how to set up their account. Can you reset their Chameleon progress?"

**Execution Steps:**
1. Claude calls `chameleon_profiles_get_number` passing `{ "email": "jdoe@example.com" }` to retrieve the internal Chameleon Profile ID.
2. Claude extracts the `id` from the response (e.g., `10482`).
3. Claude calls `chameleon_profiles_delete_id` passing `{ "profile_id": "10482" }` to reset the user's state metrics.
4. Claude confirms to the support agent that the progress has been cleared.

```mermaid
sequenceDiagram
    participant User as Support Agent
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Chameleon as Chameleon API

    User ->> Claude: "Reset the onboarding tour for jdoe@example.com"
    Claude ->> Truto: Call chameleon_profiles_get_number(email="jdoe@example.com")
    Truto ->> Chameleon: GET /profiles?email=jdoe@example.com
    Chameleon -->> Truto: Profile ID: 10482
    Truto -->> Claude: Return Profile data
    Claude ->> Truto: Call chameleon_profiles_delete_id(profile_id="10482")
    Truto ->> Chameleon: DELETE /profiles/10482
    Chameleon -->> Truto: 200 OK (State Reset)
    Truto -->> Claude: Confirmation
    Claude -->> User: "The user's tour progress has been reset."
```

### Scenario 2: Analyzing NPS and Triggering Follow-ups

Product Managers often want to analyze Microsurvey responses and take immediate action on detractors.

> "Look at the recent responses for the 'Q4 NPS' survey. Find anyone who left a score of 4 or lower, summarize their complaints, and trigger the 'Book a call with PM' delivery for them."

**Execution Steps:**
1. Claude calls `list_all_chameleon_surveys` to search for the ID of the 'Q4 NPS' survey.
2. Claude calls `list_all_chameleon_survey_responses` using the survey ID it found.
3. Claude parses the returned JSON array, filtering the data in memory to identify users who scored 4 or lower.
4. For each matching user, Claude extracts their `profile_id`.
5. Claude loops through the detractors, calling `create_a_chameleon_delivery` for each `profile_id`, setting `model_kind` to "survey" and `model_id` to the ID of the "Book a call" microsurvey.
6. Claude outputs a formatted summary of the complaints to the Product Manager.

## Security and Access Control

Exposing an internal product adoption tool to an AI model requires strict governance. Truto MCP servers enforce security at the token level, ensuring the LLM can only act within the boundaries you define.

*   **Method Filtering:** When creating the server via the UI or API, you can specify `config.methods: ["read"]`. Truto evaluates this at tool-generation time. Any endpoint that isn't a GET or LIST operation is completely hidden from the LLM, making accidental deletions impossible.
*   **Tag Filtering:** You can restrict the MCP server to specific functional areas using `config.tags`. For example, setting `tags: ["surveys"]` will generate a server that can only interact with Microsurveys, hiding all Tour and HelpBar endpoints.
*   **Temporary Access:** You can define an `expires_at` timestamp when provisioning the server. Once the timestamp is reached, Truto automatically purges the authentication token from Cloudflare KV and deletes the database record via a scheduled Durable Object alarm. This is ideal for granting a contractor temporary AI access to Chameleon data.
*   **Enforced API Token Auth:** By default, possession of the Truto MCP URL grants access. For higher security environments, you can enable `require_api_token_auth: true`. This forces the client to pass a valid Truto API bearer token in the headers alongside the connection request, adding a secondary layer of authentication.

## Handling Rate Limits and API Performance

It is critical to understand how Truto handles Chameleon's API quotas. Truto [acts as a transparent proxy layer](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/); **it does not automatically retry, throttle, or apply backoff on rate limit errors.** 

When Chameleon returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the calling client (Claude). However, to make this easier for your agent framework to handle, Truto normalizes the upstream rate limit information into standardized HTTP headers per the IETF specification:

*   `ratelimit-limit`: The total requests allowed in the current window.
*   `ratelimit-remaining`: The number of requests left.
*   `ratelimit-reset`: The timestamp when the quota resets.

The orchestrating client or agent framework is entirely responsible for reading these headers, pausing execution, and retrying the tool call. 

Furthermore, all MCP tool execution routes through Truto's proxy API infrastructure. This means that all query and body parameters supplied by the LLM correspond exactly to Chameleon's native schemas—there is no artificial data mapping layer in between. If Chameleon expects a specific nested object for a Segmentation filter, that is exactly what the LLM will generate and send.

## Unblocking Agentic Workflows

Building a custom MCP server for Chameleon forces your engineering team to become experts in Chameleon's specific implementation of JSON schemas, nested filters, and prefix-based environment updates. You inherit the technical debt of maintaining that integration layer indefinitely.

By leveraging Truto's dynamically generated MCP servers, you offload the infrastructure management entirely. Your LLM gets immediate, documented, and secure access to Chameleon's API, allowing your product and support teams to automate onboarding adjustments, analyze survey feedback, and trigger targeted user experiences entirely through natural language.

> Ready to connect Claude to Chameleon and scale your product operations? Get a demo of Truto's managed MCP servers today.
>
> [Talk to us](https://truto.one/book-a-demo/)