Major

HubSpot Gong Integration for Automated Deal-Risk Alerts

Connect HubSpot deal stages with Gong call signals to surface quiet deal risk, preserve the evidence, and route a review before pipeline slippage becomes a surprise.

Ritvij Gautam
photo-1507206130118-b5907f817163-crop-entropy-cs-tinysrgb-fit-max-fm-jpg-ixid-m3w5njk3mzz8mhwxfhnlyxjjahwxfhxzywxlcyuymg1hbmfnzxilmjbyzxzpzxdpbmclmjbkzwfsjtiwcglwzwxpbmulmjbvbiuymgxhchrvccuymgr1cmluzyuymg9mzmljzsuymhdvcmt8zw58mhx8fhwxnzk0ndkynziwfda-ixlib-rb-4-1.jpg

TL;DR: what you'll build. A HubSpot Gong integration that goes beyond the native CRM sync: a Major app that pulls open HubSpot deals in late pipeline stages alongside their linked Gong calls, flags the ones going quiet or showing concerning transcript language, and routes a review brief to the deal owner. The sales manager or RevOps lead who owns pipeline inspection gets a standing queue of at-risk deals with the evidence attached, instead of hoping someone notices before the forecast call.

The pipeline problem: call signals get separated from deal state

A HubSpot Deal moves through stages on a schedule nobody enforces. A Gong call happens, gets transcribed, and sits in its own system.

Nobody has time to listen to every call tied to every late-stage opportunity. So a deal can go 16 days without a single call, or a transcript can contain an unresolved objection, and the information stays buried until the Friday forecast meeting, when it is too late to do anything but explain the miss.

This is a sales workflow automation problem, not an AI problem. The process owner is usually a Sales Manager or RevOps lead, the same persona covered in AI agents for sales. The actual job function sits across CRM hygiene (HubSpot) and conversation intelligence (Gong), which is why this build pulls from both.

Two related patterns already live on major.build. Automated lead-to-sequence handoffs covers the front of the funnel: getting enriched leads into outreach fast. Stalled sales engagement alerts covers a similar stale-engagement pattern, but on Salesloft cadence activity against Salesforce Opportunities. This article is the Gong-specific version of that same idea, applied to HubSpot deals.

The fix is not more dashboards. It's a standing app that holds deal and call state together, flags the specific deals that need a human look, and keeps an audit trail of why each one was flagged and what the owner decided.

What a HubSpot Gong integration can automate

HubSpot and Gong already talk to each other. Gong's own documentation on connecting HubSpot to Gong describes a native integration: you authorize Gong inside HubSpot, choose which HubSpot fields Gong imports, and configure which Gong call activities get written back to HubSpot as engagements. That native sync solves data movement.

It does not solve judgment. The native integration moves fields and logs activities; it does not decide that a deal 18 days from close with no call in over two weeks is worth a manager's attention, and it does not draft a brief explaining why a specific transcript moment is concerning.

Here is the honest comparison:

  • Native HubSpot-Gong sync: moves selected HubSpot fields into Gong, and selected Gong call activity into HubSpot as logged engagements. No risk scoring, no persistent case history, no owner review queue.
  • Major app workflow (this build): pulls open, late-stage HubSpot deals and their linked Gong call metadata and transcripts on a schedule, applies deterministic age and stage rules, has an agent draft evidence-backed risk reasons for the ambiguous cases, and routes a review item to the deal owner with a stored decision trail.

The data-flow sequence is the same every run:

  1. A scheduled workflow pulls open HubSpot deals filtered by stage and close date.
  2. It pulls Gong call metadata for the same account over a trailing window.
  3. For calls flagged by the first pass, it fetches the call transcript.
  4. Deterministic rules check call age against deal stage and flag candidates.
  5. The agent reviews ambiguous cases and drafts an evidence brief.
  6. The deal owner reviews the case in the app and confirms or dismisses it.
  7. The app stores the resolution, whether confirmed or dismissed, for future audits.

Systems, API objects, and limits to verify

Both HubSpot and Gong publish full API docs, and both have an official Major connector, so IT connects each one once and every app, agent, and workflow reuses those credentials from Major's central credential store. For broader patterns on each system individually, see AI workflows for HubSpot and Gong call signals in agent workflows.

