GA4 Integration with Non-Google Products: What Can Possibly Go Wrong?

This detailed guide covers how the efficiency of certain Google Analytics (GA4) Integrations with Non-Google Products use cases can be impacted, what can possibly go wrong when using them, and what to keep in mind. This article was previously titled: “GA4 Integrations: This Ain’t The Good Ol Days”, but the title was changed, and the content was updated with recent findings to provide more clarity on the knowledge you’ll get from this blog post.

A quick thing to keep in mind; this article is not meant to condemn or praise the current version of Google Analytics as the best or worst analytics product. Instead, its purpose is to reflect on the possibilities of Google Analytics (GA4) concerning integration and highlight how industry changes like “Privacy”, its measurement model, and other elements can impact integration efficiency between Google Analytics and product outside the Google ecosystem. It also sheds light on the considerations you should have when integrating your Google Analytics (GA4) property with non-native Google products or products outside the Google ecosystem. 

Let me clarify that non-Google product integrations with GA4 are not inherently wrong, and there is no discouragement from using them. However, in scenarios where they will cause more harm than good, as shown in this article, it’s best not to use them and instead opt out for a manual approach if it’s possible for what you intend to achieve with the syncing of both tools.

The goal of this article is to explore specific angles of possible Google Analytics (GA4) integration with products outside the Google ecosystem and discuss how their use cases might often turn out to be problematic; you’ll also get insights on how to identify if these challenges exist in your current setup and the strategic decisions to make when playing with integrations.

The Power Of Integrations, And How GA4 Has Evolved

It is essential to acknowledge that integration significantly enhances the power of every analytics instrumentation and tool. It positively impacts how data gets utilized to achieve business goals, improves analysis, enriches data, and expands the possibilities of what is possible with data.

And how has Google integration with other native Google products evolved in GA4?

The Google Analytics product team designed Google Analytics 4 (GA4) in such a way that it integrates more seamlessly with more products within the Google ecosystem, as you are likely aware. This native integration makes GA4 a potent tool, providing marketers and analysts with various options to activate data for marketing purposes, export data to Google BigQuery for in-depth analysis and data ownership, and analyze Ads marketing campaigns and sampled organic search performance of websites.

Google Analytics 4 (GA4) now offers enhanced integration capabilities with various products within the Google ecosystem for free and 360 customers. These integrated products encompass a diverse range, including:

• Google Ads
• Ads Manager
• Big Query
• Display & Video 360
• Floodlight
• Merchant Center
• Google Play
• Search Ads 360
• Search Console
• Adsense

The Integration Move You Have To Make

Before GA4, most marketing stacks or business software allowed integration with Universal Analytics (the version of Google Analytics that was sunsetted in July 2023 for standard customers). With the emergence of GA4, these platforms should provide an upgraded native integration for GA4. However, it’s crucial to understand that third-party integrations with GA4 for products outside the Google ecosystem behave differently from what we were accustomed to in Universal Analytics. This realization prompted the publication of this article.

Non-Google Integration Purposes and Use Cases for Google Analytics (GA4):

Exploring the intricacies of integrating the latest Google Analytics (GA4) version with non-Google products might raise questions. How can such integrations potentially present challenges? Where can you find insights to assess if these challenges exist in your current setup? What strategies and considerations should guide you when navigating integrations?

Simple plug-and-play solutions might prove inadequate and even generate additional issues. However, rest assured that I will delve into addressing these inquiries and more in the next section of this blog post. But first, let’s swiftly examine some real-life use cases and reasons for connecting your Google Analytics property with non-Google ecosystem products.

Moreover, it’s essential to acknowledge that certain integrations can serve multiple objectives.

• GA4 Instrumentation 
• Event Collection within and outside GA4
• Event and User Data Enrichment within and outside GA4
• Data Modelling
• Data Extraction

GA4 Instrumentation:

These No-Code platforms allow you to implement the GA4 tracking code on your website, enabling you to track user actions as events in Google Analytics. When using this type of integration, there are only a few aspects to be concerned about, “privacy, method of instrumentation and standardization”, which I’ll discuss in the following section of this article.

Event Collection Within and Outside GA4:

Certain integrations facilitate tracking specific user interactions with third-party products as events in GA4. For instance, website chat widgets can trigger a GA4 event upon your website visitor starting a chat session; also, platforms like Microsoft Clarity can register an event named “Clarity” when integrated with GA4 and when the Microsoft Clarity script gets loaded on the website.

