GA4 DebugView: How to Test & Verify Events in Real-Time (4 Methods).

You pushed a new event to GA4 but nothing shows up in reports. Before blaming the code, use these four debugging methods — from quickest to most thorough. Each method reveals different information about your tracking pipeline, and using them in the right order saves hours of frustration.

The key to debugging GA4 is understanding where in the pipeline the issue might be. Is GTM not firing the tag? Is the tag firing but sending wrong data? Is GA4 receiving data but not processing it correctly? Each debugging tool answers a different question.

The Four Debugging Methods

Method 1: GA4 Realtime Report

The quickest sanity check. Go to GA4 → Reports → Realtime. This shows events received in the last 30 minutes. If your event appears here, GA4 is receiving it — the issue is downstream (processing, reporting, or filters).

What to check:

• Event name appears in the "Event count by Event name" card
• User count increments when you trigger the event
• Click on the event name to see parameter values

Limitations: Realtime doesn't show all event parameters, doesn't let you inspect the full payload, and has a 30-minute window. It also aggregates data, so you can't see individual hits from specific page views. If the event doesn't appear in Realtime, move to Method 2.

Method 2: GA4 DebugView

DebugView is GA4's purpose-built debugging tool. It shows a real-time stream of events from devices running in debug mode, with full parameter details for each event.

Enabling Debug Mode

There are three ways to enable debug mode:

1. Chrome Extension: Install "Google Analytics Debugger" from the Chrome Web Store. Toggle it on and navigate your site. This is the easiest method.
2. GTM Preview Mode: When you enter GTM Preview mode, debug mode is automatically enabled for your session. Events fired during preview will appear in DebugView.
3. Manual parameter: Add debug_mode: true as a parameter in your GA4 Configuration tag. This enables debug mode for all users (remove before going live).

Using DebugView

Go to Admin → DebugView. You'll see a timeline of events. Click any event to see:

• All event parameters and their values
• User properties set at the time of the event
• Whether the event is a conversion
• Consent status when the event fired

Pro tip: If you see a red circle next to a parameter name, it means the parameter wasn't registered as a custom dimension. The data is being collected but won't be available in standard reports. Register it in Admin → Custom Definitions.

Method 3: GTM Preview Mode

GTM Preview Mode is the most powerful debugging tool for understanding why a tag did or didn't fire. It provides full visibility into the GTM container execution.

What to Inspect

• Tags Fired / Not Fired: See which tags executed and which didn't. For tags that didn't fire, check the trigger conditions to understand why.
• Trigger evaluation: Click on a trigger to see which conditions passed and which failed. This often reveals issues like wrong variable values, mismatched event names, or page path conditions that don't match.
• Variable values: Inspect every variable's value at each event. This catches issues like data layer variables returning undefined, URL variables with unexpected values, or Custom JavaScript variables throwing errors.
• Data Layer contents: View the complete data layer state at each event. Verify that your data layer pushes contain the expected keys and values, and check the order of pushes.
• Console errors: Check the browser console while Preview is active. Custom HTML tags with JavaScript errors will show up here.

Common Issues Found in Preview Mode

• Tag fires on wrong trigger: The tag fires on every page view instead of just the conversion page because the trigger condition is too broad.
• Variable returns undefined: A Data Layer Variable returns undefined because the key name has a typo or the data layer push hasn't happened yet when the trigger fires.
• Timing issues: A tag fires before the data layer push it depends on. Use trigger sequencing or later trigger types (DOM Ready, Window Loaded) to fix this.
• Consent blocking: Tags with consent requirements show as "blocked by consent" in Preview mode if consent hasn't been granted.

Method 4: Chrome DevTools Network Tab

For the deepest level of debugging, inspect the actual network requests that GA4 sends to Google's collection servers.

1. Open Chrome DevTools (F12 or Cmd+Option+I)
2. Go to the Network tab
3. Filter by collect or google-analytics.com
4. Trigger your event and look for the collection request
5. Click the request to see the full payload

The payload is URL-encoded but you can use the "Payload" tab in DevTools to see the decoded parameters. Look for:

• en — Event name
• ep.* — Event parameters
• up.* — User properties
• tid — Measurement ID (verify this is correct)
• dl — Document location (page URL)

When to use this: Use the Network tab when you suspect GA4 is receiving the wrong data, when you need to verify exact parameter values being sent, or when DebugView isn't showing events that you think should be there.

Advanced Debugging and Systematic Workflow

Method 5 (Bonus): BigQuery Real-Time Export

If you have streaming BigQuery export enabled, you can query the events_intraday_* table for near-real-time event data. This is the ultimate source of truth — if an event appears in BigQuery, GA4 definitively received and processed it.

