Google Analytics Debugger – how to debug GA4, DebugView and tags in Google Tag Manager

Shipping analytics tools and tracking scripts without carefully verifying them is one of the most basic mistakes experienced marketers and analysts still make.

In this article you’ll learn how to verify events using Tag Assistant for GTM, advanced Chrome extensions and browser developer tools. You’ll master advanced debugging of GA4 and ad pixel implementations, which will let you eliminate measurement errors, keep your setup technically consistent with your privacy policy, and above all feed advertising algorithms good-quality data.

Who is this article for, and what should you know before reading it?

Above all, you should know the basic technical concepts around using Google tools like GA4 and GTM. To understand this article you’ll need to be familiar with tags, events, the data layer, variables and triggers.

Why debugging Google Analytics tags and ad pixels matters

• Eliminating gaps in data – errors in the data layer configuration (known in the industry as the dataLayer, or just DL) often cause key GA4 parameters to go missing. If the value field (order value) disappears from your purchase event, GA4 and often your ad pixels won’t record the transaction value, which will completely wreck your revenue reports and campaign performance.
• Consent Mode V2 compliance – debugging lets you confirm your tags respect the user’s cookie choices. Verifying consent signals directly in the events guarantees consistency between your privacy policy and what your scripts actually do. That protects your organization from potential penalties under privacy regulators. Missing consent signals will block Google Ads remarketing, cut sessions in Clarity, and impair Bing Ads.
• Protection against duplicated events – a duplicated integration (two plugins both implementing GA4 in the store admin, say), or a duplicate event firing in the data layer, often artificially inflates your results. Diagnostics immediately expose double-firing like that, which would otherwise artificially pump up your stats.
• A complete view of the sales funnel – debugging tools help you verify e-commerce events at every stage, from landing on the product page, through adding to cart, to purchase. By debugging the path to purchase, we can learn how individual events work, exactly when they fire, and what information they carry. That knowledge lets you build and interpret GA4 funnel reports better.

Google Tag Assistant and DebugView in Google Analytics 4 – the main debugging tools

For debugging to be possible and meaningful at all, you have to understand how the individual tools work together.

• The Tag Assistant extension – lets you get an initial sense of whether, and which, Google tags are present on the page. With it you can find the IDs of the GA4 properties actually present on the site, as well as the GTM container ID. That’s useful when several services are often attached to a given Google account.

• GTM Preview Mode – lets you see which tags in your container fire, and what signals reach Google’s own tags (an AW tag or GA4, say). You can enter Preview mode either from the Tag Assistant extension or directly from GTM. Worth remembering: you can only debug the information GTM reads if you have access to it. Otherwise you can only see what GA4, Google Ads or your ad pixels are sending. To enter the debugger, go to the account you’re interested in, find the preview button (top right corner) and use it to open a new window where you enter the URL of the site connected to that GTM container.

💡 A valuable tip

Limited access isn’t a problem at all – when previewing the container you’re editing isn’t possible (read-only mode), you can debug the already-published version by going to the versions tab and clicking the preview on the latest version:

• DebugView in GA4 – a place in the Google Analytics 4 admin interface. Where GTM Preview Mode shows you what was sent from your browser, DebugView in GA4 confirms what was actually received and processed by Google’s servers and ultimately landed in the property. To reach the preview in GA4, go into the property you’re interested in, then the admin section, then data display, where you’ll find the DebugView tab.

Debug mode in Google Tag Manager – using preview in practice

Before launching preview, make sure you don’t have any privacy-enhancing extensions running (adblockers), and that you’re not using a browser with built-in tracker blocking (Brave, for instance). Those features can even fully block measurement and data sending to external tools, which would make checking anything impossible.

Opening GTM preview: We open the debugger by clicking preview and entering our site’s address. At that point the actual GTM preview screen should appear.

At this point we should pause. The view can feel a bit overwhelming at first — there really are a lot of tabs and sections here. Let’s go through them together.

