---
title: "Connect Chorus to Claude: Analyze Sales Insights & Scorecards"
slug: connect-chorus-to-claude-analyze-sales-insights-scorecards
date: 2026-06-08
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "A step-by-step technical guide to connecting Chorus (ZoomInfo) to Claude via Truto's MCP Server. Automate sales call analysis, SQF extraction, and scorecard reviews."
tldr: "Learn how to expose Chorus API endpoints to Claude using Truto's Model Context Protocol (MCP) server. We cover authentication, tool execution, asynchronous workflows, and building real-world AI sales workflows."
canonical: https://truto.one/blog/connect-chorus-to-claude-analyze-sales-insights-scorecards/
---

# Connect Chorus to Claude: Analyze Sales Insights & Scorecards


Analyzing sales calls, extracting deal insights, and tracking rep performance traditionally requires jumping between your CRM, your inbox, and conversational intelligence platforms like Chorus (by ZoomInfo). By leveraging the [Model Context Protocol (MCP)](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms), you can bridge that gap, giving Anthropic's Claude direct, secure access to your Chorus data.

This guide demonstrates how to connect Chorus to Claude using Truto's MCP Server. If your team uses other LLM frameworks, check out our sibling guides on [connecting Chorus to ChatGPT](https://truto.one/connect-chorus-to-chatgpt-manage-meetings-team-workflows/) or [connecting Chorus to AI Agents](https://truto.one/connect-chorus-to-ai-agents-automate-call-recording-crm-sync/).

By the end of this guide, you will have a functional pipeline allowing Claude to query call transcripts, evaluate scorecards, and push insights directly into your Sales Qualification Framework (SQF) - entirely through natural language.

## Creating the Chorus MCP Server

Truto automatically generates an MCP-compliant JSON-RPC 2.0 server based on the endpoints exposed by the Chorus integration. You can provision this server via the Truto UI or programmatically via the API. For those interested in the underlying mechanics, see our [hands-on guide to building MCP servers](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026).

### Option 1: Via the Truto UI

1. Navigate to your connected Chorus account in the Truto dashboard.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Give your server a name (e.g., "Chorus Sales Analyst").
5. Configure any desired method or tag filters (e.g., restrict to `read` methods only).
6. Click Save and copy the generated MCP server URL.

### Option 2: Via the Truto API

For platform engineers building scalable internal tooling, you can provision MCP servers programmatically using the integrated account ID. 

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

```bash
curl -X POST https://api.truto.one/integrated-account/<CHORUS_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Desktop - Chorus Ops",
    "config": {
      "methods": ["read", "custom"]
    }
  }'
```

The response contains the exact URL you will need to configure Claude:

