gong-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@gong-mcpfind calls from last week about Q4 planning"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
gong-mcp
MCP server for the Gong API. Search calls, get transcripts, attendees, next steps, and more — directly from Claude or any MCP client.
Setup
1. Get Gong API Credentials
Log into Gong as an admin
Go to Company Settings > Ecosystem > API > API Keys
Click Create to generate an Access Key and Access Key Secret
Copy both values (the secret is shown only once)
2. Configure your MCP client
Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json) or Claude Code settings:
{
"mcpServers": {
"gong": {
"command": "npx",
"args": ["-y", "@bgrgndzz/gong-mcp@latest"],
"env": {
"GONG_ACCESS_KEY": "your-access-key",
"GONG_ACCESS_KEY_SECRET": "your-access-key-secret"
}
}
}
}If your Gong instance uses a custom API base URL (e.g., https://us-0000.api.gong.io), add it:
"env": {
"GONG_ACCESS_KEY": "your-access-key",
"GONG_ACCESS_KEY_SECRET": "your-access-key-secret",
"GONG_BASE_URL": "https://us-0000.api.gong.io"
}Related MCP server: gong-mcp
Tools
Tool | Description |
| List calls within a date range with attendee info |
| Get full call details: attendees, topics, highlights, next steps, key points, outcome |
| Get speaker-attributed transcripts with timestamps |
| Search calls by date range, user, workspace, or call IDs |
| List all Gong users (for mapping IDs to names) |
| Get details for a specific user |
Environment Variables
Variable | Required | Description |
| Yes | Gong API access key |
| Yes | Gong API access key secret |
| No | Custom API base URL (default: |
License
MIT
Available Tools
7 toolsfind-calls-by-companyA
Find all Gong calls associated with a specific company/account. Matches by: (1) CRM account/opportunity associations from Salesforce/HubSpot linked to the call, (2) participant email domains, (3) participant affiliations and names, (4) call title/brief mention. This is the best tool for finding all calls with a specific customer.
| Name | Required | Description | Default |
|---|---|---|---|
| maxRecords | No | Maximum number of matching calls to return (default: all) | |
| toDateTime | Yes | End date-time in ISO 8601 format (e.g. 2026-03-08T23:59:59Z) | |
| companyName | Yes | Company name to search for (e.g. 'Recorded Future', 'Acme Corp'). Case-insensitive, matches partial names. | |
| fromDateTime | Yes | Start date-time in ISO 8601 format (e.g. 2025-09-01T00:00:00Z) | |
| companyDomain | No | Company email domain for more accurate matching (e.g. 'recordedfuture.com'). If provided, also matches participant email domains. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses how matching works via four criteria (CRM associations, participant domains, affiliations, title mentions). This goes beyond a simple 'find calls' statement, though it doesn't mention pagination or return format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences, front-loaded with the core purpose, efficiently lists matching methods, and contains no fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, matching behavior, and when to use it. It lacks output format details, but with no output schema and a straightforward search tool, the provided information is sufficient for an agent to understand its functionality.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All five parameters have schema descriptions covering 100%, so the baseline is 3. The description adds context about matching logic but doesn't provide additional parameter-specific details beyond what the schema already offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool finds all Gong calls for a specific company/account, lists specific matching methods, and claims it is the best tool for this use case. This distinguishes it from general search-calls and other siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'This is the best tool for finding all calls with a specific customer,' giving clear context for when to use it. However, it does not mention when not to use it or alternative tools for other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-call-detailsA
Get detailed information about specific Gong calls including attendees, topics, highlights, next steps, key points, and call outcome.
| Name | Required | Description | Default |
|---|---|---|---|
| callIds | Yes | Array of Gong call IDs to retrieve details for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the types of data returned (attendees, topics, highlights, next steps, key points, call outcome), which gives some insight into behavior. However, it does not mention potential errors, authentication requirements, rate limits, or the response format, leaving gaps in transparency for a no-annotation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently states the action and resource, then lists the relevant detail categories. No unnecessary words or repetition are present, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool with no output schema, the description lists the key return fields (attendees, topics, highlights, next steps, key points, call outcome), providing a reasonable understanding of what the tool returns. However, it does not mention error behavior or response structure, and with no output schema it could have been more explicit about the format, but overall it is sufficiently complete for its simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter (callIds) with a complete description ('Array of Gong call IDs to retrieve details for'), achieving 100% schema coverage. The tool description does not add further parameter semantics beyond referencing 'specific calls' and the types of details, but since schema coverage is high, the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb 'Get' with a specific resource ('detailed information about specific Gong calls') and enumerates the content (attendees, topics, highlights, etc.). It does not explicitly distinguish from sibling tools like get-call-transcript or search-calls, but the listed fields imply a distinct purpose of retrieving comprehensive call metadata rather than transcripts or search results.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when you have specific call IDs and need detailed call information, but it does not explicitly state when to use it versus alternatives. There is no mention of prerequisites (e.g., first find call IDs via search-calls) or exclusions (e.g., use get-call-transcript for transcripts). The usage context is only implied by the phrasing 'for specific Gong calls'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-call-transcriptA
Get the full transcript for one or more Gong calls. Returns speaker-attributed text with timestamps.
| Name | Required | Description | Default |
|---|---|---|---|
| callIds | Yes | Array of Gong call IDs to get transcripts for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It meaningfully specifies that the output includes speaker attribution and timestamps, going beyond a minimal statement. It does not disclose edge cases or error behavior, but for a simple read operation this is reasonably transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no redundancy or filler. It front-loads the primary action and immediately states the key return characteristics, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no output schema, the description adequately covers what the tool does and what the response contains. It could elaborate on response structure or limitations, but given the tool's simplicity, the information is sufficient for most use cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the input schema already fully documents the single 'callIds' parameter as an array of Gong call IDs. The description adds no further parameter-specific meaning, matching the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves full transcripts for Gong calls, with a specific verb ('Get') and resource ('transcript'). It differentiates from sibling tools like get-call-details by specifying transcript-specific output (speaker-attributed text with timestamps).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when a caller needs a call transcript, but it provides no explicit guidance on when not to use it or how it compares to alternatives like get-call-details or search-calls. Usage context is inferred rather than explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-userA
Get details for a specific Gong user by their user ID.
| Name | Required | Description | Default |
|---|---|---|---|
| userId | Yes | The Gong user ID |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states 'Get details,' which implies a read operation but does not clarify what happens if the user is not found, whether any sensitive fields are omitted, or if any special permissions are required. This lack of detail is a significant gap for a tool carrying the full transparency burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately states the verb, resource, and key parameter. It contains no fluff or redundant phrasing, and every word contributes to understanding the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool, the description adequately conveys the core functionality and input. However, with no output schema, the vague term 'details' leaves the return structure undefined, and there is no mention of error behavior or output fields. It is minimally complete but could be more informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full documentation for the only parameter (userId) with 'The Gong user ID', and the description's 'by their user ID' adds no new semantic nuance. Per the rubric, with 100% schema coverage, the baseline is 3, and the description does not elevate beyond that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's action ('Get details') and resource ('a specific Gong user'), and specifies the input criterion ('by their user ID'). This distinguishes it from sibling tools like list-users, which would return multiple users.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when you have a specific user ID and need its details. However, it does not explicitly contrast with alternatives like list-users or mention when not to use it, leaving the usage guidance implicit rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list-callsB
List Gong call recordings within a date range. Returns call metadata including title, date, duration, and participants.
| Name | Required | Description | Default |
|---|---|---|---|
| maxRecords | No | Maximum number of calls to return (default: all) | |
| toDateTime | Yes | End date-time in ISO 8601 format (e.g. 2024-01-31T23:59:59Z) | |
| workspaceId | No | Filter by workspace ID | |
| fromDateTime | Yes | Start date-time in ISO 8601 format (e.g. 2024-01-01T00:00:00Z) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description must carry the behavioral disclosure burden. It states the output includes title, date, duration, and participants, but doesn't mention optional workspace filtering, maxRecords default, pagination, or whether it is strictly read-only. This is a basic disclosure but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the purpose, and includes a concise return-value note. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool without annotations or output schema, the description minimally explains the return fields and date range, but omits optional parameters and any pagination/limit behavior. It is adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover 100% of parameters, documenting ISO formats, default for maxRecords, and workspaceId filter. The description adds no independent parameter semantics beyond mentioning the date range, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists Gong call recordings within a date range, using the verb 'List' and a specific resource. It differentiates from get-call-details/transcript by focusing on metadata, but doesn't mention alternatives like search-calls.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear usage context (date range) but provides no guidance on when to use this tool instead of search-calls or find-calls-by-company. No exclusions or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list-usersA
List all Gong users in the account. Useful for mapping user IDs to names and emails.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description relies on the verb 'list' to imply read-only behavior. It adds purpose but does not disclose potential complexities like authentication, rate limits, or whether all user fields are returned. This is a moderate gap for a simple list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the primary action, and the second sentence adds relevant use-case context. No unnecessary details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and no output schema, the description is adequately complete. It conveys the purpose and the typical output (user IDs, names, emails), making the tool understandable and sufficient for an agent to select and invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the baseline is 4. The description adds value by explaining the output is useful for mapping user IDs to names and emails, which provides context beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all Gong users in the account, using a specific verb and resource. It distinguishes itself from siblings like list-calls and get-user by focusing on users and the 'all' scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear use case ('mapping user IDs to names and emails') which implies when to use this tool. However, it does not explicitly mention alternatives or when not to use it, such as when needing a single user's details.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search-callsA
Search for Gong calls by date range, user, workspace, or call IDs. Returns calls with full details including attendees, topics, highlights, and next steps.
| Name | Required | Description | Default |
|---|---|---|---|
| callIds | No | Specific call IDs to retrieve | |
| maxRecords | No | Maximum number of calls to return (default: all) | |
| toDateTime | No | End date-time in ISO 8601 format (e.g. 2024-01-31T23:59:59Z) | |
| workspaceId | No | Filter by workspace ID | |
| fromDateTime | No | Start date-time in ISO 8601 format (e.g. 2024-01-01T00:00:00Z) | |
| primaryUserIds | No | Filter by call owner user IDs |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions the return payload ('full details including attendees, topics, highlights, and next steps') and does not disclose pagination, maxRecords behavior, filter combination semantics, or the read-only nature of the operation. This is a minimal disclosure for a search tool with no safety hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: first sentence states purpose, second states output value. It is front-loaded, concise, and free of filler or tautology.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters and no output schema, the description provides a high-level overview but omits crucial invocation context: all parameters are optional, how filters combine (AND/OR), maxRecords default, and pagination behavior. It is adequate but has clear gaps for an agent to correctly use the tool in complex scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter already has a description. The tool description adds no extra semantics about parameter interactions, defaults, or edge cases (e.g., how callIds interacts with date filters). Baseline of 3 is appropriate since the description lists filters but does not enrich the parameter meanings beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb + resource: 'Search for Gong calls by date range, user, workspace, or call IDs.' It clearly identifies the tool's scope and differentiates from siblings like get-call-details and find-calls-by-company by enumerating distinct filter dimensions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by listing supported filters (date range, user, workspace, call IDs), but it does not explicitly state when to prefer this tool over alternatives like list-calls or find-calls-by-company. There is no 'use this when' or 'instead of' guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
The call retrieval tools heavily overlap: 'list-calls' and 'search-calls' both support date-range filtering, and 'search-calls' also returns full details like 'get-call-details', making the boundaries unclear. 'find-calls-by-company' is distinct but still a search variant, adding to the confusion.
All tool names follow a consistent lowercase-hyphenated verb-noun pattern (e.g., list-calls, get-user). However, the verbs are semantically inconsistent (list vs search vs find), which introduces mild ambiguity despite the stylistic consistency.
Seven tools is a well-scoped set for a call-recording and user-management domain. Each tool serves a clear purpose, and the count is neither too sparse nor overwhelming.
The toolset covers the full read-only lifecycle for Gong calls: listing, searching, retrieving details, getting transcripts, and finding by company. User management (list/get) is also complete. No obvious gaps for the apparent domain.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
An MCP server that provides congressional transcripts
MCP server for Google search results via SERP API
Related MCP Servers
- AlicenseBqualityDmaintenanceA Model Context Protocol server that allows Claude to access Gong's API for retrieving call recordings and transcripts through a standardized interface.27639MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for interacting with Gong's sales engagement platform, enabling access to call recordings, analytics, and CRM data.MIT
- AlicenseAqualityDmaintenanceMCP server for Apollo.io B2B sales intelligence API. Enables searching and enriching people and organizations via natural language.7274MIT
- FlicenseNot gradedqualityDmaintenanceRemote MCP server that exposes Airspeed/Glyphic call data to Claude web, enabling tools to list, retrieve, and query calls, transcripts, snippets, and playbooks.
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/bgrgndzz/gong-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server