Does Google Analytics 4 integrate directly with HubSpot to track form submissions and ad conversions?

What the connection really is, and why the distinction matters

The most persistent misconception in modern RevOps stacks is that installing the GA4 "integration" from inside HubSpot links the two platforms for conversion tracking. It does not. The App Marketplace connection is a read-only metric sync: it pulls GA4's high-level reporting numbers — sessions, users, bounce rate, average engagement time — into HubSpot custom reports so a marketer can watch traffic trends without leaving the CRM. That is genuinely useful for dashboarding, but data moves in exactly one direction and only at the aggregate level.

What the connection deliberately does *not* do is pass event-level data. When a visitor completes a HubSpot form, that submission never travels to Google Analytics on its own. When someone clicks a Google Ad and later converts on a HubSpot landing page, GA4 has no built-in way to stitch the ad click to the form fill. The two systems use fundamentally different data models. GA4 is event-and-parameter based: every interaction is an event (page_view, generate_lead) carrying parameters. HubSpot is object-and-property based: contacts, deals, and form submissions are CRM records with properties. No supported switch bridges that gap automatically, and no amount of clicking "Connect" inside the Marketplace will make one appear.

Why does this matter beyond tidy reporting? Because Google Ads' automated bidding — Performance Max, target CPA, and Smart Bidding generally — optimizes against the conversions that GA4 or Google Ads conversion tracking can actually see. If your highest-intent action, the demo-request form, lives in HubSpot and never fires a GA4 key event, Google's machine-learning bidder is blind to your single best signal. It will happily shift budget toward whatever cheap, visible micro-action it *can* measure — a newsletter pageview, a scroll. Meanwhile any multi-touch attribution model you run inherits the same blind spot, and revenue-intelligence software downstream reports on partial data. Closing this gap is not a dashboard nicety. It is the difference between attribution you can trust and a forecast built on a fraction of the real signal. The word "integrate" gets thrown around loosely here, so be precise about which direction data flows and at what granularity before you promise anyone that HubSpot and Analytics are "connected."

The build: wiring submissions and conversions into GA4 step by step

There is no one-click path, but there is a well-worn, reliable one. The most durable pattern for mid-market teams is client-side Google Tag Manager for browser events, backstopped by a server-side Measurement Protocol call for reliability. Here is the concrete build, in order.

Confirm the GA4 base tag is live via GTM. Install the GA4 configuration tag in Google Tag Manager and verify that pageviews land in GA4's real-time report before you touch forms. Everything downstream depends on this foundation firing correctly, so do not skip the verification.

Capture the HubSpot form submission in the browser. HubSpot's embedded forms emit a global JavaScript message when a form is completed — the onFormSubmitted callback in the HubSpot Forms API, or the hsFormCallback window message. Add a small listener (a Custom HTML tag or a dedicated script) that pushes a dataLayer event named hubspot_form_submit, carrying parameters like form_name, form_id, and the current page_url. This dataLayer push is the trigger everything else hangs on.

Fire a GA4 event tag. Create a GA4 Event tag that sends generate_lead or a custom form_submission event, triggered by the hubspot_form_submit dataLayer push. Pass the form name and page as event parameters so you can later segment which forms drive which conversions rather than treating all leads as one undifferentiated bucket.

Mark it as a key event. In GA4 Admin → Events, flag form_submission (or generate_lead) as a key event — the setting formerly called a "conversion." Only then does it count as a conversion in reports and become eligible to import into Google Ads.

Add a server-side backstop for ad conversions. Browser events get lost to ad blockers, Intelligent Tracking Prevention, and consent-mode denials — commonly 10–30% of them. Build a HubSpot workflow that fires a webhook on form submission to a lightweight serverless function (Google Cloud Functions or AWS Lambda). That function calls GA4's Measurement Protocol with the same event name plus the gclid (Google Click ID) captured on the form as a hidden field. This gives you resilient ad-to-form attribution even when the client-side tag never fires.

Import into Google Ads. In Google Ads, import the GA4 key event as a conversion action so Smart Bidding optimizes against real demo requests rather than proxy metrics. Give it a day or two to populate before you judge anything.

The dual path — client-side for rich session context, server-side for reliability and the gclid — is what separates a demo build from a production one you can bill your ad spend against. If you only build the client-side half, your conversion count will read as complete while quietly under-counting by double digits.

Costs, timelines, and typical ranges

Budget realistically, because the cheapest-looking option often carries the highest hidden operational cost. Here is roughly what the common approaches run.