GTM preview lets you:

• check every data layer event (the section marked 6 on the screenshot is the control element for the whole preview)
• check every data layer event on a given page. Don’t confuse these with GA4 events, which are a completely different concept – events sent to GA4 can be found in the tab that refers directly to that property (1).
• see which tags fired during specific interactions with the page (2)
• which tags didn’t fire – the preview lets you precisely pin down the source of a problem (2)
• see built-in and user-defined variables (3)
• see the data layer (4) at individual interactions with the page (6)
• check the user’s tracking consent signals (5)

1. Switching between individual Google tags – the screenshot above shows the section that lets you select a Google tag (1). It lets you see what information is actually being sent to GA4 or Google Ads. This is useful when some tools are implemented bypassing Google Tag Manager. Clicking on a specific event lets you check its detailed content (the data layer of an e-commerce event with its GA4 parameters, say).

2. A summary of the tags present in the container – let’s go back to the Google Tag Manager section. This section lets you check which tags fired on a given event and which didn’t. It splits into two parts: tags fired on that event, and inactive tags.

This is an excellent way to check whether your implementation is correct. Say you want to ship a conversion event: you build the tag and define the trigger. You enter debug mode and perform the action you’re interested in on the site. Unfortunately the tag doesn’t fire, so you find the moment it should have run and check the tag you’re interested in, then look at the details:

The firing details show information about the conditions and the variables used to define that specific user action on the page.

When you’re using complex firing conditions, you can see the status of each condition. On top of that, the properties section shows the information sent along with the tag (a value or a conversion ID for a purchase tag, say).

💡 A valuable tip
To find the exact place a given tag fired, you don’t have to click through every event in the events section (6) one by one. Just go to the summary (for a page or the whole session), find the tag you’re interested in, and check the unique event number that triggered it.

3. Variables – The next tab next to tags is variables. It lets you check what information the variables hold at a given event. Remember that as events change through the history, some variable contents will change too. The simplest example is the ecommerce.items variable, which carries information about the products the user interacted with. It will look completely different on a listing-view event versus a product-selection event, even though both interactions happen on the same page.

4. Data layer – The data layer tab is a simple yet very useful part of the GTM preview, especially for mid-level analysts. This tab shows what the whole layer looks like at the stage of a given event. Put simply: you get visibility into all the data available at that moment, and the values attached to each event in Google Tag Manager. Any piece of information available in the data layer can be turned into a variable, though most predefined variables don’t pull specific information from the data layer automatically – you have to define that manually.

5. The consent state tab – this section shows what consent state is present at a given event. For example, if you have a Meta tag set to respond to ad consent (ad_storage), and consent is granted too late, the tag will be blocked. Debugging lets you catch that error early and, for instance, move that tag to a different, later event.

In the case shown above, the tag won’t fire, will read the consent state as denied, and will automatically be blocked. That can be confusing at first. If I accepted consent, shouldn’t the consent state show as granted right away? Unfortunately the consent update mechanism works like this: the default consent state is always marked as denied, and it’s updated to the actual state as fast as possible.

Above is a view from a later event, where the consent state has already been updated.

DebugView in Google Analytics 4

The final step is checking the events you’re interested in directly in GA4’s DebugView.

In this last stage of checking, you need to focus on three points:

1. Whether GA4 receives the basic events – session start, engagement events, and whether it collects a page_view event on every page load.
2. Whether every custom eventyou configured (form submissions, say) reaches GA4.
3. Whether the e-commerce path events reach GA4 (every e-commerce event is documented in Google’s docs — events like add_to_cart or purchase). It’s worth running a quick checklist by checking the content of a given e-commerce event, just by clicking into it:
   • An e-commerce event contains information about item value, currency, and the items themselves along with their identifiers.
   • For a purchase event, the transaction_id parameter is essential. Without it GA4 won’t receive revenue information and will wreck most of your reports.
   • In the parameters section you’ll find the event’s value and currency, and in the items section every detail about the items connected to that event.