HubSpot: the deal record

HubSpot's CRM Object API is date-versioned. The HubSpot developer overview documents the current date-based path convention, such as /crm/2026-09/, with older versions kept available until end of life. Treat any older version number you see in a tutorial as something to re-check before you build, because HubSpot rotates these dates.

The Deals object itself still works the way most integrations expect it to. You list deals with GET /crm/v3/objects/deals, specifying which properties you want returned, such as dealstage, closedate, dealname, and hubspotownerid. You fetch one deal with GET /crm/v3/objects/deals/{dealId}, or batch-read several with POST /crm/v3/objects/deals/batch/read. To link a deal to a contact or company, you use PUT /crm/v3/objects/deals/{dealId}/associations/{toObjectType}/{toObjectId}/{associationTypeId}.

Authentication for a single-account build is usually a Private App access token sent as a Bearer credential; multi-account apps use OAuth 2.0. Rate limits depend on your HubSpot tier: published technical limits put Professional accounts around 190 requests per 10 seconds per app and 650,000 requests per day, with Enterprise accounts raising the daily ceiling to 1,000,000. Pagination on list endpoints uses a cursor returned in the response, which you pass back as the next page token. The honest gotcha here: HubSpot's CRM Search API carries a separate, stricter rate limit than the general endpoints, so don't assume your deal list pull and any search calls share the same budget.

Gong: calls and transcripts

Gong's API introduction documents two auth paths: Basic auth using an access key and secret issued by a Gong Technical Admin, or an OAuth 2.0 Bearer token for partner-built apps. The default rate limit is 3 requests per second and 10,000 requests per day per API key, and exceeding it returns an HTTP 429 with a Retry-After header telling you how long to wait.

Call metadata comes from GET /v2/calls, which takes required fromDateTime and toDateTime ISO-8601 parameters (the start is inclusive, the end is exclusive) and requires the api:calls:read:basic scope. The response includes each call's ID, Gong URL, scheduled and start times, duration, host, direction, and more. When the result set spans multiple pages, Gong returns a cursor you pass back on the next request.

Transcripts are a separate, scoped endpoint: POST /v2/calls/transcript, filtered by date range or specific call IDs, requiring the api:calls:read:transcript scope. The response structure is a list of call transcripts, each with monologues broken into sentences, each sentence carrying a speaker ID and start/end timestamps in milliseconds. This is a pull API; Gong's documented surface for this workflow does not describe a general webhook for new calls or transcripts, so a scheduled poll is the correct design, not a gap in your build.

No industry-specific regulation like HIPAA or SOX governs a sales pipeline review by default. If your organization records sales calls that touch consumer phone numbers, the FCC's Telephone Consumer Protection Act rule (47 CFR 64.1200) and the FTC's CAN-SPAM rule are the relevant primary sources for outbound contact, not for this internal review workflow itself. Keep transcript access scoped and logged regardless, because call content is sensitive even without a named statute requiring it.

Architecture: app, agent, and workflow

Split the build into three pieces with distinct jobs, because collapsing them into one agent that "does everything" is exactly the ungoverned pattern this design avoids.

HubSpot and Gong connectors feeding a Major app, agent and workflow for deal-risk alerts, ending in an owner decision

Architecture: app, agent and workflow for the HubSpot Gong deal-risk build

The workflow is deterministic and scheduled. It runs on a fixed interval, pulls HubSpot deals and Gong calls through the shared connectors, applies age and stage rules in code, and only escalates to the agent the cases that need judgment. A webhook is like a doorbell: the tool rings you when something changes, so you don't keep checking the door. Gong's documented API doesn't ring that doorbell for calls or transcripts, so the workflow has to knock on a schedule instead.

The agent is scoped narrowly. It does not decide whether to flag a deal; the deterministic rules in the app already did that. Its job is to read the transcript evidence for a flagged deal, decide whether the language genuinely supports a risk reason, and draft a short brief citing the specific call and the specific sentence. It never writes to HubSpot directly and never changes a forecast.

The app is the system of record for this process. It holds the deals table, the calls table, and the risk_cases table, and it's the screen the deal owner opens to confirm or dismiss a case. This is the part that makes the work stateful: the history of every case, confirmed or dismissed, lives in the app's database rather than in a conversation that disappears once the agent finishes talking.

