---
title: "Connect Clari to ChatGPT: Analyze Sales Calls and Deal Pipelines"
slug: connect-clari-to-chatgpt-analyze-sales-calls-and-deal-pipelines
date: 2026-10-22
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Clari to ChatGPT using a managed MCP server. A complete engineering guide to automating sales calls, pipelines, and scorecards."
tldr: "Connect Clari to ChatGPT using Truto's managed MCP server to orchestrate sales calls, scorecards, and deal pipelines without writing custom API integration code. We cover Clari-specific API realities, 5 hero tools, secure token-based access, and real-world workflows."
canonical: https://truto.one/blog/connect-clari-to-chatgpt-analyze-sales-calls-and-deal-pipelines/
---

# Connect Clari to ChatGPT: Analyze Sales Calls and Deal Pipelines


If you need to connect Clari to ChatGPT to automate pipeline reviews, analyze sales call transcripts, or update deal stages based on conversational intelligence, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between ChatGPT's tool calls and Clari's REST APIs. You can either build and maintain this infrastructure yourself, or use a [managed integration platform](https://truto.one/best-mcp-server-platform-for-ai-agents-connecting-to-enterprise-saas/) like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Clari to Claude](https://truto.one/connect-clari-to-claude-review-scorecards-and-manage-contact-data/) or explore our broader architectural overview on [connecting Clari to AI Agents](https://truto.one/connect-clari-to-ai-agents-automate-call-logging-and-deal-flows/).

Giving a Large Language Model (LLM) read and write access to a revenue platform like Clari is a complex engineering challenge. You have to handle dual API surfaces (CRM data vs. Copilot conversational data), map complex scorecard schemas to MCP tool definitions, and deal with strict rate limits. Every time a developer adds a new custom field to a deal or changes a scorecard template, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Clari, connect it natively to ChatGPT, and execute complex revenue 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 Clari 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 via JSON-RPC, implementing it against Clari's API requires dealing with domain-specific revenue data models. 

If you decide to [build a custom MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) for Clari, you own the entire API lifecycle. Here are the specific integration challenges you will face:

### Dual Data Surfaces: CRM vs Copilot
Clari operates as a unified revenue platform, but under the hood, its API surface is split between CRM synchronization (accounts, contacts, deals) and Copilot intelligence (call recordings, transcripts, scorecards). Your MCP server needs to expose tools for both, but the LLM must know how to join them. A deal might have a `crm_id` that maps back to Salesforce, while a call has a native Clari `id`. If an LLM needs to update a deal based on a call transcript, your tool schemas must clearly define which IDs go where, otherwise the LLM will hallucinate cross-references.

### Heavy Transcripts and N+1 Query Patterns
When an LLM asks "Summarize yesterday's calls," the standard listing endpoint only returns metadata (participants, time, duration). The actual conversational transcript lives on the individual call detail endpoint. This forces an N+1 query pattern. Your MCP server must restrict the LLM from trying to fetch 50 transcripts simultaneously, which would blow up the LLM context window and hit API rate limits. The tool schemas must force the LLM to fetch a curated list of calls first, filter down to the most relevant one, and then request the heavy transcript payload.

### Strict Rate Limits and Missing Automatic Retries
Clari enforces strict API rate limits to protect its infrastructure. A common mistake developers make is expecting the MCP server to magically absorb and retry these limit errors. Truto takes an explicit, transparent approach: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Clari API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller (ChatGPT). 

To help the client handle this, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller - in this case, ChatGPT or your agent orchestration framework - is responsible for reading these headers and executing its own retry and backoff logic. Do not build custom MCP servers assuming the network layer will hide 429s from your LLM.

### Nested Scorecard Schemas
Scorecards in Clari are not flat objects. They rely on `template_id` relationships and deeply nested `questions_score` arrays. A generic JSON mapping will fail here if the schema isn't explicit about the payload hierarchy. Your MCP tool definitions must parse Clari's documentation into strict JSON Schema format so ChatGPT understands exactly how to construct the scoring array when evaluating a rep's performance.

## Step 1: Create the Clari MCP Server

Truto derives MCP tools dynamically from the integration's resource definitions and documentation records. You do not have to write custom JSON-RPC handlers for every Clari endpoint. When you generate an MCP server, Truto packages these tools behind a secure, tokenized endpoint scoped to a single Clari account.

You can create this MCP server using either the Truto dashboard or the API.

### Method A: Via the Truto UI

If you prefer a visual interface, you can generate the server directly from your Truto account:

1. Log into your Truto dashboard and navigate to the integrated account page for your connected Clari instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (name, allowed methods like `read` or `write`, and specific tool tags like `calls` or `deals`).
5. Copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/<secure-token>`.

### Method B: Via the Truto API

For automated deployments, you can provision MCP servers programmatically. Make a POST request to the Truto API to generate the server. This validates that the Clari integration has tools available, generates a hashed secure token, and returns a ready-to-use URL.

```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": "Clari Revenue Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["calls", "deals", "scorecards"]
    }
  }'
