The Problem Link to heading

You’ve set up GA4 tracking, but how do you know it’s actually working? Standard reports have processing delays of 24-48 hours, making them useless for real-time validation. Real-time reports show aggregated data but lack the granular detail needed for debugging.

DebugView solves this by showing events as they arrive, with full parameter details, in near real-time. But there’s a catch: it only works when debug mode is enabled, and getting it to work consistently is where most people struggle.

This guide covers three methods to enable debug mode, followed by systematic troubleshooting for when things don’t work.

How to Access DebugView Link to heading

In GA4, navigate to Admin > DebugView (under the Property column).

You’ll see a timeline showing events from debug-enabled devices. If nothing appears, debug mode isn’t active on your device, or something is blocking the data.

If you use Google Tag Manager, this is the most reliable method because it gives you two debugging tools simultaneously.

How It Works Link to heading

When you activate GTM Preview mode, it automatically adds a _dbg=1 parameter to all GA4 requests. This flag tells GA4 to route those events to DebugView instead of standard processing.

Steps Link to heading

  1. Open your GTM container
  2. Click Preview in the top right
  3. Enter your website URL and click Connect
  4. A new tab opens with your site and the Tag Assistant panel

Your GA4 events will now appear in both:

  • Tag Assistant: Shows which tags fired and their trigger conditions
  • DebugView: Shows what data GA4 actually received

Verification Link to heading

In Tag Assistant, look for your GA4 tags. Click on any event to see:

  • Tag firing status (fired/not fired)
  • Trigger that activated it
  • Parameters sent

In DebugView, you should see the same events appearing within seconds.

Tip: Use Tag Assistant and DebugView together. Tag Assistant shows what GTM sent, DebugView shows what GA4 received. Discrepancies between them indicate data being blocked in transit.

Method 2: Google Analytics Debugger Extension Link to heading

A browser extension that enables debug mode without touching your GTM setup.

Installation Link to heading

  1. Install Google Analytics Debugger from Chrome Web Store
  2. Click the extension icon to toggle it on (icon turns orange)
  3. Navigate to your site
  4. Check DebugView

How It Works Link to heading

The extension injects a _dbg parameter into outgoing GA4 requests, similar to GTM Preview mode.

Limitations Link to heading

  • Chrome only: Won’t work in Firefox, Safari, or Edge
  • Affects all sites: While enabled, every GA4-enabled site you visit sends debug data
  • No GTM visibility: You only see GA4 data, not GTM tag firing logic

Warning: Turn this off when you’re done testing. Leaving it enabled pollutes DebugView with data from every GA4 site you visit, and other people with access to those GA4 properties will see your debug traffic.

Method 3: debug_mode Parameter in Code Link to heading

Add the debug flag directly to your tracking configuration. Use this when you need debug data from specific environments (like staging) or specific events.

For All Events (gtag.js) Link to heading

gtag('config', 'G-XXXXXXXXXX', {
  debug_mode: true,
});

For Specific Events Only Link to heading

gtag('event', 'purchase', {
  debug_mode: true,
  transaction_id: 'T12345',
  value: 99.99,
  currency: 'EUR',
});

In Google Tag Manager Link to heading

  1. Open your GA4 Configuration tag (or specific Event tag)
  2. Expand Configuration Settings or Shared Event Settings
  3. Under Fields to Set, add:
    • Field name: debug_mode
    • Value: true

Critical Warning Link to heading

Never publish debug_mode: true to production.

If you do, every visitor becomes a debug user, flooding DebugView with thousands of entries and making it useless for actual debugging.

Safe approach for GTM:

Create a variable that returns true only in specific conditions:

// Custom JavaScript Variable: Debug Mode Flag
function() {
  // Enable debug only for specific query parameter
  if (window.location.search.includes('debug=true')) {
    return true;
  }
  // Or specific cookie
  if (document.cookie.includes('gtm_debug=1')) {
    return true;
  }
  return undefined; // Important: return undefined, not false
}

Use this variable as the debug_mode value in your GA4 tags.

Important: To disable debug mode, you must exclude the parameter entirely or return undefined. Setting it to false or 'false' still activates DebugView because GA4 checks for the parameter’s presence, not its value.

Troubleshooting: DebugView Not Showing Data Link to heading

If DebugView is empty, work through these checks in order.

1. Verify Debug Mode Is Active Link to heading

Open Chrome DevTools > Network tab, then trigger an event on your site.

Filter for collect or google-analytics.com.

Look for the _dbg=1 parameter in the request URL:

/g/collect?v=2&tid=G-XXXXXXXXXX&_dbg=1&...

If _dbg is missing, debug mode isn’t being applied. Go back to the activation methods above.

2. Check for Ad Blockers Link to heading

