Gong API: Full Developer Review [2026]

The tension behind every Gong API evaluation is scope.

Gong's platform has grown from conversation intelligence into a revenue platform covering deal execution, forecasting, enablement, and sales engagement across 5,000+ customers. The API sits behind that platform, giving developers programmatic access to call data, transcripts, interaction stats, CRM imports, and AI-powered deal intelligence.

But a platform built for revenue teams and an API built for developers are different products with different questions. What can you actually retrieve? What can you push in? How fast can you call it, and what does it cost at scale?

The Gong API is likely the right choice if:

• You need to upload call recordings from external telephony systems and have Gong transcribe, analyze, and score them alongside natively captured calls.

• You are building custom reporting or BI dashboards that pull call metadata, transcript data, tracker results, and scorecard outcomes from Gong into your own analytics layer.

• You need to query deal and account intelligence through Gong's AI (the ask-entity and get-brief endpoints) and feed insights into internal tools.

• You are building a Gong Collective partner app using OAuth 2.0 and need to embed content inside Gong's UI via iFrame integrations.

• You want to push CRM data into Gong from a CRM that lacks a native integration (Salesforce, HubSpot, and Dynamics 365 have native connectors; everything else uses the CRM API).

• You need webhook-driven automation that fires when a recorded call matches specific filters (speaker, team, topic, tracker).

However, it might not be the right fit if:

• You need B2B contact data, company attributes, org charts, technographic profiles, or buyer intent signals at the API layer. Gong's API surfaces interaction data from calls and emails, not a contact or company database.

• You need high-throughput access. Gong's rate limits are 3 requests per second and 10,000 per day, with no tiered upgrade path documented.

• You want to build on a publicly browsable API reference. Gong's interactive API documentation requires a Gong login; you cannot evaluate endpoint schemas without an account.

• You need official server-side SDKs. Gong provides a JavaScript SDK for iFrame integrations but no backend SDKs for Python, Node.js, Java, or other server languages.

• You are building enrichment, prospecting, or audience management pipelines that require contact search, email verification, or company intelligence endpoints.

• You need AI-powered account research, lookalike expansion, or buying-committee recommendations via API without consuming opaque credit allotments.

In this case, consider the API from ZoomInfo: a REST suite covering search, enrichment, AI intelligence, and audience management across 500M contacts and 100M companies, with OAuth 2.0 authentication, tiered rate limits up to 35 req/sec, and an MCP server for AI-agent workflows.

This article reviews both: the Gong API in full technical depth first, then ZoomInfo's API where your build needs the B2B data and intelligence layer that conversation intelligence does not cover.

Gong API at a Glance

Gong API: What Works Well & What to Plan Around

Gong API: Authentication & Getting Started

Gong supports two authentication paths. Which one you use depends on what you are building.

Basic Auth (direct API access): For internal integrations, custom reporting, and data pipelines built by the Gong customer's own team. A Gong tech admin generates an Access Key and Access Key Secret in the admin center (Settings, Ecosystem, API).

These credentials serve as username and password in HTTP Basic Authentication headers. Keys expire on a rolling basis, and Gong notifies admins ahead of expiry. Only a tech admin can generate these credentials.

API access is available on any Gong plan, so there is no separate developer tier or enterprise gate.

OAuth 2.0 (partner and Collective apps): For apps that integrate with multiple Gong customers or list in the Gong Collective marketplace. The flow follows RFC 6749 authorization code grant.

The authorization endpoint is https://app.gong.io/oauth2/authorize, and tokens are exchanged at https://app.gong.io/oauth2/generate-customer-token. Access tokens default to 1-day validity (configurable via validity_duration), with refresh tokens for silent renewal.

One constraint: Gong does not support user-level OAuth. Authentication happens at the workspace level, not per user. Scopes define data access granularity (e.g., api:calls:create, api:calls:read:basic), and each customer's token points to their unique api_base_url_for_customer.

A basic authenticated request using Basic Auth:

curl -u YOUR_ACCESS_KEY:YOUR_ACCESS_KEY_SECRET \

"https://company-17.api.gong.io/v2/calls"

Developers building Collective apps can request a sandbox/developer instance, though provisioning takes up to five business days.

Gong API: Core Endpoints & Capabilities

The API organizes around Gong's primary data objects: calls, stats, CRM records, Engage activity, and AI intelligence. Each serves a distinct integration pattern.

Calls

The Calls endpoint family at /v2/calls is the most developed resource in the API.