```

The API will return a JSON object containing the secure `url`.

```json
{
  "id": "mcp_12345abcde",
  "name": "Clari Revenue Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

This single URL carries both the routing information and the authentication required to execute tools against that specific Clari account. Treat it like a sensitive credential.

## Step 2: Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to ChatGPT takes less than a minute. You can do this through the standard ChatGPT interface or via a local configuration file for custom desktop agents.

### Method A: Via the ChatGPT UI

If you have a ChatGPT Plus, Pro, Team, or Enterprise account with Developer mode enabled, you can add the connector directly in the browser or desktop app.

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Ensure **Developer mode** is toggled on.
3. Under the MCP servers or Custom connectors section, click **Add new server**.
4. Enter a recognizable name (e.g., "Clari Sales Agent").
5. Paste the Truto MCP URL (`https://api.truto.one/mcp/<token>`) into the Server URL field.
6. Click **Save**.

ChatGPT will immediately perform a handshake with the Truto MCP router, request the list of available Clari tools, and register their schemas. Your agent is now ready to interact with Clari.

### Method B: Via Manual Configuration File

If you are running a custom agent framework, testing locally with an MCP inspector, or using a client that requires a file-based configuration, you can connect using a standard JSON config file. Because Truto MCP servers use HTTP POST for all communication, you use the standard Server-Sent Events (SSE) transport wrapper provided by the MCP community.

Create an `mcp.json` configuration file:

```json
{
  "mcpServers": {
    "clari-agent": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your-secure-token>"
      ]
    }
  }
}
```

When your local agent starts, it will use this configuration to connect to Truto's JSON-RPC 2.0 endpoint, downloading the Clari tool definitions dynamically.

## Hero Tools for Clari

Truto automatically generates highly descriptive, snake_case tool names based on the underlying Clari endpoints. When ChatGPT lists available tools, it receives the tool name, a detailed description, and the required JSON schema for query and body parameters. 

Here are the highest-leverage tools available for Clari workflows:

### list_all_clari_calls
Fetches a paginated list of Clari Copilot calls. This is the starting point for conversation intelligence workflows. You can filter by user, attendee, topic, status, or time range. It returns heavy metadata (participants, calendar IDs, media URLs) but omits the full transcript to save bandwidth.

> "Find all discovery calls hosted by Sarah in the last 48 hours that lasted longer than 30 minutes."

### get_single_clari_call_by_id
Retrieves the full, deep payload for a specific call, including the raw transcript, the AI summary, competitor sentiments, and the live deal stage. This tool requires the `id` obtained from the list tool.

> "Get the full transcript for call ID 84729 and list every time the prospect mentioned our competitor's pricing."

### list_all_clari_scorecards
Retrieves rep performance scorecards for specific calls. You can filter by time range, rep, and scorer. This tool exposes the `questions_score` array, showing exactly where a rep succeeded or failed on their methodology rubric.

> "Pull the recent scorecards for the account executive team. Are they consistently asking the MEDDPICC budget questions?"

### list_all_clari_deals
Fetches the current status of a Clari deal by its ID. Returns crucial revenue data including `amount`, `stage`, `close_date`, and `probability`. Essential for checking deal health before making updates.

> "Check the current stage and close probability for the Acme Corp deal."

### clari_deals_bulk_update
Updates deal attributes in Clari. This is a high-leverage write operation that allows your AI agent to advance deal stages, adjust amounts, or push close dates based on signals extracted from calls.

> "The prospect agreed to move forward with the pilot. Update the Acme Corp deal to the 'Commit' stage and set the close date to next Friday."

### create_a_clari_call
Allows you to ingest external audio recordings into Clari Copilot for transcription and analysis. This is critical for bulk migrations from Zoom or Twilio, or for logging ad-hoc mobile calls. Requires `source_id`, `type`, `call_time`, and an `audio_url`.

> "Upload this MP3 recording from my mobile phone to Clari Copilot and log it as an outbound cold call for today."

For a complete list of all available Clari endpoints, required parameters, and schema definitions, view the full inventory on the [Clari integration page](https://truto.one/integrations/detail/clari).

## Workflows in Action

Giving ChatGPT access to these tools transforms it from a static chat interface into an active revenue operations agent. Here are two concrete ways teams use the Clari MCP server.

### Scenario 1: Post-Call Deal Stage Update

Sales reps hate updating their CRM after a call. An AI agent can listen to the transcript, determine if the call was successful, and automatically update the deal stage in Clari.

> "Review my last call with Initech. If they agreed to a technical evaluation, update their deal stage to 'POC' and increase the probability to 60%."

**Step-by-step execution:**
1. **`list_all_clari_calls`**: ChatGPT searches for the most recent call where the external participant matches "Initech".
2. **`get_single_clari_call_by_id`**: ChatGPT extracts the call ID and pulls the full transcript.
3. **Analysis Phase**: The LLM reads the transcript, confirming the prospect explicitly agreed to a technical evaluation.
4. **`list_all_clari_deals`**: ChatGPT queries the CRM side of Clari to find the Initech deal ID and verify its current state.
5. **`clari_deals_bulk_update`**: ChatGPT issues the write command, pushing the new stage and probability to the Clari database.

The user receives a confirmation: *"I found the Initech call. The transcript confirms they agreed to a technical evaluation starting next week. I have updated the deal stage to POC and set the probability to 60%."*

```mermaid
sequenceDiagram
    participant Rep as Sales Rep
    participant ChatGPT as ChatGPT Client
    participant Truto as Truto MCP
    participant Clari as Clari API

    Rep->>ChatGPT: "Review Initech call and update deal if POC agreed."
    ChatGPT->>Truto: tools/call (list_all_clari_calls)
    Truto->>Clari: GET /api/v1/calls?search=Initech
    Clari-->>Truto: Call Metadata (ID: 9912)
    Truto-->>ChatGPT: JSON result
    ChatGPT->>Truto: tools/call (get_single_clari_call_by_id)
    Truto->>Clari: GET /api/v1/calls/9912
    Clari-->>Truto: Full Transcript
    Truto-->>ChatGPT: JSON result
    ChatGPT->>Truto: tools/call (clari_deals_bulk_update)
    Truto->>Clari: PUT /api/v1/deals (Stage: POC)
    Clari-->>Truto: Success
    Truto-->>ChatGPT: JSON result
    ChatGPT-->>Rep: "Deal updated to POC (60%)."
```

### Scenario 2: Automated Rep Coaching

Sales managers spend hours reviewing calls to fill out scorecards. An AI agent can automatically audit calls against the company rubric and generate scorecard data.

> "Analyze yesterday's discovery calls for the enterprise team. Did they successfully cover the BANT criteria? Generate a summary of missed questions."

**Step-by-step execution:**
1. **`list_all_clari_calls`**: ChatGPT filters calls by the "Enterprise" team ID and the "Discovery" call type for the previous day.
2. **`get_single_clari_call_by_id`**: ChatGPT iterates through the top 3 calls, pulling their transcripts.
3. **`list_all_clari_scorecards`**: ChatGPT checks if any scorecards have already been submitted for these calls.
4. **Analysis Phase**: The LLM evaluates the transcripts against the BANT (Budget, Authority, Need, Timeline) framework.

The user receives a detailed breakdown: *"I reviewed 3 discovery calls. In 2 out of 3 calls, the reps successfully established Need and Timeline, but completely missed asking about Budget. I recommend coaching on early budget qualification."*

## Security and Access Control

When connecting an enterprise LLM to financial and revenue data, strict access control is mandatory. Truto MCP servers support multiple layers of configuration to limit what ChatGPT can do.

* **Method Filtering**: You can strictly limit the MCP server to read-only operations. By passing `"methods": ["read"]` during server creation, ChatGPT can invoke `list_all_clari_calls` but will be cryptographically blocked from calling `clari_deals_bulk_update`.
* **Tag Filtering**: You can scope the server by business domain. Passing `"tags": ["calls"]` ensures the LLM can only see conversational intelligence tools and cannot access the underlying CRM deal data.
* **Time-to-Live (TTL)**: For temporary audits or contractor access, you can set an `expires_at` ISO datetime. Truto automatically schedules a durable alarm to permanently delete the server token from the database and edge KV storage when time expires.
* **Extra Authentication**: By default, possessing the MCP URL grants access to the tools. For higher security environments, you can enable `require_api_token_auth`. This forces the ChatGPT client to pass a valid Truto API bearer token in the HTTP headers, ensuring only authenticated developers can execute tools.

## Stop Writing Boilerplate Integrations

Connecting ChatGPT to a dynamic revenue platform like Clari shouldn't require weeks of reading API docs, mapping custom JSON schemas, and fighting with rate limit backoffs. By using a [documentation-driven MCP architecture](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), you shift the burden of tool generation and maintenance to the infrastructure layer.

When Clari updates an endpoint, Truto updates the documentation record, and the MCP tool schema updates dynamically on the next client handshake. Your AI agents always have the correct payload structures, and your engineering team can focus on agent reasoning instead of API maintenance.

> Ready to give your AI agents secure, native access to Clari? Let Truto handle the MCP infrastructure.
>
> [Talk to us](https://truto.one/book-a-demo/)