March 26, 2025

Google Analytics 4 Key Events Not Working? Here are the solutions

Updated: March 26th, 2025

In this industry, few things are more frustrating than investing time in a tutorial or video, following every step, only to find that your setup doesn’t work as expected. Maybe the blog post you followed was outdated, or you misunderstood a crucial detail in the tutorial. Perhaps a bug in the system threw a wrench in the process.

Whatever the case, if you’re finding yourself frustrated with Google Analytics 4 key events not working, don’t worry.

Below, you’ll find a comprehensive list of some common issues (in no particular order) that could be plaguing your system, plus solutions to get everything working smoothly again.

Also, a quick side note: Key events in Google Analytics 4 were previously known as conversions.

Subscribe and Get the Ebook - working with reports in ga4

Video tutorial

If you prefer video content, here’s a tutorial from my Youtube channel.

 

Table of Contents

Here’s what you will learn in this article

 

GA4 is not installed on a page where the key event happens

Unfortunately, what seems like a small issue affecting only one aspect of your Google Analytics 4 setup may indicate a larger problem. It could be that you’re having issues with not only key events but also events in general.

To rule this out, check if GA4 is installed on all pages of your site. If you’re not sure where to start, I wrote an article on three different ways to set up Google Analytics 4. Once you identify which method was used for your installation, there are several ways to check that GA4 was properly installed.

 

Use Google Tag Assistant (Chrome Extension)

  • What it does: Google Tag Assistant helps you quickly check whether GA4 (or any other Google tags) are installed on a webpage.
  • How to use it:
    • Install the Google Tag Assistant Chrome extension.
    • Visit the page where the key event is supposed to occur.
    • Click the Tag Assistant icon in your browser toolbar, and it will show you the tags firing on the page.
    • Look for the GA4 configuration tag to confirm that GA4 is present.

 

Use the Browser Developer Tools (Console)

  • What it does: This method allows you to check whether the GA4 tag is firing by inspecting network requests.
  • How to use it:
    • Open the page in Google Chrome.
    • Right-click anywhere on the page and select “Inspect” to open the Developer Tools.
    • Navigate to the Network tab.
    • In the filter box, type “collect” to filter for GA4 network requests.
    • Refresh the page, and if GA4 is installed, you should see network requests sent to https://www.google-analytics.com/g/collect.

However, if you are using server-side tagging, the request URL might look like this: your.owndomain.com/g/collect.

 

Check the DebugView

  • What it does: DebugView in GA4 lets you see real-time events sent to GA4.
  • How to use it:
    • In GA4, navigate to Admin > Data display > DebugView.
    • Ensure Debug mode is enabled on the page (you can do this using the Google Tag Manager’s Preview Mode or downloading the Google Analytics Debugger Chrome extension).
    • Visit the page where the key event occurs and trigger the event.
    • If GA4 is installed and correctly configured, the event should appear in the DebugView in real-time. A regular event will have a blue icon, and a key event will have a green flag icon (more on this later).

What should you do if any of these options show that GA4 may not work?

Assuming you had the help of a developer to complete the installation of GA4 (either through GTM or gtag), I would recommend going back to that person or team and asking them to review the implementation process. Show them the page(s) that appear to be missing code to see if that helps them narrow down their workload.

If you installed GA4 with Google Tag Manager, you should also check the GA4 configuration tag to ensure that elements like the measurement ID and triggers are correct.

 

Typos

If you’re sure you’ve set up your event as a key event, the issue may come down to just some incorrect spelling or formatting.

Setting up a key event is pretty simple; there are not many steps, so there are not many places to go wrong. However, one pivotal part of setting up a key event is indicating the event you want to capture. Depending on how you do it (e.g., existing event, create or modify an event), this could involve typing in the name of the event, which is where things can get messed up.

GA4 is case-sensitive, so even the smallest error in spelling or capitalization can prevent the system from properly recording events. For example, form_submission and Form_submission have different values.

I recommend doing a quick audit of your events (or getting someone else to take a look) to ensure that each key event matches its name exactly. Sometimes, a second set of eyes can find details you would have missed!

To avoid this in the future, here are some tips on naming conventions and keeping everything organized.

 

Incorrect measurement ID