```json
{
  "id": "mcp_12345",
  "name": "Claude Desktop - Chorus Ops",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting to Claude

Once your server is provisioned, you need to register it with Claude. This setup allows you to expand Claude's capabilities, much like how you might [scale batch tasks or file processing](https://truto.one/connect-anthropic-to-claude-scale-batch-tasks-file-processing) for other data types. You can do this using the Claude application UI or by modifying the local configuration file.

### Option 1: Claude Desktop UI

1. Open Claude Desktop.
2. Navigate to **Settings > Connectors > Add custom connector**.
3. Paste the Truto MCP URL generated in the previous step.
4. Click **Add**.

### Option 2: Manual Configuration File

Alternatively, you can edit the `claude_desktop_config.json` file directly. 

*   **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
*   **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

Add the Truto endpoint under your `mcpServers` block:

```json
{
  "mcpServers": {
    "chorus_integration": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```
Restart Claude to initialize the connection. Claude will send an `initialize` JSON-RPC handshake to Truto, returning the server's capabilities and auto-generated tools.

## Security and Access Control

Exposing enterprise conversational intelligence data to an LLM requires strict boundary setting. Truto's MCP tokens provide several layers of access control configured directly at the server level:

*   **Method Filtering**: Restrict Claude to read-only operations by passing `methods: ["read"]` during server creation. This prevents accidental data deletion or writes.
*   **Tag Filtering**: Scope the MCP server to specific resource domains. For example, `tags: ["scorecards"]` limits Claude to reviewing rep performance without exposing core meeting transcripts.
*   **Secondary Authentication (`require_api_token_auth`)**: When enabled, possessing the MCP URL is not enough. The client must also pass a valid Truto API token in the `Authorization` header, enforcing strict identity checks.
*   **Auto-Expiration (`expires_at`)**: Ideal for temporary audit access or contractor workflows. Set an ISO timestamp, and the server will automatically revoke itself without manual cleanup.

## Engineering Reality: Chorus API Quirks

The Chorus API is incredibly powerful, but it has a few specific architectural nuances you must plan for when orchestrating AI agents.

**Asynchronous Media Workflows**: Extracting recordings or generating CSV exports of reports is not instantaneous. Endpoints like `chorus_reports_export` and `chorus_conversations_export` return a task ID. Your LLM must be instructed to poll these task statuses until completion, rather than expecting a binary payload in the immediate HTTP response.

**Complex SQF Payloads**: Writing back CRM fields via the `chorus_sales_qualifications_writeback_crm` endpoint requires precise coordination. The API expects an exact schema mapping (`meeting_id`, `opportunity_id`, `object_type`, and the nested `crm_changes` array). When prompting Claude to execute this, explicitly define the CRM object structure it should construct.

**Strict Rate Limits**: Chorus strictly limits API consumption. **Truto does not absorb, throttle, or automatically retry HTTP 429 Too Many Requests errors.** If Chorus rate-limits the request, Truto passes the 429 directly back to Claude, normalizing the rate limit context into IETF standard headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). Your application or agent must manage exponential backoff independently.

## Chorus MCP Tool Inventory

Truto automatically generates tool names from the integration's resource labels and methods, turning REST parameters into JSON Schemas that Claude understands.

### Hero Tools

Here are the highest-impact tools for sales analysis workflows:

#### `get_single_chorus_conversation_by_id`
Fetch a complete conversation object, including the meeting summary, action items, participants, and trackable metrics.
*   **Usage Notes**: Requires the exact `id` of the conversation. Use `list_all_chorus_conversations` first if you need to search for a specific meeting.
*   **Example Prompt**: "Get the conversation details for meeting ID 987654. Summarize the action items and tell me if the prospect mentioned pricing constraints."

#### `list_all_chorus_conversations`
Query the engagements endpoint to find meetings matching specific date ranges, owners, or processing states.
*   **Usage Notes**: Handles cursor-based pagination. Claude will automatically receive and pass the `next_cursor` parameter if the results exceed the default limit.
*   **Example Prompt**: "List all Chorus conversations from last week where the processing_state is complete."

#### `get_single_chorus_sales_qualification_by_id`
Extract the SQF (Sales Qualification Framework) analysis for a given recording, including tracked changes and conversation duration.
*   **Usage Notes**: Pass the `recording_id` as the primary `id`. Excellent for automating MEDDIC or BANT extraction.
*   **Example Prompt**: "Pull the sales qualification analysis for recording ID 12345. Did the rep successfully identify the economic buyer?"

#### `list_all_chorus_scorecards`
Fetch submitted scorecard evaluations for sales reps, including specific question scores, initiatives, and reviewers.
*   **Usage Notes**: Useful for aggregating rep performance over time to spot coaching opportunities.
*   **Example Prompt**: "List all scorecards submitted for Sarah this month. Calculate her average score on the 'objection handling' metric."

#### `chorus_conversations_join`
Instruct the Chorus bot to join a live meeting via a plain text invitation link.
*   **Usage Notes**: The body schema requires the full meeting text (e.g., a standard Zoom invite). 
*   **Example Prompt**: "Have Chorus join this live meeting. Here is the invite link: https://zoom.us/j/5551234567"

For the complete tool inventory and full schema details, visit the [Chorus integration page](https://truto.one/integrations/detail/chorus).

## Workflows in Action

Integrating Claude with Chorus transforms static call recordings into an active, conversational CRM assistant. Here is how specific roles can use these MCP tools.

### Workflow 1: The Post-Call Deal Briefing

Sales Managers need immediate visibility into high-value deals without listening to 45-minute call recordings.

> "Find the most recent conversation associated with the Acme Corp deal. Extract the summary, list all the action items assigned to our team, and fetch the Sales Qualification analysis to see if they mentioned a specific budget."

**Execution Steps:**
1. Claude calls `list_all_chorus_conversations` passing "Acme Corp" as a query parameter.
2. Claude extracts the `id` of the most recent MEETING engagement.
3. Claude calls `get_single_chorus_conversation_by_id` to parse the `summary` and `action_items` arrays.
4. Claude calls `get_single_chorus_sales_qualification_by_id` to check the `sqf_analysis` fields for budget indicators, returning a synthesized brief to the manager.

### Workflow 2: Automated Coaching Scorecards

Enablement teams can use Claude to analyze rep performance trends and flag coaching gaps.

> "Pull all the scorecards submitted for John Doe in Q3. Review his scores across all meetings. If his 'Discovery' score averages below 3.0, list the meeting IDs where he struggled so I can build a training playlist."

**Execution Steps:**
1. Claude calls `list_all_chorus_scorecards`, filtering for the target rep and date range.
2. Claude parses the `scores` objects within the response.
3. Claude calculates the average for the "Discovery" metric.
4. If the logic is triggered, Claude identifies the `engagement_id` for low-scoring calls and returns the list.
5. (Optional) Claude could autonomously call `create_a_chorus_playlist` and `chorus_playlists_create_moment` to build the actual training asset.

## Wrapping Up

Connecting Chorus to Claude via Truto's MCP servers replaces rigid dashboards with a fluid, natural language interface for conversational intelligence. By auto-generating schemas directly from documentation, Truto ensures that your AI agents have complete, secure, and type-safe access to every resource Chorus provides.

> Ready to connect your AI agents to Chorus and 100+ other enterprise APIs? Get started with Truto today.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)