---
title: "Connect Clari to Claude: Review Scorecards and Manage Contact Data"
slug: connect-clari-to-claude-review-scorecards-and-manage-contact-data
date: 2026-10-22
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Clari to Claude using a managed MCP server. Automate scorecard reviews, analyze Copilot call transcripts, and update CRM deal pipelines."
tldr: "This guide provides a step-by-step engineering tutorial on connecting Clari to Claude via the Model Context Protocol (MCP). Learn how to dynamically generate an authenticated MCP server, expose Clari's Copilot and CRM APIs as native AI tools, and execute workflows like automated scorecard reviews and deal updates using natural language."
canonical: https://truto.one/blog/connect-clari-to-claude-review-scorecards-and-manage-contact-data/
---

# Connect Clari to Claude: Review Scorecards and Manage Contact Data


If your team uses ChatGPT, check out our guide on [/connect-clari-to-chatgpt-analyze-sales-calls-and-deal-pipelines/](https://truto.one/connect-clari-to-chatgpt-analyze-sales-calls-and-deal-pipelines/) or explore our broader architectural overview on [/connect-clari-to-ai-agents-automate-call-logging-and-deal-flows/](https://truto.one/connect-clari-to-ai-agents-automate-call-logging-and-deal-flows/). 

If you need to connect Clari to Claude to analyze sales conversations, review rep scorecards, or automate CRM deal updates based on call intelligence, you need a [Model Context Protocol (MCP) server](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). This server acts as the translation layer between Claude's JSON-RPC 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/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) like Truto to dynamically generate a secure, authenticated MCP server URL.

Giving a Large Language Model (LLM) read and write access to a revenue platform like Clari is a significant engineering challenge. You have to handle API key token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Clari's specific data topologies. Every time Clari updates an endpoint or changes how Copilot transcripts are structured, 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 Clari, connect it natively to Claude, and execute complex [revenue workflows](https://truto.one/connect-clari-to-chatgpt-analyze-sales-calls-and-deal-pipelines/) using natural language.

> Want to give your [AI agents secure, authenticated access to Clari](https://truto.one/connect-clari-to-ai-agents-automate-call-logging-and-deal-flows/) 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 Clari API

A custom MCP server is a [self-hosted integration layer](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/). 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. Clari is built to manage revenue forecasting, deeply analyze conversational intelligence (Copilot), and synchronize with massive CRM databases. Its API reflects that complexity.

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

**Deeply Nested Transcript and Audio Asset Payloads**
Clari Copilot's core value lies in its call data. When you query an endpoint to get a single call's details, you are not just getting basic metadata like the call duration and attendees. The payload includes heavily nested objects containing full transcripts with speaker diarization, AI-generated summaries, sentiment metrics, and URLs for audio and video assets. If you map this directly to an LLM context window without strict JSON schema definitions and pagination limits, the LLM will hallucinate or hit token limits. The MCP tool must explicitly define the schema to extract only the actionable insights (like `summary` and `deal_stage_live`) without overwhelming the agent.

**Complex Relational Topology for Scorecards**
Clari uses a template-to-instance model for scorecards. To evaluate a rep's performance, you cannot simply query a flat `scores` endpoint. You have to navigate the relationship between `scorecard_templates` (which define the questions and acceptable answer rubrics) and the actual `scorecards` applied to specific `call_id`s. Building an LLM tool that understands how to fetch a template, map its questions to a call transcript, and write a new scorecard instance requires exposing a precise set of interconnected operations. 

**Bulk CRM Operations and Partial Failures**
Clari operates as the source of truth for revenue operations, which means its endpoints for accounts, contacts, and deals heavily favor bulk updates (e.g., `clari_deals_bulk_update`). LLMs inherently struggle with bulk array formations unless guided by meticulously engineered OpenAPI specs converted to MCP parameters. Furthermore, if a bulk update encounters a partial failure (e.g., three deals update successfully, one fails due to a locked stage), the API returns a complex 207 Multi-Status response. Your MCP server must parse this and translate it into a readable text response so the LLM knows exactly which deals need remediation.

## How Truto Solves the MCP Translation Layer

Truto operates as an integration orchestration layer. When you connect a Clari account, Truto automatically generates a suite of MCP-compatible tools from the underlying API documentation. 

Here is how the architecture handles the heavy lifting:

*   **Documentation-Driven Tool Generation:** Tools are never cached or pre-built. When Claude queries `/tools/list`, Truto reads the Clari API documentation records and dynamically generates JSON Schema definitions for every query and body parameter. If a Clari endpoint lacks documentation, it does not become a tool - ensuring the LLM only interacts with curated, AI-ready operations.
*   **Flat Input Namespace Resolution:** When Claude invokes a tool, it passes all arguments as a single flat JSON object. Truto's protocol handler intercepts this, reads the underlying query and body schemas, and splits the arguments into the correct locations before proxying the request to Clari.
*   **Strict Rate Limit Handling:** Clari enforces strict API quotas. **Truto does not retry, throttle, or apply backoff on rate limit errors.** When Clari returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller (Claude) and normalizes the upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller is completely responsible for handling the retry/backoff logic based on these headers.

## Step 1: Create the Clari MCP Server

You can generate an MCP server for Clari either through the Truto dashboard or programmatically via the API. Both methods output a secure, tokenized URL that serves the JSON-RPC 2.0 endpoint.

### Method A: Via the Truto UI

1.  Log into your Truto environment and navigate to the integrated account page for your connected Clari instance.
2.  Click the **MCP Servers** tab.
3.  Click **Create MCP Server**.
4.  Configure your server. You can name it (e.g., "Clari Deal Desk AI"), select specific method filters (e.g., restrict to `read` operations to prevent accidental deal modifications), and set an optional expiration date.
5.  Click Save. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method B: Via the API

If you are automating infrastructure provisioning, you can generate the MCP server programmatically. 

Make a `POST` request to `/integrated-account/:id/mcp` with your desired configuration. You can use method filters (like `read`, `write`, `get`, `list`) or tag filters to scope the tools.

```bash
curl -X POST https://api.truto.one/admin/integrated-accounts/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Clari Copilot Analyzer",
    "config": {
      "methods": ["read", "update"],
      "tags": ["calls", "scorecards", "deals"]
    }
  }'
```

The API will return the database record and the secure URL needed to connect Claude:

```json
{
  "id": "mcp_8f7d6e5c",
  "name": "Clari Copilot Analyzer",
  "config": {
    "methods": ["read", "update"],
    "tags": ["calls", "scorecards", "deals"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Step 2: Connect the MCP Server to Claude

Once you have your Truto MCP URL, you can plug it directly into your AI client. The server is completely self-contained; the token in the URL handles the authentication routing to your specific Clari tenant.

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

If you are using a UI-based client that supports custom connectors (like ChatGPT Developer Mode or Claude's web interface when available):

1.  Navigate to **Settings - > Connectors - > Add custom connector** (or equivalent in ChatGPT: **Settings - > Apps - > Advanced settings - > Developer mode**).
2.  Enter a name for the connection (e.g., "Clari CRM Sync").
3.  Paste the Truto MCP URL into the Server URL field.
4.  Click **Add** or **Save**. The client will automatically handshake with the server using the `initialize` method and populate its context window with the available Clari tools.

### Method B: Via the Claude Desktop Config File

For local development and engineering teams using the Claude Desktop app, you can add the server via the configuration file. Because Truto provides the MCP server over HTTP (Server-Sent Events / SSE), you will use the `@modelcontextprotocol/server-sse` package to proxy the connection.

Open your Claude Desktop config file (located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add the following:

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

Restart Claude Desktop. The hammer icon in the input bar will now display the available Clari tools.

## High-Leverage MCP Tools for Clari

Truto derives tools dynamically from the integration's documentation records. When building agents for Clari, you want to focus on high-leverage operations that extract insights from Copilot or update the CRM pipeline. 

Here are the hero tools your LLM can now call natively.

### `list_all_clari_calls`

This tool allows Claude to query the Copilot database for sales calls based on specific filters, such as a specific user, attendee, or time range. It returns the fundamental metadata for up to 100 calls per page, including the `id` required to fetch deeper transcripts.

> "Find all sales calls hosted by john.doe@company.com from the last 7 days that have the status 'completed'. Extract the call IDs."

### `get_single_clari_call_by_id`

This is the workhorse for conversational intelligence. By passing a specific call ID, Claude receives the full transcript, AI-generated summary, competitor sentiments, and the live deal stage associated with the call. 

> "Get the full details and transcript for call ID 883920. Read the transcript and summarize the primary objections the prospect raised regarding our pricing model."

### `list_all_clari_scorecards`

Claude can use this tool to review how sales managers are evaluating reps on specific calls. It returns the scorecard instances, total scores, manager remarks, and question-level scoring. This is critical for building automated coaching agents.

> "Fetch the scorecards for Jane Smith from the past month. Calculate her average score and list out any specific areas where managers left remarks about 'discovery questions'."

### `list_all_clari_contacts`

Revenue operations require context. This tool allows the LLM to fetch a contact from Clari's CRM by ID, retrieving their job title, stage, associated account CRM ID, and custom fields to inform personalized follow-ups.

> "Look up the contact details for CRM ID 10459. Tell me their current stage, job title, and if they are marked as a lead."

### `clari_deals_bulk_update`

Agents can take autonomous action on your pipeline. Based on insights gathered from a call transcript or an email thread, Claude can use this tool to update the stage, amount, or close date of a specific deal.

> "Based on the transcript from the recent call, the customer agreed to move forward. Update the deal in Clari (CRM ID 99283) to the 'Negotiation' stage and change the probability to 75%."

### `create_a_clari_call`

If you have audio files generated outside of Clari (e.g., legacy Zoom recordings or Twilio telephony logs), Claude can orchestrate their ingestion. This tool submits an audio recording URL for transcription and analysis by Clari's Copilot engine.

> "Create a new call record in Clari using this audio URL (https://storage.example.com/call_55.mp3). Set the source ID to 'twilio_55' and the type to 'outbound_prospecting'."

To view the complete inventory of available endpoints and schema details, visit the [Clari integration page](https://truto.one/integrations/detail/clari).

## Workflows in Action

When you combine an LLM's reasoning capabilities with the structured execution of an MCP server, you can build autonomous revenue operations workflows. Here are two real-world examples of how Claude executes multi-step tasks against the Clari API.

### Scenario 1: Automated Deal Pipeline Updates

Sales reps often forget to update their deal stages after a successful call. An AI agent can monitor recent calls, analyze the transcripts, and automatically update the CRM pipeline if buying signals are detected.

> "Review the most recent call for deal ID 77382. If the customer explicitly agreed to pricing and asked for a contract, update the deal stage to 'Closed Won' and adjust the close date to today."

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Clari as "Clari API (Upstream)"

    User->>Claude: "Review the most recent call for deal ID 77382..."
    Claude->>Truto: Call tool `list_all_clari_calls` (query by deal_id)
    Truto->>Clari: GET /api/v1/calls?deal_id=77382
    Clari-->>Truto: Return Call Metadata (id: 1102)
    Truto-->>Claude: Return JSON Array
    
    Claude->>Truto: Call tool `get_single_clari_call_by_id` (id: 1102)
    Truto->>Clari: GET /api/v1/calls/1102
    Clari-->>Truto: Return Full Transcript & Summary
    Truto-->>Claude: Return JSON Object
    
    Note over Claude: LLM analyzes transcript for buying signals.<br>Detects contract request.
    
    Claude->>Truto: Call tool `clari_deals_bulk_update` (crm_id: 77382, stage: Closed Won)
    Truto->>Clari: PATCH /api/v1/deals
    Clari-->>Truto: 200 OK (Deal Updated)
    Truto-->>Claude: Return Updated Deal JSON
    Claude-->>User: "I reviewed the transcript. The customer agreed to pricing. I have updated the deal to Closed Won."
```

**What the user gets back:** Claude confirms that it successfully retrieved the transcript, verified the buying intent using its semantic reasoning, and successfully executed the bulk update tool to advance the deal stage.

### Scenario 2: Automated Manager Coaching and Scorecard Generation

Sales enablement teams need to ensure reps are adhering to playbooks. An agent can retrieve a rep's latest calls, evaluate them against a standard rubric, and surface areas for improvement without a human manager listening to hours of audio.

> "Find the latest completed call for rep alex@company.com. Read the transcript and tell me if he asked the standard MEDDIC discovery questions. Then, fetch his past scorecards to see if this is a recurring issue."

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Clari as "Clari API (Upstream)"

    User->>Claude: "Find the latest completed call for rep alex..."
    Claude->>Truto: Call tool `list_all_clari_calls` (user: alex@company.com)
    Truto->>Clari: GET /api/v1/calls?user=alex@company.com
    Clari-->>Truto: Return Call Metadata (id: 4492)
    Truto-->>Claude: Return JSON Array
    
    Claude->>Truto: Call tool `get_single_clari_call_by_id` (id: 4492)
    Truto->>Clari: GET /api/v1/calls/4492
    Clari-->>Truto: Return Full Transcript
    Truto-->>Claude: Return JSON Object
    
    Claude->>Truto: Call tool `list_all_clari_scorecards` (rep: alex@company.com)
    Truto->>Clari: GET /api/v1/scorecards?rep=alex@company.com
    Clari-->>Truto: Return Scorecard Array
    Truto-->>Claude: Return JSON Array
    
    Note over Claude: LLM cross-references the current transcript<br>against historical scorecard remarks.
    Claude-->>User: "Alex did not ask about the Economic Buyer on this call. Looking at his past 3 scorecards, managers have noted this as an area for improvement twice before."
```

**What the user gets back:** A comprehensive coaching brief. The agent identifies the specific call, analyzes the transcript text for MEDDIC criteria, fetches historical performance data, and synthesizes a specific trend regarding the rep's performance.

## Security and Access Control

Exposing your revenue platform to an autonomous agent requires strict governance. Truto's MCP architecture provides several layers of security configuration when generating a server:

*   **Method Filtering (`config.methods`):** You can restrict an MCP server to specific operation types. For example, setting `methods: ["read"]` ensures the LLM can only query data (like transcripts and lists) and categorically prevents it from executing `create`, `update`, or `delete` operations.
*   **Tag Filtering (`config.tags`):** You can scope the server to specific functional areas of the API. Setting `tags: ["scorecards"]` ensures only tools related to scorecards are exposed, hiding sensitive deal or contact modification endpoints from the agent.
*   **Time-to-Live (`expires_at`):** You can generate ephemeral MCP servers by passing an ISO datetime to the `expires_at` field. Once the timestamp passes, edge storage automatically invalidates the token, instantly revoking the LLM's access to Clari.
*   **Extra Authentication (`require_api_token_auth`):** By default, the cryptographically hashed MCP URL is the only credential needed. For higher-security environments, setting this flag requires the MCP client to also pass a valid Truto API token in the `Authorization` header, enforcing a secondary identity check.

## Next Steps for Clari Automation

Building an AI agent that can reliably parse conversational intelligence, evaluate sales rep performance, and manipulate CRM pipelines requires robust infrastructure. Hardcoding API requests to Clari forces your engineering team to absorb schema drift, complex nested payloads, and pagination logic.

By leveraging Truto's managed MCP architecture, you offload the entire integration lifecycle. Truto handles the OAuth token refreshes, dynamic OpenAPI-to-MCP tool generation, and rate-limit header normalization, allowing you to focus purely on prompt engineering and workflow design.

Your agents get native, structured access to Clari. Your engineers get their time back.