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. 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 or explore our broader architectural overview on connecting Gong to AI Agents.

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 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 - 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

{
  "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:

{
  "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:

{
  "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.

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.