Build it on Major, step by step

This is the concrete build: one app, one agent, one scheduled workflow, reusing two connectors that IT sets up once.

  1. Connect the HubSpot and Gong connectors once, as an IT admin, scoping the HubSpot Private App token to read-only deal and association scopes and the Gong API key to api:calls:read:basic and api:calls:read:transcript. Store both in Major's central credential store. You should see both connectors listed as available resources that any app, agent, or workflow in the org can reference without re-entering credentials.
  2. Build the app with a prompt describing three managed tables: deals (hubspotdealid, dealstage, closedate, ownerid, sourcesyncat), calls (gongcallid, hubspotdealid, callstartedat, signaltype), and riskcases (riskreason, evidenceexcerpt, status, reviewedby, reviewed_at). Add a queue view filtered to status "needs review" and a detail view showing the deal snapshot next to the linked call evidence. You should see a working queue table with a status column and a detail panel that opens on click.

Example prompt for the app build:

"Build an app with three tables: deals (hubspotdealid, dealstage, closedate, ownerid, sourcesyncat), calls (gongcallid, hubspotdealid, callstartedat, signaltype), and riskcases (riskreason, evidenceexcerpt, status, reviewedby, reviewedat). Give me a queue view of open riskcases filtered by status, and a detail view showing the deal fields next to the related call's evidenceexcerpt. Add confirm and dismiss actions on the detail view that write reviewedby and reviewed_at."
  1. Add the agent that reads flagged cases from the app's riskcases table where status is "pendingreview," fetches the linked transcript excerpt, and drafts a two-paragraph brief citing the call ID and the specific sentence that supports the risk reason. You should see the agent return a draft brief it writes back into the evidenceexcerpt and riskreason fields, with status unchanged until a human acts.

Example prompt for the agent:

"When a riskcase has status pendingreview, read the deal's stage and closedate and the linked call's transcript. Decide if the transcript genuinely supports a deal-risk reason (do not rely on a sentiment label alone; require a specific quoted concern). Write a two to three sentence riskreason citing the call ID and approximate timestamp. Never change dealstage, closedate, or any HubSpot field. Never draft a message to the buyer."
  1. Set the workflow trigger to an hourly schedule for the HubSpot deal and Gong call pull, with a daily reconciliation pass to catch any calls that landed late or were re-transcribed. You should see the workflow's run history populate with timestamps and a row count for deals and calls pulled each run.
  2. Test the workflow against a sandbox or a small filtered set of deals first, confirming the deterministic rule (for example, late-stage plus no call in 14 days, or a transcript match on a tracked risk keyword) only creates cases you'd expect. You should see a handful of risk_cases rows appear in the queue, each traceable to the specific deal and call that triggered it.
  3. Roll out with permissions scoped so only the deal's owner and their manager can see and act on that risk_case, and only an authorized role can grant the app write access back to HubSpot if the org later decides to let a confirmed case auto-log a HubSpot note. You should see role-based visibility on the queue view, with each owner seeing only their own open cases.
Deal-risk case approval path showing the agent drafting evidence while only the owner can confirm a change to HubSpot

Approval path: the agent drafts, the owner decides

Governance and IT control

Every connector in this build is set up once by IT and governed centrally, not re-authorized per app.

  • SSO and role-based access: the queue view only shows a rep their own flagged deals; a sales manager sees the team rollup.
  • Scoped credentials via the credential proxy: the HubSpot token only needs deal read and association scopes; the Gong key only needs the two calls scopes named above, never a broader admin key.
  • Audit logs: every risk_case row records who reviewed it and when, which satisfies the basic "who decided what, and when" question a sales leader will eventually ask.
  • Managed database and storage: the deals, calls, and risk_cases tables live in Major's managed database, not in a spreadsheet a rep might lose or a prompt that evaporates after one session.
  • Versioned deploys: changes to the risk rubric (the 14-day threshold, for example) go through the same deploy process as any other code change, so you can see exactly when the policy changed and roll it back if it creates too many false positives.
  • Approval required: any action that would change HubSpot data, such as logging a note or updating a forecast field, requires the human owner's confirm action in the app. The agent's output is always a draft.