SELECT event_name, event_timestamp,
  (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location') as page,
  (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'your_param') as custom_param
FROM `project.analytics_123456789.events_intraday_*`
WHERE event_name = 'your_event_name'
ORDER BY event_timestamp DESC
LIMIT 10

Systematic Debugging Workflow

When an event isn't working, follow this order to systematically narrow down the problem:

1. Check Realtime: Is GA4 receiving any data at all? If not, the issue is with tag firing or network connectivity.
2. Check GTM Preview: Is the tag firing? Are trigger conditions met? Are variables resolving correctly?
3. Check DebugView: Is the event arriving with the correct name and parameters? Are parameters registered as custom dimensions?
4. Check Network Tab: Is the collection request being sent? Does the payload contain the expected data?
5. Check Processing: Wait 24-48 hours and check if the event appears in standard reports. Some processing delays are normal.

Key Takeaways

• Use Realtime for a quick sanity check, DebugView for parameter inspection, GTM Preview for trigger debugging, and Network tab for payload verification.
• Always enable debug mode via the Chrome extension or GTM Preview — DebugView only shows events from debug-enabled devices.
• A red circle next to a parameter in DebugView means it's not registered as a custom dimension and won't appear in reports.
• GTM Preview is the best tool for diagnosing why a tag didn't fire — it shows exact trigger condition evaluations.
• BigQuery intraday tables are the ultimate source of truth for event data verification.

Frequently Asked Questions

How do I debug GA4 events?

The most efficient approach is to work through the debugging pipeline in order: start with the GA4 Realtime report for a quick check that data is arriving, then use GA4 DebugView for full parameter inspection, then GTM Preview Mode to verify triggers and variables fired correctly, and finally the Chrome DevTools Network tab to inspect the raw collection request payload. Each tool answers a different question. Realtime tells you whether data is arriving at all; DebugView tells you what parameters were sent; GTM Preview tells you why a tag did or didn't fire; the Network tab tells you exactly what data left the browser.

What is GA4 DebugView?

GA4 DebugView is a real-time event stream in the GA4 Admin interface that shows every event fired from devices running in debug mode. Unlike the standard Realtime report, DebugView displays the complete parameter list for each event, shows user properties at the time of the event, indicates whether the event is marked as a conversion, and displays the consent state when the event was sent. A red circle next to a parameter name means the parameter hasn't been registered as a custom dimension and won't appear in standard reports. DebugView is available at GA4 Admin → DebugView.

How do I enable GA4 debug mode?

There are three ways. The easiest is to install the "Google Analytics Debugger" Chrome extension from the Chrome Web Store and toggle it on — this sets the debug_mode flag in your browser session without any code changes. The second method is to enter GTM Preview Mode, which automatically enables debug mode for your preview session and routes events to DebugView. The third method is to add debug_mode: true as a parameter directly in your GA4 Configuration tag in GTM — this is useful for testing in environments where the extension can't be installed, but it enables debug mode for all users and must be removed before the container is published to production.

Why are my GA4 events not showing in DebugView?

DebugView only receives events from devices that are actively running in debug mode. If you don't see events, first confirm that debug mode is actually enabled — either via the Chrome extension (the icon should be active), GTM Preview Mode (the GTM debug banner should be visible in the browser), or the debug_mode: true parameter in your tag. Also verify you are looking at the correct GA4 property — it is easy to have multiple properties and check the wrong one. If debug mode is confirmed active and events still don't appear, the tag may not be firing at all, which means the issue is in GTM; check GTM Preview Mode to see whether the GA4 tag is listed under "Tags Fired."

What is the GA4 Realtime report?

The GA4 Realtime report shows aggregate event data received by your property in the last 30 minutes. It is accessible at GA4 → Reports → Realtime. It displays active users, their location, top events by count, and top pages. Clicking an event name shows a limited view of its parameter values. The Realtime report is useful as a quick sanity check that events are arriving, but it is not suitable for detailed debugging because it aggregates data, shows a limited set of parameters, and has a short 30-minute window. For detailed per-event inspection with full parameters, use DebugView instead.

What is the difference between GA4 DebugView and Realtime?

The Realtime report shows aggregated event data from all users visiting your site in the last 30 minutes — no special setup is required to see data there. DebugView shows a detailed, per-event stream exclusively from devices running in debug mode. DebugView includes the full parameter list, user properties, conversion status, and consent state for every individual event hit; the Realtime report shows counts and a subset of parameters. Use Realtime to confirm data is arriving from production traffic; use DebugView when you need to inspect individual events during development or testing.

How do I use the GA Debugger Chrome extension?

Install the "Google Analytics Debugger" extension from the Chrome Web Store. Once installed, click the extension icon in your browser toolbar to toggle it on — the icon turns blue when active. Navigate to the page you want to test. Two things happen when the extension is active: detailed GA4 hit data is logged to the browser's developer console (open with F12 → Console tab, then filter for "Google Analytics"), and debug mode is set so events appear in DebugView in your GA4 property. The console output is useful for seeing raw hit data without needing to open GA4; DebugView is better for inspecting parameters alongside user properties and consent state.

How do I test GTM events in GA4?

Enter GTM Preview Mode by clicking the "Preview" button in your GTM container. A debug window will open alongside your site in the browser. From there you can see every tag that fired or didn't fire for each interaction. For GA4 specifically: verify the GA4 Event tag is listed under "Tags Fired" for the interaction you're testing, click the tag to confirm it sent the correct event name and parameters, then open DebugView in GA4 Admin to see the event arrive with its full parameter list. GTM Preview Mode automatically enables GA4 debug mode, so events appear in DebugView in real time during your preview session without any additional configuration.