Ad blockers (uBlock Origin, AdBlock Plus, Brave Shields, Privacy Badger) commonly block GA4 requests entirely.

Test: Open an Incognito window (which typically disables extensions) and repeat your test.

If DebugView works in Incognito but not in your normal browser, an extension is blocking requests.

Solutions:

  • Disable the ad blocker for your test domain
  • Use a browser profile without ad blockers for testing
  • Test on mobile (usually no ad blockers)

3. Check Internal Traffic Filters Link to heading

GA4’s Internal Traffic filter can block debug data before it reaches DebugView.

Check: Go to Admin > Data Settings > Data Filters.

If your Internal Traffic filter is set to Active and your IP matches the filter rules, your debug data is being excluded.

Solution: Temporarily set the filter to Testing mode. In Testing mode, data flows through but gets labeled as internal traffic.

4. Verify Device Selection Link to heading

DebugView shows data per device. You might be looking at the wrong one.

Check: Click the device dropdown in the top-left of DebugView. Even if it shows “0” next to a device, click to check if there are multiple devices listed.

Your current device might not be the one selected.

If you’ve implemented Consent Mode and the user hasn’t granted consent, events may not appear in DebugView.

How Consent Mode affects DebugView:

  • analytics_storage: 'denied': Events are sent with reduced data (no cookies, no client ID persistence). These limited events may not appear in DebugView.
  • analytics_storage: 'granted': Full events sent, appear in DebugView normally.

Test: Grant consent in your consent banner, then check DebugView.

6. Verify Measurement ID Link to heading

A wrong or mismatched Measurement ID means events go to a different GA4 property.

Check: In your GA4 tag configuration, verify the Measurement ID matches your property.

Find your correct ID in GA4: Admin > Data Streams > Select stream > Measurement ID (format: G-XXXXXXXXXX).

7. Network Issues Link to heading

Firewalls, corporate proxies, or VPNs can block requests to Google’s servers.

Test: Switch to a different network (mobile hotspot) and try again.

Check: In DevTools Network tab, look for failed requests to google-analytics.com. Status codes like 403 or network errors indicate blocking.

8. GA4 Processing Delays Link to heading

DebugView occasionally has delays of 30 seconds to a few minutes. This is a known GA4 behavior.

Solution: Wait 2-3 minutes and refresh the DebugView page (not just the browser tab).

9. Server-Side GTM Specific Issues Link to heading

If you’re using server-side GTM, the Chrome extension method won’t work because events route through your server domain, not directly to Google.

Solutions for server-side:

  • Use GTM Preview mode (works for both web and server containers)
  • Add debug_mode: true as an event parameter in your web container’s GA4 tags
  • Enable server container Preview mode to see server-side processing

Using DebugView Effectively Link to heading

Once debug mode is working, here’s how to get the most from DebugView.

Event Timeline Link to heading

The main view shows events in chronological order. Click any event to see its parameters.

Key things to verify:

  • Events fire in correct sequence (e.g., page_view before purchase)
  • Required parameters are present (e.g., transaction_id on purchase)
  • Parameter values are correct types (strings vs numbers)

User Properties Link to heading

User properties appear as a separate card. Verify that user-scoped data (like user_id, custom user properties) is being set correctly.

Conversion Events Link to heading

Events marked as conversions show a flag icon. Verify your key events are being recognized as conversions.

Top Events Summary Link to heading

The right panel shows event counts. Use this to check if events are firing multiple times (duplicate tracking) or not at all.

Best Practices Link to heading

Always Test in Incognito First Link to heading

Eliminates extension interference and cache issues. Start here to establish a baseline.

Use a Consistent Test Protocol Link to heading

Create a checklist of actions to perform during testing:

  1. Load page (expect: page_view)
  2. Scroll to bottom (expect: scroll if enhanced measurement enabled)
  3. Add item to cart (expect: add_to_cart)
  4. Complete purchase (expect: begin_checkout, purchase)

Cross-Reference with Tag Assistant Link to heading

DebugView shows what GA4 received. Tag Assistant shows what GTM sent. Compare both to identify where data is being lost.

Document Your Test Results Link to heading

Screenshot DebugView showing successful event capture. This becomes your reference for future debugging and QA handoff.

Filter Developer Traffic in Production Link to heading

If you use debug_mode in code (not just GTM Preview), create a data filter to exclude debug traffic from reports:

  1. Admin > Data Settings > Data Filters
  2. Create a filter for Developer Traffic
  3. Set to Active once validated

This prevents test events from polluting your production data.

Quick Reference Link to heading

MethodBest ForDrawbacks
GTM PreviewGTM users, full debuggingRequires GTM access
Chrome ExtensionQuick checks, non-GTM sitesChrome only, affects all sites
Code ParameterStaging environments, specific eventsRisk of production deployment

Sources Link to heading