Google Analytics Debugger and other Chrome extensions – fast debugging

Analytics Debugger: Built by David Vallejo, Analytics Debugger is considered one of the best debugging extensions available. It loads directly inside DevTools, which stops it from interfering with the page view itself and makes it easier to debug on two screens at once. Worth noting: the same developer also offers an app for debugging analytics implementations on Android and iOS devices.

The extension offers a wide range of capabilities and goes well beyond what Tag Assistant offers. It’s particularly useful for debugging ad pixel implementations (Meta, TikTok, Bing Ads, for instance).

The tool’s main features:

• The tool isn’t limited to the Google ecosystem. It debugs signals from Tealium, Piwik Pro, Matomo, Adobe Tools and most popular marketing pixels flawlessly.
• It logs every piece of information sent to your ad pixels, with detailed information about items and transaction amounts — you can see everything reaching its destination.
• It logs the hits sent to Google Ads (remarketing information included).
• The tool shows whether a hit was sent to the sGTM server.
• It has a dedicated, highly readable tab for reporting e-commerce events (cart steps, sorted into e-commerce sections), which significantly speeds up QA.
• It shows the current consent-mode state for every hit/event sent.
• It stores information sent to ad pixels from previous pages – you can always go back to earlier stages of the purchase path. That’s this extension’s main advantage over the plugins from Meta or TikTok, which only show events on the current page.

Extensive documentation for the tool is available on its official site. But at the start of your journey with it, a few basics are worth knowing:

• You access the extension through developer tools: right-click > inspect > the Analytics Debugger tab should appear at the top.
• Before you start debugging, it’s worth adding the sections you’re interested in to your current view using the plus icon next to the section picker.

As mentioned earlier, the extension debugs not only GA4 but also ad pixels and other analytics tools.

Of course, the ultimate source of truth is the information in the network tab of your developer tools. But checking data that way is time-consuming and requires technical knowledge of what that information should look like. In day-to-day work it’s worth relying on ready-made solutions like the plugin mentioned above and Google’s own official tools.

Debugging ad pixels – conversion parameters and their verification

Most of the major ad platforms have their own dedicated tools for checking events. Meta Pixel Helper, for instance, is officially available as a Chrome extension (as are TikTok Pixel Helper and Pinterest Tag Helper). But juggling multiple tools during a comprehensive check can get frustrating. That’s why it’s recommended to use a plugin that groups every hit sent (Analytics Debugger) alongside Tag Assistant, to catch errors in tag firing early (only once a tag fires does it send information onward).

Each ad platform is a bit different and may need a different kind of data to run effective campaigns, but plenty of elements are shared across all of them. When debugging an implementation, focus on solid fundamentals and dig deeper as needed. Here’s a short checklist, universal across any ad pixel:

• the correct event name in the information sent onward
• no duplicate events
• basic product information sent (their identifiers above all – this directly affects the match rate with your product feed)
• the conversion event’s value

The key to effective debugging isn’t only mastering the tools, it’s understanding the characteristics of the specific ad platform. Source material is useful here. Documentation, even though it can look convoluted, will teach you a given pixel’s requirements inside out over the long run. Meta Pixel’s documentation, for instance, clearly lists the variables required on a given event for campaigns to work correctly.

Good data starts with good debugging

Effective analytics debugging is a process that demands method. Just clicking through a site with plugins enabled is nowhere near enough in a professional setting. Real data quality comes from agilely combining tools: you start by verifying your tag architecture in Google Tag Assistant, you examine the dataLayer in parallel with extensions like Analytics Debugger, you validate external systems using several sources of truth at once, and finally, when you’re after hard, indisputable proof, you cross-check all of it against the raw logs in your browser’s network tab. That workflow is the best investment you can make in any organization’s analytics scalability and reliability.