If you work with multiple GA4 properties, one potential issue is that your data is being sent to the wrong property. This is another mistake that can happen even to the best of us. The troubleshooting process for this issue depends on how you installed Google Analytics 4.

First, go to Admin > Data collection and modification > Data streams and check the Measurement ID, which starts with “G-” and you can find it towards the right of the screen.

Now check either your GA4 tags in Google Tag Manager or the measurement ID in your GTAG (in the website’s source code. I talk more about this here). If the measurement ID does not match, you might have discovered the cause of your problem!

Not sure how GA4 is installed on your website? Read this article.

The event is not marked as a key event

If you’re thinking, “Wait, I had to set up key events, right?”, we may have found your problem right away.

While there are a handful of events that GA4 automatically marks as a key event (like first_open, app_store_subscription_convert, app_store_subscription_renew, in_app_purchase and purchase), you need to indicate in the Google Analytics 4 interface that you want another event to be a key event.

If you can see that the Event count metric is positive but the Key event metric is zero, this may indicate that your event is working properly, but you have not set it up as a key event.

You can use the DebugView to immediately check that an event is flagged as a Key Event. The primary feature built-in for debugging GA4 data is the DebugView. You can find it by going to Admin > Data display > DebugView on the left side of the GA4 interface.

Do not mix this up with the GTM Preview and Debug mode. They are two different beasts.

Enabling the GTM Preview mode in GA4 is enough to enable the debug mode. Then, all events sent to Google Analytics 4 will have a debug_mode parameter attached to them, and this data will be visible in the GA4 DebugView.

Another option to enable the debug_mode in Google Analytics 4 is to install the Google Analytics Debugger Chrome extension. Once installed, simply click its icon to activate it (you’ll see the ON ribbon). From this point, you can trust that your events will start appearing in DebugView.

Ensure you have selected the correct Debug device in the top left corner. If more than one visitor has enabled the debug view (e.g., they have all enabled the Chrome extension), you will see multiple devices there, and it might require some time to find yourself.

You will notice that Google marks events with blue icons and key events with green. All you need to do here is ensure that the events you have set up as key events have the green flag icon.

If you need to test some events in general, review the GTM Preview mode and DebugView in Google Analytics 4 articles.

If you don’t see the green flag next to your event, it means this event is not labeled as a key event!

Thankfully, I have an entire article dedicated to how to set up key events, whether for an existing event or an event you create within the GA4 interface, so check that out! To mark an event as a key event in GA4, you must ensure that you are a marketer or above. If you’re unsure about this, ask the owner of your GA4 property.

 

“Modify event” feature

If you’ve used the “Modify event” feature in GA4 to change the name or parameters of an event, it could cause issues with key event tracking.

Let’s say you aren’t happy with how you or someone else named an event in Google Tag Manager but can’t (or don’t want to) change it there. You can modify the event name in GA4, which is super handy. However, if you’ve marked this event as a key event, GA4 will no longer recognize it as the original key event since the name is different!

For example, in the screenshot below, you can see that I have a key event called form_submission.

Since this is an example, I will modify this event name to form_submission_modified.

Now, when I test this event using DebugView, you can see that form_submission_modified is not marked as a key event (unlike thankyou_page_visit).

So, if you have modified the name of a key event, make sure that you mark that new event as a key event!

 

The event name is too long

As per Google documentation, “If you mark an event as a key event and the event exceeds 40 characters, then the event will not be reported as a key event because the appended “_c” will be missing.”

You may not know this, but there is a comprehensive list of limitations that you need to consider when it comes to creating events. The list for non-360 users is here, and the list for 360 users is here.

 

The key event happens inside an iframe

When an iframe on your site is on a different domain, event data will not be shared with the parent page, and GTM and GA4 on the parent page will not be able to detect the event without proper setup.

To resolve this, you can add a GTM container inside the iframe to track events directly within it. If the iframe is hosted on a different domain, you need to install GTM in the iframe (if you have access to do so) and use window.postMessage() to send data from the iframe to the parent page. Additionally, make that key events inside the iframe are pushed to the data layer so GTM on the parent page can capture them and trigger the appropriate tags.

