How to Fix Common GA4 Issues

Are you staring at your Google Analytics 4 (GA4) reports, feeling confused by messy, inaccurate, or even missing data? You are certainly not alone. Many business owners and marketers find GA4 challenging, especially when transitioning from Universal Analytics or setting it up for the first time.

Bad data can lead to poor business decisions, wasted marketing budgets, and a lack of trust in your own analytics. It can feel like navigating a maze without a map. But there’s good news.

This comprehensive guide will walk you through diagnosing, troubleshooting, and resolving the most prevalent GA4 issues. Tired of guessing why your data is off? Our goal is to empower you to build confidence in your analytics and make data-driven choices. Let’s start transforming your GA4 data from a headache into a reliable source of insights.

Understanding GA4’s Core & Why Issues Occur

GA4 is a powerful tool, but it works differently from its predecessor, Universal Analytics. But what exactly makes it so different, and why do things often go wrong? The biggest shift is its move to an “event-based” data model. This means every user interaction, from a page view to a button click, is considered an “event.”

This event-centric approach offers more flexibility but also introduces new ways for things to go wrong. Common causes of GA4 data problems often stem from misconfigurations during setup. These can be in Google Tag Manager (GTM) or directly in your website’s code.

Issues can also arise from incorrect event parameters, complicated consent management, and the complexities of tracking users across multiple website domains. Many issues are simply user errors made during the initial setup process. Understanding these underlying reasons is the first step to a successful GA4 troubleshooting guide.

Issue 1: The Dreaded “(not set)” Values

Ever wonder why GA4 just can’t seem to figure out where some of your traffic came from? One of the most common and frustrating sights in GA4 reports is the “(not set)” value. This label appears when GA4 collects data but cannot assign it to a known dimension. It means that a specific piece of information, like a traffic source or an event name, is missing or corrupted.

It creates gaps in your understanding of user behavior and campaign performance. You can’t tell where users came from or what they did on your site. This problem directly impacts your web analytics reporting accuracy.

Common Culprits for “(not set)”

• Traffic Acquisition (Source/Medium): Often, this happens when users arrive at your site without proper UTM tags, or it could be from direct traffic that isn’t identified.
• Event Parameters: If you expect a specific parameter (like item_name) to be sent with an event, but it’s not, GA4 might show “(not set).” This is a frequent problem when the event tracking configuration is incomplete.
• Page Location: Sometimes, a page path might be recorded incorrectly or not at all, leading to “(not set)” for page-related dimensions.

How to Diagnose “(not set)” Values

First, check your GA4 reports. Go to “Traffic Acquisition” to see if source/medium are “(not set).” Then, look at “Engagement > Events” to identify any events with missing parameters. The “Pages and Screens” report might also show “(not set)” for page paths or titles.

Next, use the GA4 DebugView. This powerful tool shows a real-time stream of events as they are sent to GA4. Pay close attention to any events missing expected parameters. If you use Google Tag Manager, activate Preview Mode. This lets you see exactly what data is being sent from your website before it even reaches GA4.

Step-by-Step Fixes for “(not set)”

1. For Source/Medium:
   • Ensure all marketing campaigns use consistent and correct UTM tagging (utm_source, utm_medium, utm_campaign).
   • Review your GA4 “Channel Grouping” settings under “Admin > Data Settings > Channel Groups.” Make sure your custom channels are correctly defined.
2. For Event Parameters:
   • In Google Tag Manager, open your GA4 event tags. Verify that all expected parameters are correctly extracted from your website’s data layer.
   • Check that the parameter names in GTM exactly match what GA4 expects or what you’ve defined as custom dimensions.
   • If you are not using GTM, ensure your direct gtag.js code includes all necessary parameters with each event.
3. For Other Dimensions:
   • If you have custom dimensions, ensure they are correctly registered in GA4 (Admin > Data Display > Custom Definitions). Also, confirm that the data type (text, number) matches the data being sent.

Issue 2: Broken Cross-Domain Tracking

Imagine a user starting their journey on your main website, then clicking a link to your blog (on a subdomain like blog.yourwebsite.com) or an e-commerce store (on a completely different domain). If cross-domain tracking isn’t set up correctly, GA4 will treat this single user as two separate individuals.