Google Tag Manager route. GTM itself is free. The real cost is engineering time: a competent marketing-ops or web developer needs roughly 4–8 hours to build and QA the form-submission tags, plus another 2–4 hours to wire the server-side Measurement Protocol backstop. Serverless hosting for the webhook function is trivial — typically under $5–$50/month even at tens of thousands of submissions, since these are lightweight, short-lived invocations well inside most free tiers. For the large middle of the SMB and mid-market, this is the best cost-to-reliability ratio and it scales cleanly.

CDP middleware (Segment, Tealium, RudderStack). These platforms ingest HubSpot webhooks and fan events out to GA4, Google Ads, a warehouse, and product analytics with no custom code. Convenience has a price. Segment's paid tiers commonly start around $120/month and climb steeply with monthly tracked users into the four- and five-figure range; Tealium is enterprise-priced, frequently $15,000+/year. Implementation reaches first value faster — days rather than a full sprint — and the spend is justified when you are routing events to many destinations. If GA4 is your only target, a CDP is usually overkill.

Zapier / Make no-code glue. Attractive for a fast win: connect a HubSpot "new form submission" trigger to a GA4 action in an afternoon, no developer required. The trade-offs are latency (seconds of delay, which makes it unsuitable as a real-time bidding signal) and per-task pricing that gets expensive at volume. It is fine for low-volume lead forms and poor for high-traffic paid campaigns.

Timelines. A basic single-form GA4 event via GTM can be live and verified in half a day. A full production setup — multiple forms, the server-side backstop, gclid capture, Google Ads import, and QA across consent-mode states — realistically takes 1–2 weeks of part-time work including testing. After go-live, budget 24–48 hours for GA4 to populate conversion data, then another 1–2 weeks before Smart Bidding has accumulated enough conversion volume to meaningfully re-optimize. Do not judge the ad-performance impact until the algorithm has retrained on the new signal; early swings are noise.

Where teams get the integration wrong

Even experienced teams stumble on the same predictable failure modes. Knowing them up front saves weeks of dirty data and misallocated budget.

Trusting the native sync for conversions. The number-one error: someone installs the App Marketplace connection, sees GA4 numbers appear in HubSpot, and declares attribution "done." It is not — no form submissions or ad conversions are flowing as events. Audit this immediately by submitting a test form and checking whether it appears as a GA4 event in the real-time report. If it does not, your event pipeline was never built, regardless of what the dashboard shows.

Losing UTM and gclid parameters. HubSpot forms embedded on non-HubSpot pages frequently strip or fail to capture UTM parameters and the gclid. Without the gclid reaching GA4, you lose true ad-to-conversion attribution — Google cannot match the conversion back to the click that produced it. Fix it by adding hidden fields to every form that capture UTM values and gclid from the URL or a first-party cookie, then confirm those values survive into the event payload rather than assuming they do.

Double-counting. Running both a client-side GTM tag and a server-side Measurement Protocol call without deduplication inflates your conversion count. Google Ads then over-optimizes against phantom volume and misreads your true cost per acquisition. Pass a shared transaction_id or event ID on both paths so GA4 collapses them into one conversion.

Ignoring Consent Mode and privacy limits. Consent-mode-denied sessions and ad blockers silently drop a meaningful share of client-side events. Teams that rely only on browser tags routinely see conversion counts drift 10–30% below reality, and the shortfall is not random — it skews toward privacy-conscious segments. The server-side backstop is the mitigation, not an optional extra, and Consent Mode v2 behavior should be tested before you trust any number.

Hitting Measurement Protocol quirks. Server-side events can appear as "direct / none" traffic unless you deliberately pass a consistent session_id and client_id, and there are per-user event caps that high-traffic campaigns can brush against. Validate the payload against GA4's Measurement Protocol validation endpoint before trusting it in production. These are the details that separate a demo that "works" once from an integration that survives a real campaign under load.

Decision framework: matching the method to the situation

Match the method to your volume, your team's technical depth, and how many destinations you need to feed. Do not over-engineer a two-form brochure site, and do not under-build a high-spend ad program on Zapier.

Use Google Tag Manager plus a server-side Measurement Protocol backstop when you have — or can borrow — basic web-dev capability, you are routing events primarily to GA4 and Google Ads, and you want the best cost-to-reliability ratio. This fits the large middle of the market. Reach for a CDP like Segment or Tealium when you already pay for one, or when HubSpot events must reach many destinations (GA4, ad platforms, a warehouse, product analytics) and you would rather buy maintained connectors than own code. Reserve a fully custom serverless API for high-volume enterprise cases — tens of thousands of submissions monthly, strict data governance, or bespoke transformation needs. Fall back to Zapier or Make only for genuinely low-volume forms where a few seconds of latency and per-task cost do not matter and speed of setup wins outright.