Moreover, some integrations use GA4 events that got triggered to send events to the integrated platform. However, these events follow the GA4 event schema and its properties. A real-life example will be how the Fullstory integration with GA4 functions; the integration listens to all GA4 events and transforms them into custom events for Fullstory.

When using any GA4 integrations for event collection, there are specific considerations to be aware of, which I’ll explain in detail later in the blog.

Event and User Data Enrichment within and outside GA4:

Another use case of GA4 integration that raises significant concerns is when the integration aims to enrich GA4 event or user data. Let’s take Microsoft Clarity as an example again. Session recording tools often trigger an event and then pass the session recording playback URL as an event parameter or sometimes as user properties (which is not advisable when using user properties).

In the following section, I’ll explain how this can present challenges during analysis and even lead to significant data discrepancies.

It’s important to note that this integration use case is not limited to session recording tools; it’s merely an example to help you grasp how the integration functions.

Furthermore, this integration can also be utilized to enrich user data in the third-party platform, which is a non-Google product.

Data Modeling:

Some non-Google products integrate with Google Analytics to leverage the data collected in GA4 and utilize Machine Learning and Artificial Intelligence for insights or predictions. While I can’t provide a specific example right now, it’s evident that concerns related to GA4 and products outside the Google ecosystem for this use case are relatively minor when using such integrations, except there are privacy concerns that must be addressed to ensure compliance.

Data Extraction:

These integration use cases are often used to transfer Google Analytics data to a different reporting or dashboarding platform. Countless software options offer such integrations, and generally, this is a minor concern, except in rare cases, which I might cover later in the blog.

What Can Possibly Go Wrong With Non-Google Integration (Using Real-Life Use Cases)

There are crucial factors that now demand attention when integrating Google Analytics (GA4) with products outside the Google ecosystem—privacy and the GA4 measurement model. Additionally, “Standardization in GA4” is another relevant consideration.

I will explain the significance of these factors and provide real-life examples to demonstrate how they can impact the efficiency of GA4 integration.

Privacy and Its Impact on Third-Party Integration Efficiency:

Significant changes have occurred since the inception of Google’s Universal Analytics, particularly with the introduction of privacy laws like GDPR, DPA, HIPAA, and LGPD, among others. Regulations like GDPR require obtaining consent from users before deploying tracking technology on their browsers for data collection, which may involve tracking and marketing cookies.

I’m not a privacy expert, but regarding GA4, In privacy guidelines like GDPR, website visitors must grant marketing and advertising consent types before GA4 can be used for advertising and analytics data collection. However, the platform you are integrating GA4 with might require a different consent category or a similar one, not precisely those mandated for GA4.

Moreover, some consent banners allow users to grant consent at the vendor level. This responsibility falls on the platform integrating GA4 for event collection or event and user data enrichment; to ensure that these consent choices are considered before emitting a GA4 event. 

Unfortunately, not all product integrations with GA4 are equipped to handle this task consistently, and compliance might not always be guaranteed, as the tool itself is primarily responsible for checking and ensuring its own privacy compliance, not that of GA4.

For instance, in the case of GA4 and Microsoft Clarity integration, the Clarity integration may fire a GA4 event with the “session playback URL” as a variable, even when GA4 consent has not been granted. This means that Microsoft Clarity will trigger the GA4 event without adhering to the consent required for firing the GA4 tag.

Similarly, using the native GA4 implementation software can pose challenges. While some Consent Management platforms offer automatic blocking, relying solely on this feature may only sometimes be foolproof. 

There could be instances where the integration injects the GA4 tracking script above the consent script, which is meant to block tags from firing or setting cookies on the user’s browser. Such a setup could fail, resulting in compliance issues and potential fines. Ensuring compliance often requires meticulous attention to detail.

GA4 Measurement Model and Its Impact on Third-Party Integration Efficiency:

Google Analytics 4 (GA4) employs a measurement model that differs from what we were accustomed to in Universal Analytics. In GA4, everything is an event. However, some experts still argue it’s not entirely an event-based measurement model due to the return of scoping and other elements.

While the event measurement model is not new in the world of digital analytics, its usage in GA4, particularly with non-Google product integrations, can impact event data enrichment, as seen in the example of Microsoft Clarity, where an established Microsoft Clarity and GA4 Integration registers an event named “Clarity,” including the session recording playback URL as an event parameter, which enriches the event data, allowing easy access to the user session recording playback video using the URL.