If you want a more comprehensive explanation of how to track iframes with GTM, this topic is available in my Intermediate/Advanced Google Tag Manager course.

 

GA4 event tag does not fire in GTM

When setting up a brand-new event as a key event in GA4, the issue may lie within the event configuration itself. For example, GTM may not trigger the event on your site. This issue could stem from various causes, such as code errors, incorrect triggers, or conditions not being met.

To troubleshoot, it’s a good idea to use tools like Preview mode in GTM and DebugView in GA4 to confirm that the event is firing as expected. These tools allow you to test in real time and help you pinpoint any misconfigurations or issues preventing the event from being triggered correctly.

For example, you can find a list of tags that did not fire using Preview mode in Google Tag Manager. Here, you can click on any tag and see what conditions resulted in the tag not firing. So, if you have a tag that you expected to fire but didn’t, you can see the reason why!

The solution would be to either change the trigger conditions in GTM or, if it’s a custom event, work with a developer to update the data layer push event.

I also have a blog post on reasons why a tag in Google Tag Manager is not firing (or fires when it shouldn’t), so you can check that out to learn more about potential issues.

 

dataLayer is broken

Event tracking will not work properly if the data layer declaration, e.g., dataLayer = [], is placed below the GTM container snippet.

This is because you need to initialize the dataLayer before GTM can use it to push data for event tracking. If it is placed below, it will overwrite the data layer and break it. Thus, GTM will stop seeing new data pushed to the data layer.

To fix this, ensure that you place the dataLayer = [] code above the GTM container snippet (you may need a developer’s help for this). Or, even better, always use the dataLayer.push() method:

window.dataLayer = window.dataLayer || [];
window.dataLayer.push({})

Once you have corrected the order, test your events with GTM Preview mode and DebugView in Google Analytics 4 to ensure data is passed to GA4.

 

 

gtag does not send the event to GA4

If the Google tag (gtag.js) is not sending an event to GA4, there are several common pitfalls in the setup that could be causing the error. Some things to check are:

  • Make sure that the gtag.js snippet is added correctly to the <head> section of the website code .
  • Any event tracking cannot fire before the gtag.js snippet is loaded (any gtag() function needs to occur after this).
  • Double-check that the GA4 measurement ID is (1) in the snippet and (2) the right one (maybe the tracking works, but it’s being sent somewhere else).
  • Review the event name (make sure it’s the same as what you set up as a key event).

You can review my article on how to track events with Google Tag to check that you followed all the steps properly.

 

User doesn’t give consent: tag is blocked

If users don’t give consent, especially in regions where privacy laws apply, a consent management platform (CMP) or cookie banner typically blocks the tracking script from firing. This usually happens when users decline cookies or tracking consent via a cookie consent banner or something similar.

When a user does not grant consent, the GA4 or GTM tags (if they are configured to respect user’s consent preferences) won’t fire, meaning GA4 will not receive key event data.

 

Implementing advanced consent mode will enable your site to send cookieless pings even if a user denies consent to analytics cookies. Google Analytics 4 will not directly display this data (e.g., in DebugView); rather, it will undergo a modeling process to estimate what unconsenting users did on the site.

Based on the modeling process (which is a black box), the key events data may not be reported in GA4 reports. As per Google documentation, “When users don’t grant consent, events are not associated with a persistent user identifier… Analytics applies machine learning to estimate the behavior of those users based on the behavior of similar users who do accept analytics cookies…”.

In other words, when you send events to GA4 (with denied consent), some events will eventually be displayed in the reports (but not all of them).

You can learn more about Google’s Behavioral modelling for consent mode here. If you want to learn more about consent mode, my GTM course for beginners has an in-depth module on the topic.

 

Not enough time has passed

If you’ve just created a new event and marked it as a key event, you might be frustrated when you don’t see it in your report immediately. But don’t panic–this is common GA4. The platform can take anywhere from 24 to 48 hours to process and display data for new events.

So, chances are you’ve done everything right, and it’s simply a waiting game! If, after 48 hours, you still don’t see your event data in any reports, it may be time to explore some of the other chapters in this article.

Also, be aware of Conversion Modeling. GA4 may reattribute a key event to another traffic source within 12 days days after it was recorded.

 