This issue inflates your user counts, skews session metrics, and makes it impossible to understand the complete user journey. It severely impacts the reliability of your GA4 data integrity. You lose the ability to see a holistic view of user behavior across your digital properties.

Why Cross-Domain Tracking Fails

By default, GA4’s cookies are domain-specific. When a user moves to a different domain, the original cookie isn’t carried over. This means GA4 cannot connect the new session to the previous one. It sees a new user starting a new session.

How to Diagnose Cross-Domain Issues

The Realtime report in GA4 is your first stop. Navigate between your main site and the linked domain. If you see a “new user” count jump immediately after moving to the second domain, you likely have a problem. You can also use your browser’s developer tools to inspect cookies. Look for the _ga cookie and see if it persists across both domains. It should carry a linker parameter in the URL when moving between domains.

Step-by-Step Fixes for Broken Cross-Domain Tracking

1. Method 1: Using the Google Tag (gtag.js):
   • Add the linker parameter to your GA4 configuration tag. This automatically decorates outgoing links with a unique ID.
   • Your code might look something like this:
     gtag('config', 'G-XXXXXXX', {
'linker': {
'domains': ['yourwebsite.com', 'blog.yourwebsite.com', 'store.anothersite.com']
}
});
   • Replace G-XXXXXXX with your actual Measurement ID and list all relevant domains.
2. Method 2: Using Google Tag Manager:
   • Open your GA4 Configuration Tag in GTM.
   • Under “Fields to Set,” add a new field named _gl (for linker) with the value true.
   • Under “Fields to Set,” you will also often find a section for “Cross-domain tracking.” Here, add a new field named linker and set its value to an object containing your domains: {"domains": ["yourwebsite.com", "blog.yourwebsite.com"]}.
   • Alternatively, under “Google Tag Settings” -> “Configure Tag Settings” in your GA4 Configuration Tag, you will find “Cross-domain tracking.” Add your domains there.
   • Test thoroughly in GTM Preview Mode to ensure URLs are decorated correctly.
3. Add Domains to Referral Exclusion List:
   • Go to “Admin > Data Streams > Your Web Stream > Configure tag settings > List unwanted referrals.”
   • Add all your interlinked domains here. This prevents GA4 from crediting your own domains as the source of new sessions.

Issue 3: Conversion Tracking Not Firing (or Firing Incorrectly)

Conversions are the lifeblood of your business. Whether it’s a purchase, a lead form submission, or a newsletter signup, accurately tracking these actions is crucial for measuring your marketing effectiveness. But imagine launching a massive Black Friday campaign, seeing clicks pour in, and then realizing your GA4 shows zero sales. That’s the nightmare of broken conversion tracking.

This is a major Google Analytics 4 error that can lead to incorrect attribution modeling and poor strategic decisions. It means you can’t tell which marketing efforts are truly driving results.

Why Conversion Tracking Goes Wrong

Conversion issues often stem from misconfigured event definitions or incorrect trigger setups in GTM. The event might be firing, but GA4 isn’t recognizing it as a conversion. Or, the event itself might not be firing at all.

How to Diagnose Conversion Problems

Start by verifying that your intended conversion event is actually being registered in GA4. Go to “Engagement > Events” and look for the event name. If it’s there, check the “Conversions” section under “Admin > Conversions” to ensure it’s marked as a conversion event.

For real-time debugging, use GA4’s Realtime report and DebugView. Perform the conversion action on your website and watch the DebugView to see if the event fires. Check if all expected parameters are present. If you use GTM, Preview Mode is essential. Step through the conversion process and confirm that your GTM tag fires when it should and pushes the correct data to GA4.

Step-by-Step Fixes for Conversion Tracking

1. Ensure Event is Registered and Marked as Conversion:
   • Go to “Admin > Events” in GA4. If your event isn’t listed, it’s not being sent to GA4.
   • If it is listed, go to “Admin > Conversions” and click “New Conversion Event.” Enter the exact event name (e.g., generate_lead or purchase) and click “Save.”
   • Wait a few hours for data to populate after making this change.
2. Check Event Parameters:
   • Many conversion events, like purchases, require specific parameters (e.g., value, currency). Verify that these are being sent correctly with the event.
   • If using GTM, ensure your variables are extracting the correct values from the data layer or HTML elements.