The impact of the event measurement model is that the event parameter is only available for the event registered by the integration. Thus, you cannot access the parameter in other GA4 events. Unlike Universal Analytics, where “session scope custom dimensions” ensured the parameter’s availability in all hits collected for that website session, GA4 lacks this feature.

Event-based analytics tools like Mixpanel use what is known as “Super Property”, which gives you the flexibility of having an event property/parameter be included in every event hit after you’ve registered it using the tracking commands. (Probably something that I’ll like to see in Google Analytics)

For example, suppose you want to easily access the session recording playback URL for a transaction or 404 error event. In that case, you won’t be able to do so conveniently within the GA4 reporting interface, and in some cases, it might even be impossible. While a few workarounds exist using Google Big Query to stitch together data using the GA4 session ID, this presents challenges for analysis.

Using Clarity as an example again, the image shows that the session recording URL is available only for events dispatched by the GA4 and Microsoft Clarity integration, which has the name “Clarity”.

This limitation may prompt you to devise a method to ensure the parameter is available on all event hits or rely on Google Big Query for analysis (if your GA4 property has been synced with it). Alternatively, you may have to accept and live happily with the challenge.

Some integrations might attempt to bypass this limitation by using the user properties feature of Google Analytics. However, you must exercise extra caution to determine if this approach suits your use case. For instance, using user properties to send website visitor IDs from third-party software to GA4 is acceptable for user-level data. However, for session-based data points, such as session recording playback URLs or session IDs, employing user properties can be problematic and may disrupt your analysis.

This limitation in the areas of integration with session recording prompted the publication of an article outlining how to integrate GA4 with nine-plus session recording tools, not as the primary integration method, but as a complementary solution to address this challenge.

Standardization in GA4 and Its Impact on Third-Party Integration Efficiency:

With the introduction of GA4, a new naming syntax has emerged where events are expected to follow a snake and lowercase format. Also, Google’s recommended event names, such as “generate_lead” for lead generation, are encouraged to be used when tracking similar events that have a reserved name, as specified in their documentation.

However, a potential challenge arises when an event adopts a different naming syntax that aligns differently from Google’s snake case lowercase convention. Additionally, if the event name chosen for the action already exists as a recommended event, it may lead to not tapping from the benefits it adds to marketing or cause unexpected challenges when the integrated product triggers a different event.

While there are instances where not using the recommended event name might be feasible, primarily if Google Ads is not used with GA4, deviating from the “industry-believed” Google’s laid-out rules on event naming conventions can cause problems when utilizing certain Google Analytics (GA4) features, but it mainly impacts consistency.

Moreover, standardization not only applies to events but also extends to event properties, meaning event parameters are expected to follow the same standardization, though they are not mandatory.

The adherence to standardization becomes particularly crucial for integration use cases involving GA4 instrumentation and GA4 event collection, event, and user data enrichment. Ensuring consistent standardization across all aspects of the integration process can significantly impact its efficiency and effectiveness.

Changes in the GA4 Measurement Protocol and Its Impact on Integration Efficiency:

Lastly, another factor to consider, albeit in rare and unique cases, is how the GA4 Measurement Protocol operates. While I won’t delve into great detail about the Measurement Protocol here, you can find more information about it in Julius’ video on the Analytics Mania YouTube Channel or watch Google’s team video on the Measurement Protocol.

What challenges does the GA4 Measurement Protocol present for third-party integration with Google Analytics? Let me reframe the question for you: In what scenarios can this impact the data quality collected through integrations with GA4 using the Measurement Protocol?

The problem arises when your GA4 integration with a third-party aims to collect an event in GA4, which should be tied to an existing active session already tracked outside the GA4 Measurement Protocol setup. If the hit is not configured correctly, it can negatively impact your GA4 data integrity, and I’ll explain further.

For example, when a user visits your website and performs all the necessary website and e-commerce actions tracked in GTM (Google Tag Manager), then makes a purchase, which is tracked by your GA4 instrumentation software, and the purchase conversion event hit gets sent through the Measurement Protocol, improper hit schema configuration can lead to data discrepancies. I’ll explain the missing elements that can complicate things.