Whichever path you pick, the non-negotiable is the same: a real conversion event must reach GA4, carry its gclid, and be imported into Google Ads so bidding optimizes on truth. The tooling is negotiable; the event integrity is not. Let the analytics software choice follow the requirement, never the reverse.

Related questions

Does the HubSpot GA4 integration send data both ways?

No. The native App Marketplace connection is one-directional: it pulls aggregate GA4 metrics into HubSpot reports. It does not push HubSpot form submissions or CRM events back to GA4. Bidirectional event flow requires GTM, webhooks with the Measurement Protocol, or a CDP.

Can I track Google Ads conversions from HubSpot forms without GA4?

Yes. You can implement Google Ads conversion tracking directly through GTM, firing a Google Ads conversion tag on the HubSpot form-submit event and passing the gclid. GA4 is not strictly required, though routing through GA4 gives you richer analysis and a single conversion source of truth.

Why don't my HubSpot and GA4 form numbers match?

They measure different things. HubSpot counts CRM form-submission records; GA4 counts browser events, which are reduced by ad blockers, consent denials, and failed page loads. Expect a 10–30% gap unless you add a server-side backstop to recover the missed client-side events.

Do I need Google Tag Manager to integrate the two?

Not strictly, but it is the easiest reliable option. GTM lets you deploy and version tags without editing site code and handles triggers cleanly. Alternatives are direct gtag.js edits, a CDP, or a pure server-side webhook build — all workable, but GTM is the common default.

FAQ

Does Google Analytics 4 natively integrate with HubSpot for form submissions?

No. The HubSpot App Marketplace GA4 connection only syncs aggregate metrics such as sessions, users, and pageviews into HubSpot dashboards. It does not send form submissions to GA4 as events. Tracking submissions as conversions requires Google Tag Manager, HubSpot webhooks with the Measurement Protocol, or middleware like Segment.

How do I send HubSpot form submissions to GA4 as conversions?

Listen for HubSpot's form-submit browser event, push it to the dataLayer, and fire a GA4 event tag through Google Tag Manager. Then mark that event as a key event in GA4 Admin. Add a server-side Measurement Protocol call as a backstop so ad-blocked and consent-denied sessions are still captured.

Will ad conversions flow automatically once I connect the accounts?

No. Ad conversions are never passed automatically. You must fire a GA4 or Google Ads conversion event on the form submission, capture the gclid, and import that key event into Google Ads so Smart Bidding can optimize against it. The native sync shares no conversion events at all.

Is a CDP like Segment required to make this work?

No. A CDP is convenient when you route events to many destinations, but it is optional and expensive. A GTM plus serverless Measurement Protocol build achieves reliable form-submission and ad-conversion tracking in GA4 for a fraction of the cost, typically under $50 per month in hosting.

How long does the setup take?

A single form can be live in half a day. A full production build across multiple forms, with a server-side backstop, gclid capture, and Google Ads import, realistically takes one to two weeks of part-time work including QA. Expect 24–48 hours after launch for GA4 conversion data to populate.

Why does this integration matter for automated bidding and attribution?

Revenue-intelligence and bidding software optimize against the conversions they can see. If high-intent form submissions never reach GA4, those models train on incomplete data, mis-attribute pipeline, and misallocate ad budget. Feeding complete event-level data keeps automated bidding and attribution accurate.

Sources

• https://support.google.com/analytics/answer/9216061 — Google Analytics Help: about events and key events in GA4
• https://developers.google.com/analytics/devguides/collection/protocol/ga4 — GA4 Measurement Protocol reference
• https://knowledge.hubspot.com/forms/use-form-webhooks — HubSpot Knowledge Base: form and workflow webhooks
• https://developers.hubspot.com/docs/api/webhooks — HubSpot Developers: Webhooks API
• https://support.google.com/tagmanager/answer/6103696 — Google Tag Manager Help: tags, triggers, and variables
• https://support.google.com/google-ads/answer/9888656 — Google Ads Help: import conversions from Google Analytics
• https://segment.com/docs/connections/destinations/catalog/actions-google-analytics-4/ — Segment documentation: GA4 destination
• https://support.google.com/analytics/answer/10739859 — GA4 Help: consent mode and data behavior

Related on PULSE

• [How to set up multi-touch attribution in Google Analytics 4?](/knowledge/sw0094)
• [What are the best analytics tools for SaaS revenue operations?](/knowledge/sw0076)
• [How to integrate Salesforce with LinkedIn Sales Navigator for prospecting?](/knowledge/sw0075)
• [How to integrate Shopify with Salesforce for ecommerce CRM?](/knowledge/sw0099)
• [How does Google Workspace compare to Microsoft 365 for collaboration?](/knowledge/sw0086)