Sampling

Sampling can occur when the number of events used to create a report or exploration exceeds the quota limit for your property. This means that GA4 will use a subset of your data to estimate the total values for events rather than processing every single event.

This can affect your key event data, as the number of key events shown in your reports could be an estimate (rather than an exact count). If your key event count often looks wonky, it may be due to sampling.

How can you avoid sampling?

  • Reduce the number of elements in your report: Try to limit the time frame for your reports, reduce the number of dimensions, or filter the data to include only the most relevant information (e.g., focusing on a specific user segment).
  • Create an unsampled report: For GA4 360, when the data in an exploration is sampled, you can “request unsampled results” that will load a new tab in the same exploration containing the unsampled data.
  • Use BigQuery: Another way to avoid the issues caused by sampling is by exporting your data to BigQuery for deeper analysis. BigQuery lets you work with raw, unsampled data, providing a more accurate picture of your key events without sampling interference.

 

Incorrect date range

Picture this: you have an event you’ve been tracking for a while, and on January 1, you set that event as a key event. Now, you go to look at key event data before January 1, but you don’t see anything.

If you recently marked an event as a key event but are looking at a date range that includes the time before you labeled it as such, you will not see any data for it.

Why? Although the event existed, it wasn’t considered a key event until you made the change. As a result, if the selected date range spans the period when the event was active, but you hadn’t yet marked it as a key event, the data will not appear.

 

Filter/comparison/segment excludes the event

Along with the date range, another sneaky part of reports and explorations that can cause unnecessary headaches is when you unknowingly include a filter, comparison, or segment that you don’t need.

If you duplicate a tab in an exploration (to save time), but I forget to remove certain aspects you no longer need (segments/filters), you may end up spending more time trying to figure out what’s happening than if you had just started with a blank tab.

So, if you are working with an exploration, check the filters and segments.

For the built-in reports, check the filters and comparisons.

Ensure there is nothing in your reports you didn’t explicitly put there!

 

Ad blockers or other privacy-related extensions

Call it a feature or symptom of today’s web browsing behavior, but ad blockers and other privacy-related blockers and extensions make life difficult for web analysts.

Popular browser extensions like Ghostery, AdGuard AdBlocker, and AdBlock Plus make it easy to block Google Analytics. If you’re using one of these blockers (or anything else similar), try disabling it and see whether it helps. You’ll need to disable the extension to have a working preview mode.

Not sure which extension is causing the problem? Try disabling them one by one to determine the root cause.

However, in this case, the entire session will likely not be tracked. Therefore, it’s less probable that ad blockers (and other privacy-related extensions) would affect only key events. But I thought it was still worth mentioning this.

 

Internal/developer filter

In Google Analytics 4, you can exclude internal traffic (traffic coming from your employees or co-workers). This feature checks the visitor’s IP address, and if it matches the rules for internal or developer traffic, GA4 will exclude your events. However, that might be why you cannot see your key events in the reports (actually, in this case, you would not see all of your events).

The first place to check is Admin > Data collection and modification > Data filters. If you see “Active” next to the Internal and Developer filters, this might be the reason.

But we are not done yet. In the Admin panel, go to Data Streams > Click your web stream > Configure tag settings > Show more > Define internal traffic.

This will open a list of rules that define internal/developer traffic.

  • If you see no rules, your GA4 key events are not showing up for another reason (in that case, continue reading this blog post).
  • If you see some rules, click them and see which IP addresses are configured. If one of them is yours, that might be why you don’t see your key events in GA4.

 

Server-side tagging issues

With server-side tagging, if there’s no GA4 client to accept the request or no GA4 tag to forward the data, the event data won’t be sent to GA4. Server-side tagging processes the data on your own server instead of directly in the browser, and for this setup to work, you need both the correct GA4 client and GA4 tag properly configured on your server.

In your SGTM container, you should check that you have a GA4 tag and that the trigger for it includes the following condition:

This article introduces how to set up server-side using Google Tag Manager, and it can help you review the entire server-side process.

Subscribe and Get the Ebook - Server-side tagging

SGTM: tag does not fire

Using the previous chapter, you can do a quick check to make sure that your server-side GTM container is set up properly. If you still have issues, the problem may lie with a particular tag.