What you can do:

• Upload call recordings from any external telephony system or recorder, including the representative's audio channel, so Gong can transcribe and analyze them alongside natively captured calls.

• Retrieve analyzed call data: internal and external participants, topics discussed, Smart Tracker matches, public comments, scorecards, and full transcripts.

This is the core of the API. If your integration involves getting conversation data out of Gong or getting recordings into Gong, the Calls endpoints are where you work.

What you would build with this: A nightly pipeline that pulls transcripts and tracker results from every call in the last 24 hours into your data warehouse, then joins them with CRM opportunity data for custom win/loss analysis that goes deeper than Gong's built-in dashboards.

Stats

The Stats endpoints retrieve team member usage data: who used Gong and when, daily activity metrics, and interaction statistics per user. Use these to build adoption dashboards or monitor which team members are actively using the platform.

CRM API

The CRM API lets you upload account, contact, and opportunity records directly to Gong. It exists for customers whose CRM lacks a native integration. Salesforce, HubSpot, and Microsoft Dynamics 365 all have native bi-directional connectors; the CRM API is the fallback for everything else.

One constraint: this is import-only. You can push data into Gong, but you cannot export CRM data back out via this API. Native CRM integrations are bi-directional; the API is not.

Engage API

Source: Gong

For teams using Gong Engage (sales engagement), the API supports reporting on flow assignments, prospect contact data, and outreach activity. This helps teams that need more frequent data refresh of Engage metrics than the daily default, or that want to build custom engagement reporting outside Gong's UI.

AI / Ask APIs

Two AI-powered endpoints are available:

• ask-entity: Answers questions about accounts and deals using conversation data. You pass a natural-language question and an entity reference; it returns an AI-generated answer grounded in Gong's interaction history.

• get-brief: Generates structured summaries for accounts, deals, or contacts.

Both consume Gong credits. Consumption scales with the volume of calls and emails analyzed per request, the date range covered, and the scope of the entity queried. Longer ranges and broader scope cost more credits.

The Gong MCP server exposes the same capabilities as tools (ask_account, ask_deal, generate_brief), using the same credit model.

What you would build with this: An internal Slack bot that answers "what's the latest on the Acme deal?" by calling ask-entity with the deal ID, returning an AI summary grounded in the last two weeks of call transcripts and email threads.

Gong API: Webhooks & Events

Source: Gong

