---
title: "Connect Gong to ChatGPT: Analyze Call Transcripts & Activity"
slug: connect-gong-to-chatgpt-analyze-call-transcripts-activity
date: 2026-06-08
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to securely connect Gong to ChatGPT using a managed MCP server. This step-by-step guide covers handling complex Gong APIs, AI tool calling, and workflow automation."
tldr: "Connect Gong to ChatGPT via a managed MCP server to automate call transcript analysis and activity audits. This guide shows how to securely expose Gong API tools, manage authentication scopes, and execute AI workflows without building custom connectors."
canonical: https://truto.one/blog/connect-gong-to-chatgpt-analyze-call-transcripts-activity/
---

# Connect Gong to ChatGPT: Analyze Call Transcripts & Activity


If you need your AI agents to analyze sales calls, audit team activity, or extract intelligence from Gong transcripts, you need to connect Gong to ChatGPT. To do this securely and reliably, you must use 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 ChatGPT's tool calls and Gong's REST APIs. If your team uses Claude, check out our guide on [connecting Gong to Claude](https://truto.one/connect-gong-to-claude-manage-engage-flows-sales-tasks/) or explore our broader architectural overview on [connecting Gong to AI Agents](https://truto.one/connect-gong-to-ai-agents-generate-ai-briefs-coaching-insights/).

Giving a Large Language Model (LLM) read and write access to a revenue intelligence platform like Gong is a significant engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and navigate Gong's specific API quirks. Every time Gong updates an endpoint or deprecates a field, 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 Gong, connect it natively to ChatGPT, and execute complex workflows using natural language.

## The Engineering Reality of the Gong API

A custom MCP server is a self-hosted integration layer. While the open [MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools, the reality of implementing it against Gong's API - or [maintaining custom connectors for 100+ other platforms](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/) - is painful.

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

### Hyper-Granular OAuth Scopes
Gong does not offer a single "read" or "write" permission. Their authorization model relies on highly specific scopes. For example, reading basic call metadata requires `api:calls:read:basic`, while getting the actual conversation requires `api:calls:read:transcript`, and getting detailed participant data requires `api:calls:read:extensive`. If your LLM decides to summarize a call, your MCP server must ensure the underlying token possesses the exact transcript scope, or the API will silently reject the request. Managing these scopes dynamically across different AI agent personas is complex.

### Asynchronous Processing and Two-Step Operations
Gong's API frequently relies on asynchronous processing. If you want an agent to upload external call media to Gong, it cannot just send an audio file in a single request. It must first create a call record, extract the returned `callId`, and then execute a secondary follow-up request to the media endpoint. If your custom server does not handle this stateful dependency, the LLM will hallucinate the upload success. Similarly, CRM syncs and data privacy deletions (like erasing a contact) happen asynchronously and require polling a status endpoint.

### Strict Rate Limiting and 429 Handling
Gong enforces strict concurrency and volumetric rate limits to protect their infrastructure. When connecting an LLM to Gong, the AI agent can easily fire off dozens of concurrent tool calls to fetch multiple transcripts or analyze a broad date range. 

It is critical to note a factual point on how managed infrastructure handles this: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Gong API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The LLM orchestrator or client is entirely responsible for implementing retry and backoff logic. Do not assume the integration layer will magically absorb rate limit errors.

## The Managed MCP Server Approach

Instead of forcing your engineering team to build, host, and maintain a custom Node.js or Python MCP server, you can use Truto. Truto derives tool definitions dynamically from Gong's API specification and human-readable documentation records. 

Tools are generated dynamically on every `tools/list` request. A tool only appears in the MCP server if it has a corresponding documentation entry - this acts as a quality gate to ensure only well-documented, curated endpoints are exposed to the LLM. 

Because each MCP server is scoped to a single integrated account via a cryptographic token, the server URL alone is enough to authenticate and serve tools. There is no additional configuration needed on the client side.

## How to Generate a Gong MCP Server

You can create an MCP server for your connected Gong instance in two ways: via the Truto user interface or programmatically via the REST API.

### Method 1: Via the Truto UI

For internal teams or ad-hoc agent deployments, the UI is the fastest path.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard.
2. Select the connected Gong account you want to expose to ChatGPT.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restrict to "read" methods only, or filter by specific tool tags).
6. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/your-secure-token`).

### Method 2: Via the Truto API

For programmatic, multi-tenant deployments, you can generate MCP servers dynamically. The Truto API validates the configuration, generates a secure token, and returns a ready-to-use URL.

**Endpoint:** `POST /integrated-account/:id/mcp`

```json
{
  "name": "Gong Sales Analysis Agent",
  "config": {
    "methods": ["read", "custom"]
  },
  "expires_at": "2026-12-31T23:59:59Z"
}
```

The API response will include the unique URL needed to connect the LLM client:

```json
{
  "id": "mcp_12345abcde",
  "name": "Gong Sales Analysis Agent",
  "config": {
    "methods": ["read", "custom"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## How to Connect the Gong MCP Server to ChatGPT

Once you have your MCP URL, you can route it into ChatGPT. There are two primary ways to do this, depending on your setup.

### Method A: Via the ChatGPT UI (Custom Connectors)

If you are using ChatGPT Enterprise, Plus, Pro, or Team plans, you can add the MCP server directly in the client.

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable the **Developer mode** toggle (MCP support requires this flag to be active).
3. Under **MCP servers / Custom connectors**, select **Add a new server**.
4. **Name:** Enter a descriptive label, like "Gong AI Analytics".
5. **Server URL:** Paste the Truto MCP URL you generated in the previous step.
6. Save the configuration. ChatGPT will immediately perform a handshake, discover the available tools, and make them available in your chat context.

### Method B: Via Manual Config File (Local/CLI Orchestrators)

If you are running a custom ChatGPT wrapper, an orchestrator, or a local testing client, you can use the standard MCP configuration file approach via Server-Sent Events (SSE).

Create or update your `mcp.json` file:

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

When your agent initializes, it will proxy the JSON-RPC traffic through the SSE transport layer securely.

## Core Gong AI Tools

When ChatGPT connects to the Gong MCP server, it gains access to the specific resources defined by the integration. Here are 6 high-leverage hero tools your AI agent can use to orchestrate Gong data.

### List All Gong Calls

This tool allows the LLM to query calls within a specific date range. It handles pagination seamlessly by explicitly instructing the LLM to pass back the `nextCursor` value exactly as received.

**Contextual Note:** Requires the `api:calls:read:basic` OAuth scope.

> "Find all Gong calls that took place last week and summarize the total number of meetings held."

### Get Single Gong Call by ID

This tool retrieves highly specific metadata for a single call, including participant details, duration, CRM context, and hosting information.

**Contextual Note:** Requires the `api:calls:read:basic` scope.

> "Get the details for the call ID '88392019' and list all external participants who joined the meeting."

### Create a Gong Calls Transcript

This is a critical custom method that fetches the actual conversational text. Because transcripts can be massive, the schema enforces date period constraints or specific Call IDs.

**Contextual Note:** Requires the `api:calls:read:transcript` scope.

> "Fetch the transcript for call ID '88392019' and extract all mentions of our competitor, Acme Corp."

### List All Gong Entities Get Briefs

This tool triggers Gong's native AI to generate a brief for a specific Account, Deal, Contact, or Lead. It utilizes the brief templates set up in Gong Agent Studio. 

**Contextual Note:** Requires the `api:ai-briefer:read` scope. Note that calling this API consumes Gong credits based on the volume of underlying emails and calls processed.

> "Generate an AI brief for the 'Stark Industries' deal in our CRM using the 'Executive Summary' brief template."

### Create a Gong Activity Aggregate by Period

This analytics tool pulls aggregated activity statistics for team members. It returns counts of calls, listens, comments, and other actions grouped by a specific time period.

**Contextual Note:** Useful for auditing team performance without having to parse individual call records.

> "Pull the activity aggregates for the sales team for the month of October and identify who had the highest number of calls and comments."

### List All Gong Users

This tool provides a complete directory of all company users within Gong, mapping their internal IDs to email addresses and active states.

**Contextual Note:** Requires the `api:users:read` scope. Crucial for mapping user IDs to the activity and call data endpoints.

> "List all active Gong users and cross-reference their IDs against the activity data from last week."

For the complete tool inventory, detailed JSON schemas, and required properties for every endpoint, view the [Gong integration page](https://truto.one/integrations/detail/gong).

## Workflows in Action

Exposing these tools to ChatGPT enables complex, multi-step automations. Here is how an AI agent uses the Gong MCP server in real-world scenarios.

### Scenario 1: The Post-Mortem Sales Analysis

A Sales Manager wants to understand why a major deal was lost by analyzing recent conversations.

> "Find all calls related to the 'Initech' account from the last 30 days. Pull the transcripts for those calls, and give me a summary of the main objections the prospect raised."

**Execution Steps:**
1. The agent calls `list_all_gong_calls`, passing a date range filter and looking for CRM associations matching 'Initech'.
2. It extracts the `callId` from the resulting list.
3. It calls `create_a_gong_calls_transcript` using those extracted Call IDs to pull the raw text.
4. The LLM processes the massive transcript text in context, identifies the specific objections, and formats a summary for the manager.

### Scenario 2: Sales Ops Activity Audit

A Revenue Operations leader needs to audit platform usage to ensure reps are actively engaging with call recordings and providing feedback.

> "Pull the activity aggregates for all account executives over the last quarter. Flag any rep who has zero 'listens' or 'comments' in the system."

**Execution Steps:**
1. The agent calls `list_all_gong_users` to get the master list of reps and their Gong IDs.
2. It calls `create_a_gong_activity_aggregate_by_period`, passing the date ranges for the last quarter.
3. The agent cross-references the activity data against the user list.
4. The LLM evaluates the `listens` and `comments` counters, returning a formatted list of low-engagement users.

### Scenario 3: Automated Executive Briefings

A VP of Sales is heading into a renewal meeting and needs a top-level summary of the account's health based on native Gong insights.

> "Get the executive brief for the 'Pied Piper' renewal deal. Then, find the most recent call with that account and summarize the final 10 minutes."

**Execution Steps:**
1. The agent calls `list_all_gong_entities_get_briefs`, providing the CRM Deal ID and requesting the specific brief name.
2. It calls `list_all_gong_calls` with the Deal ID to find the chronologically most recent meeting.
3. It calls `create_a_gong_calls_transcript` for that specific call.
4. The LLM synthesizes the AI Brief with the final segment of the transcript, outputting a high-signal prep document.

## Security and Access Control

When providing an LLM access to sensitive revenue intelligence data, strict governance is non-negotiable. Truto's MCP architecture provides four layers of access control at the server configuration level:

*   **Method Filtering:** You can enforce strict boundary conditions by configuring the MCP server to only allow `read` operations. If the LLM hallucinates and attempts to call `create_a_gong_call` or update user access, the server will block the JSON-RPC request entirely.
*   **Tag Filtering:** Tools can be grouped by functional area. You can restrict an MCP server to only expose tools tagged with "analytics" or "users", ensuring the LLM cannot access unrelated resources like CRM integrations or Engage flow controls.
*   **Require API Token Auth:** By default, the MCP token in the URL authenticates the request. For high-security environments, you can set `require_api_token_auth: true`. This forces the ChatGPT client to pass a valid Truto API token in the Authorization header, preventing access if the URL is ever exposed in logs.
*   **Expiration Controls:** Servers can be generated with a strict `expires_at` timestamp. This is ideal for short-lived agent sessions. Once the timestamp is reached, the distributed KV store expires the token automatically, and scheduled cleanup alarms wipe the database records.

## Strategic Wrap-Up

Connecting Gong to ChatGPT using an MCP server transforms static sales data into an interactive, agentic workflow. Instead of writing custom integration scripts to manage OAuth, handle complex asynchronous API flows, and marshal massive JSON payloads, you can rely on a generated, managed infrastructure layer.

By leveraging Truto, your engineering team bypasses the boilerplate of integration maintenance. You can deploy secure, strictly scoped MCP servers that give your AI agents exactly the tools they need - and nothing they don't - while ensuring enterprise-grade access controls.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} 
Ready to connect your AI agents to Gong and 100+ other SaaS platforms? We can help you architect a managed MCP solution today.
:::