Another scenario is when GA4 gets integrated with third-party software, and when a user interacts with the software widget embedded on your website, it sends an event through the Measurement Protocol. This means you have events set up in Google Tag Manager and another GA4 event sent through the GA4 Measurement Protocol due to the product’s integration with GA4. However, if the Measurement Protocol event hit is not well-configured, it can cause issues.

The reason the Measurement Protocol can be problematic is if one or more of the following are incorrect or missing:

• The Client ID (used to tie the event to the user)
• Session ID (used to connect the event to the user’s session where the event occurred)
• Timestamp (used to indicate when the event happened to Google if the event happens after 72 hours then it can be stitched back with the current session)

Suppose you can ensure that the event hit sent by the Measurement Protocol includes all these parameters correctly. In that case, you need not worry about any issues impacting the efficiency of your integration.

There are multiple ways to identify if there are issues due to missing or incorrectly configured parameters, but I won’t cover them in this article.

In this case, improperly instrumenting the GA4 measurement protocol parameters can have several adverse effects. One significant consequence is the potential for duplicate users or sessions, which, in turn, can significantly impact the accuracy of attribution in your reporting within Google Analytics.

How Does Google Analytics Impact Integration Efficiency When Instrumented in a GTM Server-Side Environment?

While I won’t delve into the technical details, I will ensure you understand the potential impact on third-party integration efficiency or the problem it could pose when using GA4 in a server-side setup with slight configuration differences, such as cookie settings and custom client IDs. These configuration differences in sGTM raise new challenges when integrating GA4 with third-party platforms that send events on the web, similar to the Clarity and GA4 integration example we saw earlier.

Please note that this scenario is not limited to Microsoft Clarity; it applies to any third-party platform capable of sending event data when integrated with Google Analytics, including chat software, embeddable widgets, etc.

In a specific scenario, when GA4 gets instrumented using server-side Google Tag Manager (sGTM), and you use the “server-managed cookie” type of cookies and client identification in your GA4 client within your sGTM container, and there is a third-party product integration with GA4 that triggers an event, similar to the “Clarity” event triggered by Microsoft Clarity, GA4 may count two users and two sessions. 

This happens because the sGTM GA4 implementation utilizes a server cookie called “FPID,” which uses a new Client ID stored in a secure HttpOnly cookie, while the event triggered on the web by the integration uses the standard Google Analytics JavaScript cookie.

Another instance is when you use a custom client ID, which is a user identification value generated and managed by you. In this case, the event triggered by the integration with the third-party software will create another user and a new session, as both are not using the same user identification method.

However, there are ways to address and resolve this issue. I won’t cover them in this article, but it is essential not to be discouraged from using sGTM with GA4 and third-party integrations. Instead, exercise caution and careful consideration when implementing these integrations.

Recommendation & Conclusion

As mentioned earlier, integrations play a crucial role in enhancing your analytics instrumentation, not just limited to Google Analytics. However, when working with GA4, there are specific considerations to keep in mind when dealing with integrations. Rather than viewing these integration challenges as obstacles, it is essential to recognize their existence and find ways to address them by using complementary integration solutions or ditching them when it adds more problems than they should solve. Identifying and resolving these challenges can be achieved by establishing a thoughtful process for integrating GA4 with third-party and non-Google software.

You can adapt and improve the thought process outlined below by asking and answering the following questions:

• What is the specific use case of this integration?
• Does the integration with GA4 align with your expectations and requirements?
• How do privacy concerns, the GA4 event measurement model, the instrumentation method, server-side tagging configuration, and GA4 data standardization impact the efficiency of this integration?
• If a manual integration approach is utilized, will it result in any loss of real value? If so, consider using manual integration as a complementary solution.
• Does the communication between both tools adhere to your privacy configuration?

In cases where integration does not add significant value but introduces unnecessary complications, it is advisable to avoid such integrations. Instead, consider opting for a more manual approach if feasible, or explore alternative solutions.

We have concluded this blog, covering various use cases of GA4 integration, the changes brought about by the sunsetting of Google’s Universal Analytics and the emergence of GA4, and how they may impact the efficiency of integrating GA4 with products outside the Google ecosystem. Moreover, we have addressed the thought process for establishing an integration with GA4 that avoids complicating matters further with Google Analytics (GA4). Until then, happy “GA4ing” if such a term exists.

I’m open to your feedback and intend to keep this article updated. If anything you feel needs to be added or subtracted, you can reach out to me on LinkedIn, and I’ll be happy to hear your thoughts.

Content Contributors