Gong supports webhooks through Automation Rules, available on the Gong Foundation plan and above. The model is rule-based: an admin defines call filters (using the same filter logic available in Gong's call search), specifies a destination URL, and the rule fires when a recorded call matches those filters.

Trigger type: One trigger type exists: a call matching the configured filters. Gong does not expose named event types for deal-stage changes, leads, or forecasts. Webhooks are scoped to calls.

Authentication for your receiving endpoint: Two options:

• URL-embedded key: The webhook URL contains a secure random token as a query parameter.

• Signed JWT header: Gong signs the payload with a private key; the public key is available in the Gong UI for verification. Sample receiving code for JWT validation is documented.

Payload structure: The webhook payload is a JSON object with two top-level fields:

• callData: the full call object, identical in structure to the /v2/calls API response. This includes metaData (call ID, URL, title, timing, duration, direction, system, scope, media, language), context (associated CRM objects with fields), and parties (participants with email, name, title, speaker ID, affiliation, CRM context, and meeting methods).

• isTest: boolean flag set to true when triggered from the rule test UI.

The payload is dense in a useful way: you get the full call record in one delivery, not a notification that requires a follow-up API call.

Two constraints to plan around:

• Single trigger type. If you need event-driven automation on deal status changes, forecast updates, or Engage activity, webhooks will not cover it. You are limited to call-matching rules.

• Retry and delivery guarantees are not documented. The public docs do not describe what happens when your endpoint is down or returns an error. Build your receiver to be idempotent regardless.

Gong API: SDKs, Docs & Rate Limits

SDKs & Libraries

Gong provides a JavaScript SDK for iFrame-based integrations that embed third-party content inside Gong's email composer or account/pipeline pages. This is a frontend SDK for partner apps that surface content within Gong's UI, not a general-purpose API client.

No official server-side SDKs exist for Python, Node.js, Java, Ruby, Go, or any other backend language. Developers integrate directly with the REST API over HTTP. The Fivetran community maintains a connector for extracting Gong data into data warehouses, but that is a third-party tool, not a Gong SDK.

Without an official SDK, you own the authentication flow, request serialization, rate-limit backoff, error handling, and retry logic. For a simple integration pulling call data nightly, this is manageable. For a production system making hundreds of daily calls across multiple endpoint families, it adds engineering overhead.

Documentation & Developer Experience

Gong's developer documentation lives in two places:

Help center (help.gong.io): Covers API access setup, OAuth app creation, webhook configuration, CRM API integration, MCP server setup, Data Cloud configuration, and integration patterns.

Content includes step-by-step setup guides, code samples for OAuth flows, and a worked JSON example for webhook payloads. A dedicated Gong Developers Hub section exists for technology partners.

Interactive API reference (gong.app.gong.io/settings/api/documentation): The full endpoint reference with schemas and examples. This is where you find request bodies, response shapes, and endpoint-level documentation for the /v2/calls family and other resources.

The interactive reference requires a Gong login. You cannot browse endpoint schemas, test requests, or evaluate the API surface without a customer or developer account. For a developer evaluating the API before committing, this is a real barrier.

The help center describes what the API can do at a high level, but the endpoint-level detail lives behind the login wall.

No publicly browsable OpenAPI/Swagger spec, no Postman collection, and no public changelog appear in the documentation. The API is versioned under /v2/, but versioning details beyond the path prefix are not described.

Gong does warn that fields may be added to JSON output without notice, so your code must tolerate unknown fields.

Developer support runs through Gong's standard support ticket system. No dedicated developer Slack, forum, or community channel is documented.

Rate Limits & Constraints

Gong publishes the following rate limits:

• 3 API calls per second (burst ceiling)

• 10,000 API calls per day (daily quota)

Exceeding either limit triggers HTTP 429 with a Retry-After header indicating seconds to wait. These limits apply uniformly across all plan tiers. No tiered rate-limit model is documented, so there is no path to higher throughput by upgrading your plan.

Additional constraints:

• Customer-specific base URLs. Each Gong customer account has a distinct API base URL (api_base_url_for_customer). Multi-tenant integrations cannot use a single global URL.

• CRM API is import-only. Data flows into Gong; you cannot export CRM data back out via this endpoint.

• AI endpoints consume credits. The ask-entity and get-brief calls are gated by Gong credits, with consumption scaling by the volume of analyzed interactions, date range, and entity scope. Repeated requests on the same entity over different time ranges each consume credits.

• API batch size for CRM data is configurable in the admin center, though exact limits are not specified in the public documentation.

For context: 10,000 calls per day at 3 per second means your daily quota empties in under an hour of sustained calling. If your integration needs to pull transcripts for hundreds of calls, retrieve stats for dozens of users, and make AI queries against multiple deals, plan your call budget carefully.

Gong API Pricing & Access Costs

Gong does not publish standalone API pricing. API access comes with any Gong plan, bundled with the platform subscription rather than sold as an add-on.

Since Gong's pricing is quote-based (per-user licenses plus a platform fee, with no published price points), the cost of API access is embedded in whatever you negotiate for the platform.

The one documented cost beyond the subscription is Gong credits, consumed by the AI-powered APIs (ask-entity and get-brief). Credit consumption varies: it scales with the number of calls and emails analyzed per request, the date range queried, and the entity scope.

The MCP server tools use the same credit model. Whether credits come with the base subscription or require a separate purchase is not stated in public documentation.

For a developer sizing cost: the API is free if you already pay for Gong. The real cost variables are the platform subscription (custom-quoted, no published prices) and credit consumption from AI endpoints. If your integration sticks to call data retrieval and CRM imports, credits do not apply.

If it depends on AI queries at scale, credit costs are the unknown you need to negotiate upfront.

Where the Gong API Falls Short

These are practical limits a developer should plan around, not criticisms of the platform. Several reflect the fact that Gong built its API to extend a revenue team platform, not to serve as a general-purpose B2B data surface.

The API exposes interaction data, not B2B intelligence. No endpoints exist for contact search, company enrichment, org-chart traversal, technographic lookup, or buyer intent signals. If your pipeline needs to go from "who was on this call?" to "what company do they work for, what is that company's tech stack, and are they showing buying intent?", you need a second API.

Gong captures what happened in conversations; it does not maintain a contact or company database.

Rate limits are restrictive for data-heavy integrations. At 3 requests per second and 10,000 per day, the throughput ceiling is low. No documented tiered upgrade path exists. A team pulling transcripts, stats, and AI insights across a large Gong instance will need careful call budgeting.

By comparison, most API-first platforms offer 25+ requests per second at their standard tier.

The interactive API reference is behind a login wall. You cannot browse endpoint schemas, test requests, or evaluate response shapes without a Gong customer or developer account. During a technical evaluation, you must rely on the help center's high-level descriptions rather than the actual endpoint documentation.

No server-side SDKs. Every backend integration is raw HTTP. The JavaScript SDK covers frontend iFrame integrations only. If your team is accustomed to maintained client libraries that handle auth, retry, and pagination, you build that layer yourself.

Webhook scope is limited to calls. One trigger type exists: a call matching a filter rule. No webhook events for deal changes, forecast updates, pipeline movements, or Engage activity. If your integration needs event-driven automation beyond "a call matched these criteria," webhooks will not cover it.

AI endpoint costs are opaque. The ask-entity and get-brief endpoints consume Gong credits, but credit pricing, allocation, and consumption rates are not publicly documented. Building a cost model for an integration that makes frequent AI queries requires a conversation with Gong's sales team.

MCP server is not yet generally available. The MCP server at mcp.gong.io/mcp is announced but listed as "coming soon." Developers building AI-agent integrations today cannot rely on it.

ZoomInfo API: The B2B Data and Intelligence Layer

Gong's API gives you programmatic access to what happened in revenue team conversations.

ZoomInfo gives you the B2B data that tells you who those people are, what companies they work for, what technology those companies use, whether those accounts are researching your category, and how the buying committee is structured. This intelligence draws from ZoomInfo's GTM Context Graph, which processes 1.5B+ data points daily.

The two APIs operate at different layers. A developer building a complete revenue intelligence pipeline would use Gong's API for interaction data and ZoomInfo's API for the contact, company, and intent data that conversation intelligence does not capture.

What the API Covers

ZoomInfo's Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into four areas documented in the interactive API reference:

• Data API (Search & Enrich): Search endpoints cover Contacts, Companies, Intent, News, and Scoops, returning matched records without consuming credits. Enrich endpoints unlock the full payload: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, up to 25 records per call. The underlying dataset spans 500M contacts, 100M companies, 135M+ verified phone numbers, and 200M+ verified business email addresses.

• AI Intelligence API: Account Summary returns structured account intelligence with a free-form Q&A endpoint. Find Similar Companies performs lookalike expansion from a seed account. Contact Recommendations returns AI-ranked buying-committee suggestions by motion (prospecting, deal acceleration, renewals).

• Marketing API: CRUD endpoints for programmatic audience management.

• Platform API (Engagements, Beta): Bidirectional engagement data via the Engagements API.

The search-then-enrich pattern means you filter freely (search and lookup calls are free), then pay only for the records you enrich. This is a different cost model from one where every API call consumes credits regardless of what it returns.

Authentication & Access

ZoomInfo uses OAuth 2.0 with PKCE via Okta, supporting three flows:

• Authorization Code with PKCE for web applications

• Client Credentials for server-to-server integrations

• Refresh Token for silent token renewal

Access tokens last 24 hours as Bearer tokens with rotating refresh tokens. Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints.

Two app types are supported: custom applications (auto-approved on registration) and partner applications (requires ZoomInfo review).

The developer portal also supports generating bearer tokens directly in the UI for testing, which lets you evaluate endpoint responses before building the full OAuth flow.

Endpoints, Rate Limits & Credits

Rate limits are published by tier: Builder (5 req/sec), Standard (25 req/sec), and Scaling (35 req/sec), with per-hour and per-day sliding-window limits enforced simultaneously.

Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing plus identification of which window was exhausted.

Credits follow a rolling 12-month window: enriching a record for the first time consumes one credit; re-enriching the same record within the year is free. Search and lookup operations cost nothing. AI research endpoints (Account Research, Contact Research) consume a separate AI action credit pool.

For developers building AI agents, ZoomInfo's MCP server at https://mcp.zoominfo.com/mcp exposes search, enrich, and account research as native tools for MCP-compatible assistants, currently supporting Claude and ChatGPT. The credit model carries over from the REST API.

Developer Experience

Documentation lives at docs.zoominfo.com with an interactive API reference, OAuth recipes in five languages (Shell, Node, Ruby, PHP, Python), and an llms.txt index for AI development tools. A separate Docs MCP server enables AI-assisted code generation against the API spec.

ZoomInfo does not publish official SDKs either, so both Gong and ZoomInfo require direct HTTP integration.

Pricing follows a consumption-based model and is custom-quoted. ZoomInfo has added API access to all relevant plans, removing a prior enterprise-only gate.

BDO Canada reported an 87% reduction in time spent updating internal data dashboards using the ZoomInfo API, with one analyst describing the integration as plug-and-play across any process. (ZoomInfo)

Gong API vs. ZoomInfo API

Final Verdict

Gong's API does what it was built for: giving developers programmatic access to the conversation intelligence, deal insights, and interaction data that Gong captures from revenue team activities.

The webhook payloads (full call objects in every delivery), the AI-powered ask-entity and get-brief endpoints, and the upcoming MCP server make it a capable integration layer for teams already on the Gong platform. Its limits are limits of scope and throughput, not quality.

Choose the Gong API if your build starts with conversation data: pulling call transcripts into a custom analytics layer, uploading recordings from external systems for Gong to process, triggering workflows when specific call patterns are detected, or querying deal intelligence via the AI endpoints.

If your team already runs on Gong and the integration extends what Gong captures, the API delivers that access at no additional cost beyond the platform subscription.

Choose the ZoomInfo API if your build needs the B2B data layer that conversation intelligence does not provide: searching and enriching contacts and companies, detecting buyer intent, mapping org charts and technology stacks, generating AI account research, or building audience segments programmatically.

The search-then-enrich pattern (search is free, enrich consumes credits), published tiered rate limits up to 35 req/sec, and the live MCP server give developers a broader, higher-throughput surface for data-intensive pipelines.

Explore the ZoomInfo Enterprise API or start with the developer docs to evaluate the endpoint surface directly.

A developer who needs neither should know that Gong's API does not expose B2B contact or company data, and ZoomInfo's API does not capture or analyze sales conversations. If your pipeline needs both interaction intelligence and data enrichment, the two are complementary layers, not competing surfaces.

FAQ

Is the Gong API free?

API access comes with any Gong plan at no additional charge. There is no separate developer tier, API add-on, or per-call pricing for standard endpoints (calls, stats, CRM imports). The exception is the AI-powered endpoints (ask-entity and get-brief), which consume Gong credits.

Credit pricing and allocation are not publicly documented, so teams planning to use AI endpoints at scale should clarify credit terms during contract negotiation.

Does Gong have a GraphQL API?

No. Gong exposes a REST API with JSON responses, versioned under /v2/. There is no GraphQL endpoint. If you need a GraphQL interface for Gong data, you would build a wrapper on top of the REST API.

What is the Gong API rate limit?

Gong enforces two simultaneous limits: 3 API calls per second and 10,000 API calls per day. Exceeding either triggers a 429 response with a Retry-After header. These limits apply uniformly across all plan tiers, and no documented upgrade path to higher throughput exists. At sustained calling, the daily quota empties in under an hour.

Are there official Gong SDKs?

Gong provides a JavaScript SDK for iFrame-based frontend integrations (embedding partner content inside Gong's email composer or account pages). No official server-side SDKs exist for Python, Node.js, Java, Ruby, Go, or any other backend language. Developers build directly against the REST API. The Fivetran community maintains a separate connector for extracting Gong data into data warehouses.

Does the Gong API support webhooks?

Yes, through Automation Rules. An admin defines call filters and a destination URL; when a recorded call matches those filters, Gong delivers the full call object as a JSON payload to your endpoint. Authentication options include a URL-embedded token or a signed JWT header.

The limitation is scope: webhooks only fire on call events. No webhook triggers exist for deal status changes, forecast updates, pipeline movements, or Engage activity.

What does ZoomInfo's API add to a Gong build?

ZoomInfo's API adds the B2B data and intelligence layer that Gong's API does not cover. Where Gong's API returns conversation data (who was on a call, what was said, how a deal is trending), ZoomInfo's API provides the contact and company intelligence behind those interactions: verified emails and direct dials across 500M contacts, company attributes and org charts across 100M companies, technographic profiles, buyer intent signals, and AI-powered account research.

The two APIs use different authentication models (Basic Auth/OAuth 2.0 vs. OAuth 2.0 with PKCE) and different pricing structures (platform-bundled vs. credit-based), so plan the integration layer to handle both. ZoomInfo's MCP server extends the same data to AI-agent workflows, adding a live capability that Gong's MCP server has not yet reached.