3. Review GTM Trigger & Tag Configuration:
   • In GTM, ensure your GA4 Event tag has the correct trigger. For example, a “Form Submission” trigger for a lead, or a “Custom Event” trigger for a dataLayer push after a purchase.
   • Confirm that the GA4 event name in your GTM tag exactly matches what you want to see in GA4 and what you’ve marked as a conversion.
4. Avoid Duplicate Conversions:
   • Sometimes, an event might fire multiple times due to incorrect trigger setup or page reloads. Use GTM Preview Mode to prevent this.
   • Implement checks in your GTM trigger (e.g., fire only on the first load, or after a specific condition is met).

Issue 4: E-commerce Tracking Errors (Missing Items, Incorrect Revenue)

For online businesses, accurate e-commerce tracking is non-negotiable. Problems here mean you’re losing track of sales, product performance, and overall revenue. Common errors include missing items in purchase reports, incorrect revenue figures, or even entirely absent purchase events.

These issues directly impact your ability to understand product demand, optimize pricing, and run profitable marketing campaigns. If your e-commerce data is flawed, you cannot effectively resolve GA4 data problems for your online store.

Why E-commerce Tracking is Tricky

GA4’s e-commerce tracking requires a very specific data layer structure for events like view_item, add_to_cart, and especially purchase. These events need detailed item arrays (product ID, name, price, quantity, etc.). Any deviation from this schema or failure to push this data correctly will result in tracking errors.

How to Diagnose E-commerce Issues

Start with your GA4 e-commerce reports (e.g., “Monetization > E-commerce purchases”). Look for glaring inconsistencies like zero revenue despite sales, or missing product details. Then, use DebugView and GTM Preview Mode. Perform a test purchase on your site.

Observe the purchase event in DebugView. Check if the items array is present and populated with correct product details, quantities, and prices. Ensure the value and currency parameters are also accurate. Use your browser’s developer tools to inspect the dataLayer object on your confirmation page. Confirm that the e-commerce data is pushed correctly before your GA4 tag fires.

Step-by-Step Fixes for E-commerce Tracking

1. Validate Data Layer Schema:
   • The most critical step is ensuring your website’s data layer pushes e-commerce events and their parameters in the exact format GA4 expects. Refer to Google’s official documentation for the precise schema for events like purchase, add_to_cart, etc.
   • Work with your developers to ensure the data layer structure is correct, especially for the items array.
2. Map GTM Variables Correctly:
   • In GTM, create Data Layer Variables to extract each piece of e-commerce data (e.g., ecommerce.transaction_id, ecommerce.value, and the entire ecommerce.items array).
   • In your GA4 Event tag for purchase, ensure these variables are mapped to the correct event parameters. The items array often requires a specific variable type.
3. Test All E-commerce Events:
   • Don’t just test purchases. Verify that view_item_list (product list views), view_item (product detail views), add_to_cart, and begin_checkout events are also firing correctly with their respective parameters.
   • This comprehensive testing will help you debug GA4 issues across the entire customer journey.
4. Handle Duplicates/Refunds:
   • If users refresh a thank-you page, it can trigger duplicate purchase events. Implement logic in GTM or your website to prevent this (e.g., clear the data layer after a successful push).
   • For refunds, send separate refund events to GA4 to maintain accurate revenue reporting.

Issue 5: Consent Mode & Data Loss

With increasing privacy regulations like GDPR and CCPA, managing user consent is paramount. GA4’s Consent Mode helps adjust how Google tags behave based on user consent choices. However, incorrect implementation can lead to significant data loss, leaving you with incomplete insights or heavily modeled data.

Why Consent Mode Can Cause Problems

Data loss occurs when users decline cookies, and your Consent Management Platform (CMP) or GA4 setup doesn’t correctly communicate this. Think of it like a website needing a “permission slip” to share certain information; if that slip isn’t correctly handled, data can be lost. If Consent Mode V2 is not implemented properly, or if default consent states are too restrictive, GA4 might not collect any data until consent is given, or it might struggle to model user behavior effectively.

How to Diagnose Consent Mode Issues

First, check your GA4 “Reporting Identity” in Admin settings. If you see a high percentage of “Modeled” data, it suggests a significant portion of user data is being inferred, likely due to consent issues. Observe your data volumes. If they are significantly lower than expected, or compared to previous periods, consent might be a factor.

