---
title: "Connect Totango to ChatGPT: Automate SuccessPlays and Account Tasks"
slug: connect-totango-to-chatgpt-automate-successplays-and-account-tasks
date: 2026-10-19
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Totango to chatgpt using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows."
canonical: https://truto.one/blog/connect-totango-to-chatgpt-automate-successplays-and-account-tasks/
---

# Connect Totango to ChatGPT: Automate SuccessPlays and Account Tasks


If you want to connect Totango to ChatGPT so your [AI agents](https://truto.one/connect-totango-to-ai-agents-manage-usage-data-and-system-users/) can execute SuccessPlays, update account health scores, log touchpoints, and manage users, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's function calls and Totango's REST APIs. You can either spend weeks building and maintaining this infrastructure in-house, 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 Totango to Claude](https://truto.one/connect-totango-to-claude-sync-objectives-and-touchpoint-activities/) or explore our broader architectural overview on [connecting Totango to AI Agents](https://truto.one/connect-totango-to-ai-agents-manage-usage-data-and-system-users/).

Giving a Large Language Model (LLM) read and write access to a Customer Success platform like Totango is an engineering challenge. You have to handle irreversible async bulk updates, complex search envelopes, and entirely separate API paradigms for system users versus account users. Every time a Customer Success Manager adds a new custom attribute, your custom server code must be updated to expose that schema to the LLM.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Totango, connect it natively to ChatGPT, and execute complex customer success 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 Totango API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Totango's highly specific API surfaces is exceptionally painful.

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

### Asynchronous Ingestion and Irreversible Batch Updates
Totango handles data updates (accounts, users, collections, usage) via asynchronous batch endpoints. When you call an endpoint like `update_a_totango_account_by_id`, you can submit up to 1,000 accounts at once. However, Totango does not process these synchronously. It returns a 202 Accepted with a `batch_id` and a `status` of "received". More importantly, once an update is accepted, it is strictly irreversible. If your LLM hallucinates a field mapping or overwrites a critical tag, there is no "undo" endpoint. Your MCP server must be extremely strict about input validation before letting the model write data.

### Complex Search Envelopes
When an LLM searches for accounts or users, Totango's search API doesn't just return a flat array of records. It requires you to submit specific `query`, `terms`, and `fields` parameters, and it returns a nested envelope. The actual data lives buried under `response.accounts.hits` (or `response.events.hits`), along with pagination metadata like `total_hits`. If your MCP server doesn't parse and flatten this envelope, the LLM will struggle to understand the results and often hallucinate pagination cursors.

### The SCIM vs. Core API Divide
Totango uses two completely different API paradigms. Account data, usage metrics, and touchpoints use Totango's core REST API. But if you need your agent to manage *internal* users (your CSMs), you must interact with the [Totango SCIM API](https://truto.one/automate-scim-user-management-with-ai-agents/). SCIM requires strict patch operations (`Operations`) and specific schema headers (`urn:ietf:params:scim:schemas:core:2.0:User`). Building a unified MCP server means you have to maintain separate authentication scopes and payload builders for these two parallel systems.

## Step 1: Generate a Totango MCP Server in Truto

Truto eliminates these engineering headaches by dynamically generating MCP tools from its managed proxy APIs. Because tool generation is documentation-driven, Truto automatically parses Totango's schemas and converts them into LLM-friendly JSON-RPC tool definitions.

Each MCP server is scoped to a single connected Totango account. You can create this server through the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

1. Log in to the Truto dashboard and navigate to **Integrated Accounts**.
2. Select your connected Totango account to open the details page.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can optionally filter by `methods` (e.g., read-only access) or `tags` to limit what the LLM can touch.
6. Click **Create** and copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For teams building automated onboarding flows, you can generate MCP servers programmatically. Send a `POST` request to `/integrated-account/:id/mcp`.

```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": "Totango CSM Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["accounts", "tasks", "touchpoints", "successplays"]
    }
  }'
```

The API response includes the `url` field. This URL contains a cryptographically hashed token that securely routes requests to that specific Totango tenant. Treat this URL like a secret.

## Step 2: Connect the MCP Server to Your AI Client

Once you have your Truto MCP URL, connecting it to an AI client is trivial. The URL handles all authentication and protocol handshakes automatically.

### Method A: Via the ChatGPT UI (Developer Mode)

1. Open ChatGPT and go to **Settings**.
2. Navigate to **Apps -> Advanced settings**.
3. Ensure **Developer mode** is toggled on (requires a Pro, Plus, Enterprise, or Education tier).
4. Click **Add custom connector** under the MCP servers list.
5. Name the connector (e.g., "Totango Agent") and paste your Truto MCP URL.
6. Click **Save**. ChatGPT will instantly initialize the connection and list the available Totango tools.

*(Note: If you are connecting [Claude Desktop](https://truto.one/connect-totango-to-claude-sync-objectives-and-touchpoint-activities/) instead, go to **Settings -> Integrations -> Add MCP Server**, paste the URL, and save.)*

### Method B: Via Manual Config File (CLI / Custom Agents)

If you are running a custom agent framework (like LangGraph or CrewAI) or a local IDE client like Cursor, you can connect via a standard SSE configuration file. 

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

## Totango Hero Tools for ChatGPT

Once connected, your agent has access to all documented Totango resources. Instead of dumping raw JSON payloads, the LLM will utilize these highly curated tools. Here are the highest-leverage operations for a Customer Success agent.

### Search Totango Accounts
`totango_accounts_search`

Searches Totango accounts matching specific filter criteria. It returns the structured response envelope, including the `total_hits` and `accounts.hits` arrays. Because Totango caps pagination at 1,000 records, the tool automatically injects offset cursor hints for the LLM.

> "Find all Enterprise tier accounts in Totango that have a health score of 'Poor' and haven't had any activity in the last 30 days. Return their display names and Account IDs."

### Batch Update Accounts
`update_a_totango_account_by_id`

Creates or updates Totango accounts in batch with their attributes and tags. This tool accepts up to 1,000 accounts per request. It returns a `batch_id` and the number of accepted updates. Because this is an irreversible async operation, agents should be prompted to verify the payload before executing.

> "Update the account with ID 'acct_9921' to set its renewal status to 'At Risk' and add the tag 'Q3_Churn_Watch'."

### Log a Touchpoint
`create_a_totango_touchpoint`

Creates a new touchpoint (note or meeting log) on a Totango account. This is critical for agents acting as AI assistants for CSMs, allowing them to summarize emails or calls and immediately log them to the customer record.

> "Log a new touchpoint for Account ID 'acct_104'. The content should be a summary of our recent onboarding call, highlighting that the client successfully integrated their SSO provider."

### Manage CSM Tasks
`create_a_totango_task`

Creates a task assigned to a specific user for a specific account. This tool requires the `activity_type_id` and `account_id`, allowing the agent to orchestrate follow-ups based on account health drops.

> "Create a task for the CSM on account 'acct_455' to review the upcoming Q4 renewal. Set the due date for next Tuesday."

### Run a SuccessPlay
`totango_successplays_run`

Executes a manual Totango SuccessPlay for a given account. This triggers the configured action within Totango (like automatically generating a suite of tasks or requesting information via a form). The target SuccessPlay must be configured as manual and active.

> "Trigger the 'Executive Escalation' SuccessPlay for Account ID 'acct_882'."

### List Timeline Events
`list_all_totango_events`

Lists the events on an account's timeline, including touchpoints, tasks, alerts, and campaign events. This tool is essential for providing the LLM with historical context before it generates an email or updates an objective.

> "Fetch the last 10 timeline events for Account 'acct_301'. Summarize the recent support alerts and CSM notes to tell me why their health score dropped."

### Manage Objectives
`create_a_totango_objective`

Creates a new objective on a Totango account. Objectives are used to track long-term goals like "Complete Implementation" or "Expand License Count." The agent can define manual or attribute-driven milestones.

> "Create a new objective on account 'acct_702' called 'Drive Platform Adoption'. Add two milestones: one for completing the training webinar, and another for 50 active daily users."

To view the complete inventory of available tools and their underlying JSON schemas, visit the [Totango integration page](https://truto.one/integrations/detail/totango).

## Workflows in Action

Exposing individual endpoints to an LLM is useful, but the real power of MCP is workflow orchestration. Here is how ChatGPT chains Totango tools together to solve complex CS problems autonomously.

### Workflow 1: Automated Churn Risk Triage

When a high-value account shows signs of churn, speed is critical. Instead of a CSM manually digging through dashboards, they can ask the agent to triage the situation and orchestrate the response.

> "Find the 'Globex' account. Review their recent timeline events and touchpoints. If there are signs of churn, trigger the 'Executive Escalation' SuccessPlay and create a task for me to follow up tomorrow."

1. **`totango_accounts_search`**: The agent searches for "Globex" to resolve the exact Account ID and current health score.
2. **`list_all_totango_events`**: The agent fetches the timeline events for that ID, analyzing recent notes and alerts.
3. **`totango_successplays_run`**: The agent determines the account is at risk and executes the manual escalation SuccessPlay.
4. **`create_a_totango_task`**: The agent logs a task on the account for the CSM to follow up.

```mermaid
sequenceDiagram
    participant Agent as "ChatGPT (Agent)"
    participant Truto as "Truto MCP Server"
    participant Upstream as "Totango API"

    Agent->>Truto: Call totango_accounts_search
    Truto->>Upstream: GET /api/v3/search/accounts
    Upstream-->>Truto: Return response.accounts.hits
    Truto-->>Agent: Map JSON payload
    
    Agent->>Truto: Call list_all_totango_events
    Truto->>Upstream: GET /api/v3/events
    Upstream-->>Truto: Return timeline events
    Truto-->>Agent: Map JSON payload
    
    Agent->>Truto: Call totango_successplays_run
    Truto->>Upstream: POST /api/v3/successplays
    Upstream-->>Truto: Return 'Success'
    Truto-->>Agent: Confirm execution
```

### Workflow 2: Post-EBR Account Realignment

After an Executive Business Review (EBR), a CSM typically has to update account statuses, log their notes, and set new objectives. The agent can handle this entire administrative burden.

> "I just finished the EBR for Initech (ID: acct_554). They are renewing early! Update their status to 'Committed', log a touchpoint summarizing the early renewal, and create a new objective to 'Expand to EMEA office'."

1. **`update_a_totango_account_by_id`**: The agent dispatches a batch update payload to change the account's renewal status field. It captures the async `batch_id`.
2. **`create_a_totango_touchpoint`**: The agent creates a detailed meeting note summarizing the user's prompt.
3. **`create_a_totango_objective`**: The agent initializes the new expansion objective on the account.

```mermaid
sequenceDiagram
    participant Agent as "ChatGPT (Agent)"
    participant Truto as "Truto MCP Server"
    participant Upstream as "Totango API"

    Agent->>Truto: Call update_a_totango_account_by_id
    Truto->>Upstream: POST /api/v3/accounts
    Upstream-->>Truto: Return batch_id<br>Status: received
    Truto-->>Agent: Return batch_id
    
    Agent->>Truto: Call create_a_totango_touchpoint
    Truto->>Upstream: POST /api/v3/touchpoints
    Upstream-->>Truto: Return note ID
    Truto-->>Agent: Confirm touchpoint
```

## Security and Access Control

Giving an AI agent access to your primary Customer Success database requires strict boundaries. Truto provides several layers of access control directly on the MCP token:

* **Method Filtering:** By passing `"methods": ["read"]` during server creation, you can physically prevent the server from generating any `create`, `update`, or `delete` tools. The LLM simply won't know those operations exist.
* **Tag Filtering:** Integrations in Truto map resources to tags. Passing `"tags": ["accounts"]` ensures the agent can query accounts, but cannot execute SuccessPlays or modify system SCIM users.
* **Time-to-Live (TTL):** Setting an `expires_at` timestamp creates an ephemeral MCP server. Truto's background durable alarms will automatically destroy the token and KV entries when time expires.
* **API Token Auth (`require_api_token_auth`):** For high-security environments, possessing the MCP URL isn't enough. You can enforce a second layer of authentication, requiring the client to pass a valid Truto API bearer token to execute tools.

## Handling Rate Limits

Totango enforces strict rate limits across its endpoints, particularly on heavy operations like search and bulk updates. It is a critical architectural fact that **Truto does not retry, throttle, or apply backoff on rate limit errors.** 

When the upstream Totango API returns an HTTP 429 Too Many Requests, Truto passes that exact error back to the caller. However, Truto actively normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. 

Because Truto operates as a transparent proxy for tool execution, the caller (your agent orchestrator or ChatGPT) is entirely responsible for reading these normalized headers and implementing its own retry or backoff logic. Truto will not automatically absorb rate limit errors, ensuring your system architecture remains fully aware of upstream capacity constraints.

## Final Thoughts

Connecting ChatGPT to Totango transforms an LLM from a passive text generator into an active participant in your Customer Success workflows. Instead of writing custom polling logic for async batch updates or battling SCIM schemas, you can rely on Truto's auto-generated MCP server to handle the protocol translation.

By leveraging dynamic tool generation, you ensure that your AI agents always have access to the latest APIs and documentation, secured by strict method and tag boundaries. Stop writing integration boilerplate and start orchestrating workflows.

> Ready to connect your AI agents to Totango? Get started with Truto and deploy production-ready MCP servers in minutes.
>
> [Talk to us](https://truto.one/book-a-demo/)