The tag may not fire because a trigger condition wasn’t met, which resulted in key events not being sent to GA4 as expected. This can happen if the conditions defined in the trigger—such as a specific event or query string—are not satisfied.

For example, if the trigger is set to fire only when a particular query parameter has a specific value, but that value is incorrect (or not present), the event won’t be tracked.

You can learn more about triggers in SGTM container here.

 

Changes are not published in the GTM container

If you have followed any of my articles to set up event tracking, you will know that I always include how to test if an event works. The great thing about Google Tag Manager is that it has a preview mode available to test your events.

One mistake that can come from this, though, is that you can’t just update your GTM container and call it a day; you need to publish the container, too.

So, make sure that you are not only testing your events but actually publishing the changes once you’ve confirmed that everything is working.

 

Content Security Policy

A Content Security Policy (CSP) is a browser security feature that helps prevent certain types of attacks, like data injection attacks. To do this, it restricts the sources from which content can be loaded (like JavaScript).

If your website has a CSP policy that is too restrictive, normally, the entire session would not be tracked.

However, let’s imagine a situation: Using cross-domain tracking, you are tracking across websites A and B. Website B contains the “Thank You” page that you track as a key event. Website B also has a more restrictive CSP.

In this case, the CSP can block necessary resources, such as Google Analytics 4 or Google Tag Manager scripts.

As a result, only the key event is affected, not the entire session.

How can you determine if this is the issue you’re facing? Go to your browser’s developer console (right-click on your webpage and select “Inspect”) and refresh the page. If you find an error that looks like this (or something similar), your Content Security Policy is causing issues for cross-domain tracking.

In this case, the URL of the error might also contain google-analytics.com.

In 2022, Google changed the URL where GA4 sends data. Previously, it was just www.google-analytics.com; now, it might be region1.google-analytics.com (or something similar). So, it would be best if your developers updated the CSP to support all domains containing google-analytics.com.

This means that developers should add *.google-analytics.com and *.analytics.google.com to the “connect-src” and “img-src” instructions in the content security policy (*. at the start is important).

You can learn more about this in Google’s documentation on using Google Tag Manager with a Content Security Policy.

 

Cross-domain tracking issues

While GA4 will still track key events, if cross-domain tracking is not working, they won’t be attributed to the original traffic source. I have written an entire article on various reasons why cross-domain tracking might not be working (and possible solutions), so if you suspect you have an issue, you can check that out.

If you want to learn more about cross-domain tracking in Google Analytics 4, check out my blog post on the topic. This article walks through the process of setting up cross-domain tracking, so it might be useful to review it and check for any missteps in your setup that could be causing the issues you’re facing.

 

The same key event happens multiple times in a session

If you’ve set your key event count to “Once per session”, you might notice an unexpected dip in your Key events count. For example, after triggering the same key event multiple times in a single session while testing, you may find that the number of completed key events is lower than expected when you later check your reports.

You can set a counting method for each key event. To check and change the current counting method, go to Admin > Data Settings > Key Events and select “Change Counting Method” under the menu for each listed event.

Here, you can set the counting method to “Once per event” or “Once per session”.

It’s important to remember that GA4’s default behavior is to count each event individually (once per event), so when you change the setting to “Once per session,” the count of new key events will naturally become lower, as it tracks the event only once per session.

 

Key events are not retroactive

For events that were set up before you marked them as key events, any past data won’t contribute to the key event count moving forward.

It’s important to remember that marking a key event is not retroactive. Therefore, the event will only start contributing to the key event totals from the moment it is labeled as a key event (although the data may not appear immediately).

 

Google Analytics 4 Key Events Not Working: Final Words

I hope this list of potential issues helps you determine what’s preventing your key events from working. This article is quite long, but I wanted to ensure I covered most of the issues.

If you’ve encountered a challenge with your key events that wasn’t covered here, I’d like to hear about it! Please feel free to share your experience in the comments below. We all learn from one another.

Subscribe and Get the Ebook - JavaScript for Google Tag Manager
Julius Fedorovicius
In Google Analytics Tips
0 COMMENTS

Leave a comment

Your email address will not be published. Required fields are marked *