Use DebugView and look for `consent` parameters within your events. You should see `analytics_storage` and `ad_storage` states (e.g., `granted` or `denied`). Simulate a user declining cookies via your CMP and observe how GA4 tags react in GTM Preview Mode.

Step-by-Step Fixes for Consent Mode & Data Loss

1. Implement Consent Mode V2 Correctly:
   • Ensure your website or CMP is sending the correct `gtag(‘consent’, ‘update’, { … });` commands to GA4. Specifically, verify that `analytics_storage` and `ad_storage` are being set based on user choices.
   • This is often handled by your CMP, but it’s crucial to confirm its integration with Google tags.
2. Integrate with Your CMP:
   • If you use a Consent Management Platform (like OneTrust, Cookiebot, etc.), ensure it’s properly configured to update GA4’s consent states. Most CMPs have direct integrations or GTM templates for this.
   • The CMP should fire before any GA4 tags, setting the initial consent status.
3. Check Default Consent State:
   • Set appropriate default consent states based on your region’s regulations. In many areas, you must default to `denied` for `analytics_storage` and `ad_storage` until the user grants consent.
   • This ensures legal compliance but will mean GA4 will model more data from non-consenting users.

Essential Tools for GA4 Troubleshooting

Having the right tools is half the battle when you want to fix GA4 issues. These are your go-to helpers for pinpointing problems:

• Google Tag Manager (GTM) Preview Mode: This is your sandbox. It lets you test your tags and triggers on your website before publishing them live. You can see exactly what data is pushed to the data layer and which tags fire (or don’t fire).
• GA4 DebugView: Located in your GA4 admin section, DebugView shows a real-time stream of all events and parameters as they arrive in your property. It’s invaluable for confirming that data is being sent correctly from your website.
• Google Tag Assistant Companion (Browser Extension): This Chrome extension helps you verify if Google tags are firing correctly on any webpage. It can highlight issues with your Google tag setup.
• Browser Developer Tools (Console/Network/Elements): Available in all major browsers, these tools let you inspect your website’s data layer, network requests (to see if GA4 hits are sent), and cookie information. They are crucial for deep dives into how your website communicates with GA4.
• GA4 Realtime Report: While not a deep dive tool, the Realtime report gives you an immediate overview of current activity. It’s useful for a quick check to see if any data is coming in and if basic actions are being tracked.

Proactive Measures to Prevent Future GA4 Issues

Fixing problems is good, but preventing them is even better. By implementing some proactive measures, you can maintain healthy GA4 data and avoid many common GA4 configuration issues in the first place.

• Regular Data Audits: Make it a habit to audit your GA4 configuration regularly. Schedule periodic checks of your GA4 configuration. Review your events, custom definitions, and conversions to ensure they are still relevant and accurately configured. Look for unexpected “(not set)” values or sudden drops in key metrics.
• Document Your Setup: Keep a clear, up-to-date record of your GA4 events, their required parameters, custom dimensions, and how your GTM tags are structured. This documentation is invaluable for troubleshooting and onboarding new team members.
• Set Up Custom Alerts: Use GA4’s “Custom Insights” (under “Admin > Reports > Custom Insights”) to configure alerts for sudden drops in user counts, revenue, or specific event volumes. These alerts can notify you of potential issues before they become major problems.
• Stay Updated: Google Analytics 4 is constantly evolving. Follow official Google Analytics blogs and developer resources to stay informed about new features, best practices, and important changes that might affect your setup.
• Establish a Testing Protocol: Before deploying any major website changes or new GA4 implementations, always follow a rigorous testing protocol using GTM Preview Mode and GA4 DebugView. Ensure all critical events and conversions are firing as expected.

Conclusion

Accurate and reliable GA4 data is essential for making informed business decisions in today’s digital landscape. While GA4 can seem complex, most common issues are fixable with a structured approach and the right tools.

By understanding why problems like “(not set)” values, broken cross-domain tracking, and conversion errors occur, you can systematically diagnose and rectify GA4 tracking discrepancies. Empower yourself with this guide to troubleshoot and maintain healthy GA4 data. Start applying these practical solutions today to build confidence in your analytics.