Failure handling and edge cases

Gong's documented 429 response includes a Retry-After header, and the workflow should honor it exactly rather than retrying immediately, which would only extend the back-off window.

A partial sync is the most common real failure: the HubSpot pull succeeds but the Gong call pull times out, or vice versa. The deterministic rule should treat "no Gong data available this run" as a reason to skip scoring that deal rather than treat a missing call as evidence of silence, since those are different situations.

Duplicate events matter when a transcript gets reprocessed or a call ID appears across two sync windows. Keying the calls table on gongcallid and upserting rather than inserting avoids double-counting the same call as two separate pieces of evidence.

Stale data is a slower-moving risk. If the HubSpot owner field changes mid-week, a case assigned to the old owner should route to the new one on the next sync, not sit orphaned.

The agent must never be allowed to write to HubSpot directly, draft an external message to a buyer, or change a deal's forecast category. If the agent's confidence in its own read of a transcript is low, the correct behavior is to surface the case with a lower-confidence flag and let a human decide, not to suppress it or over-assert a risk reason it cannot support with a quote.

A worked example: a fictional weekly deal-risk review

This is an illustrative example, not a measured customer result.

Picture a 40-person B2B sales org running roughly 300 open deals at any time, about 60 of them in a late pipeline stage (negotiation or verbal commit). On a Tuesday, the scheduled workflow runs its hourly pull and finds deal ID 4471: close date is 18 days out, stage is "Decision Maker Bought-In," and the last linked Gong call was 16 days ago.

The deterministic rule flags it immediately on the age check alone, since 16 days exceeds the 14-day threshold for a late-stage deal. The app also pulls the most recent transcript tied to the account from three weeks earlier, and the agent reads it. One monologue includes the buyer's security lead saying, "we still need our InfoSec team to sign off before we can move forward," with no follow-up call since.

The agent drafts: "Deal 4471 is 18 days from close with no call activity in 16 days. The last recorded call (Gong call ID [redacted], timestamp approx. 34:12) includes an unresolved security review objection from the buyer's security lead that has not been addressed in a subsequent call." It writes this into the riskcase row and sets status to pendingreview. It does not touch the HubSpot close date or stage.

The deal owner opens the queue the next morning, sees the case, listens to the cited 90 seconds of the call, and confirms the case is real. They manually log a HubSpot note and schedule a call with the InfoSec contact. If the owner instead believed the concern was already resolved off-call, they would dismiss the case with a reason, and that dismissal is stored for the manager's weekly rollup.

Across 60 late-stage deals, suppose the deterministic rule flags eight as candidates in a given week, the agent drafts a brief for all eight, and owners confirm five as genuine risks while dismissing three as already handled. The arithmetic a manager cares about: five real risks caught before the forecast call versus zero, if nobody happened to notice the quiet deal on their own that week.

What to measure

  • Cases created per week: how many deals the deterministic rule and agent together flag, which tells you if the thresholds are too loose or too tight.
  • Confirm-to-dismiss ratio: a high dismiss rate suggests the age or keyword thresholds need tuning before reps start ignoring the queue.
  • Time from flag to owner action: how long a confirmed case sits before the rep acts, which is the actual cycle-time metric this process is meant to shrink.
  • Deals that later slipped or were lost despite being confirmed: not a prediction accuracy score, just a record of whether confirmed risk cases correlated with later outcomes, reviewed by the sales manager over time.
  • Manual touches avoided: how many deals the manager would otherwise have had to personally review by listening to calls, versus how many the queue surfaced for them.

Frequently asked questions

Does HubSpot have a native Gong integration?

Yes. Gong documents connecting HubSpot from its CRM settings, letting you choose which HubSpot fields Gong imports and which Gong call activities get logged back to HubSpot as engagements. That native sync moves data between the two systems; it does not build a persistent risk-review queue with stored reasons and an owner decision trail, which is the layer this article adds.

What HubSpot and Gong data should a deal-risk workflow read?

Read HubSpot's deal stage, close date, and owner from the Deals object, plus the Gong call metadata (timing, duration) and transcript excerpts for calls linked to the same account. Request only the properties and transcript scope you need, and avoid pulling full transcripts for deals that aren't already flagged by the age or stage rule.

Can Gong call transcripts be used to flag deal risk?

Gong's transcript endpoint returns sentence-level text with speaker and timestamp data, which is a genuine evidence source. Treat a flagged phrase or sentiment signal as something a human must read in context, not a standalone score, since language alone can be ambiguous or sarcastic.

How often should a HubSpot-Gong deal-risk workflow run?

An hourly pull for active late-stage deals with a daily reconciliation pass is a reasonable starting cadence, but it has to respect Gong's 3 requests per second and 10,000 per day default limit and HubSpot's per-tier burst limits. Tune the interval to your deal volume rather than treating any single cadence as universal.

Should an AI agent update a HubSpot forecast automatically?

No, not in this design. The agent's job is to propose a risk reason with cited evidence; an authorized deal owner or manager should be the only one who changes a HubSpot field, a forecast category, or sends anything to the buyer.

What happens if Gong has no call data for a flagged deal?

Treat a missing or unavailable Gong pull as insufficient evidence rather than as proof of silence, and skip scoring that deal on this run rather than generating a false risk case from absent data.

Before you go live

Run through this list with the sales manager and an IT admin before the workflow goes live on real pipeline data. Most of these are one-time checks, but the scope and permission items should be re-verified any time a new rep or manager role is added to the queue. Treat the checklist as the minimum bar, not the full rollout plan: the goal is a workflow that reps trust enough to actually act on, not just one that technically runs.

  • [ ] HubSpot Private App token scoped to deal read and association permissions only
  • [ ] Gong API key scoped to api:calls:read:basic and api:calls:read:transcript, nothing broader
  • [ ] Both connectors tested with a small, filtered deal set before the full rollout
  • [ ] Deterministic age/stage thresholds reviewed and agreed with the sales manager
  • [ ] Agent instructions explicitly block writes to HubSpot and buyer-facing drafts
  • [ ] Role-based visibility confirmed so reps see only their own flagged deals
  • [ ] Retry-After handling verified against Gong's 429 response in a test run
  • [ ] Weekly rollup metric (cases created, confirm/dismiss ratio) assigned to an owner

More sales AI automation use cases

Start building on Major

Build a deal-risk review app that joins HubSpot deal context to Gong call evidence and keeps each owner decision inspectable.

Related articles

About the author

Ritvij Gautam is Head of Growth at Major.

Last reviewed November 12, 2026 by Ritvij Gautam.

Frequently asked questions

Does HubSpot have a native Gong integration?
Yes. Gong documents connecting HubSpot from its CRM settings, letting you choose which HubSpot fields Gong imports and which Gong call activities get logged back to HubSpot as engagements. That native sync moves data between the two systems; it does not build a persistent risk-review queue with stored reasons and an owner decision trail, which is the layer this article adds.
What HubSpot and Gong data should a deal-risk workflow read?
Read HubSpot's deal stage, close date, and owner from the Deals object, plus the Gong call metadata (timing, duration) and transcript excerpts for calls linked to the same account. Request only the properties and transcript scope you need, and avoid pulling full transcripts for deals that aren't already flagged by the age or stage rule.
Can Gong call transcripts be used to flag deal risk?
Gong's transcript endpoint returns sentence-level text with speaker and timestamp data, which is a genuine evidence source. Treat a flagged phrase or sentiment signal as something a human must read in context, not a standalone score, since language alone can be ambiguous or sarcastic.
How often should a HubSpot-Gong deal-risk workflow run?
An hourly pull for active late-stage deals with a daily reconciliation pass is a reasonable starting cadence, but it has to respect Gong's 3 requests per second and 10,000 per day default limit and HubSpot's per-tier burst limits. Tune the interval to your deal volume rather than treating any single cadence as universal.
Should an AI agent update a HubSpot forecast automatically?
No, not in this design. The agent's job is to propose a risk reason with cited evidence; an authorized deal owner or manager should be the only one who changes a HubSpot field, a forecast category, or sends anything to the buyer.
What happens if Gong has no call data for a flagged deal?
Treat a missing or unavailable Gong pull as insufficient evidence rather than as proof of silence, and skip scoring that deal on this run rather than generating a false risk case from absent data.