User-ID Setup in GA4: How to Validate?

The Case File

Your GA4 property is collecting data. Sessions are logging. Events are firing. But here's the critical question: are you tracking anonymous device IDs, or are you identifying actual users?

The User-ID setup in Google Analytics 4 is a feature that allows you to associate your own unique, persistent identifiers with individual users across sessions, devices, and platforms. Without it, GA4 defaults to device-based tracking using Client IDs—a browser-cookie combination that treats the same person on their laptop, phone, and tablet as three separate users.

This check measures whether your GA4 property is successfully capturing and reporting User-IDs for logged-in users. The key metrics: Users with user_id, Number of users with User-ID, and % of Total users with identifiers. If these numbers are zero or disproportionately low compared to your known logged-in user base, your cross-device tracking is broken—and your data is fundamentally fragmented.

The Root Causes (Why This Happens)

User-ID implementation failures stem from multiple technical layers. Let's investigate each.

1. No Implementation at All

The most common cause: User-ID is not a default feature in GA4. Unlike Client ID (which GA4 generates automatically), User-ID requires deliberate configuration. If your development team hasn't explicitly pushed user identifiers to the data layer and configured GTM or gtag.js to send them, GA4 will never receive them.

Many organizations mistakenly assume that because they have a login system, GA4 "knows" who users are. It doesn't. You must tell it.

2. Data Layer Timing Issues (Race Conditions)

Even when developers push a User-ID to the data layer, timing matters. If your GA4 configuration tag fires before the User-ID is available in the data layer, the tag sends the event without the identifier.

Common scenario: A user logs in, triggering a page reload. The GA4 tag fires on DOM Ready, but the User-ID is pushed to the data layer only after an asynchronous authentication check completes 200ms later. Result: the page_view event has no user_id parameter.

This is especially problematic on single-page applications (SPAs) where the data layer must be explicitly updated on login without a full page refresh.

3. GTM Variable Misconfiguration

In Google Tag Manager, the User-ID must be captured via a Data Layer Variable and then passed to the GA4 Configuration Tag. Common errors include:

• Wrong Data Layer Variable Name: The variable is looking for userId but the data layer contains user_id (case-sensitive).

• Missing Variable in Tag: The Data Layer Variable exists but was never added to the GA4 tag's Fields to Set section with the field name user_id.

• Undefined Variable Handling: GTM is set to return undefined when the User-ID isn't present, which GA4 interprets as a literal string "undefined" rather than no value.

4. PII Violations (Policy Non-Compliance)

Google's Terms of Service explicitly prohibit sending Personally Identifiable Information (PII) to GA4. This includes email addresses, names, phone numbers, or social security numbers.

If your development team is passing user@example.com or a full name as the User-ID, you're violating policy. While this won't technically "break" tracking, it exposes your organization to compliance risk and potential account suspension. The correct approach: use a hashed, anonymized, or system-generated unique identifier (e.g., user_12345 or a UUID).

5. Reporting Identity Misconfiguration

Even if User-IDs are being sent to GA4, they won't appear in reports unless your Reporting Identity is set to Blended or Observed.

GA4 offers three reporting identity modes:

• Blended: Uses User-ID first, then Google Signals, then Device ID, then modeling.

• Observed: Uses User-ID first, then Google Signals, then Device ID (no modeling).

• Device-based: Ignores User-ID entirely and relies only on Device ID.

If your property is set to Device-based, User-IDs are collected but never used in reporting. This is a silent failure—data is flowing, but it's not being leveraged.

6. Cross-Domain or Subdomain Fragmentation

If your login flow spans multiple domains (e.g., www.example.com → auth.example.com → app.example.com), the User-ID must persist across all domains. Without proper cross-domain measurement configuration, the User-ID may be lost during domain transitions, resulting in fragmented user journeys.

7. Server-Side Tagging Without User-ID Forwarding

Organizations using server-side Google Tag Manager must explicitly configure the server container to forward the user_id parameter. If the client-side container sends it but the server-side container doesn't pass it through to GA4, the data is dropped.

The "So What?" (Business Impact)

A missing or broken User-ID setup has cascading consequences across your analytics stack and business intelligence.

1. Inflated User Counts

Without User-ID, GA4 treats each device as a separate user. A single customer who visits your site on their phone, tablet, and desktop is counted as three users. This inflates your user metrics by 30-60% in multi-device environments, distorting:

• User acquisition costs (you're spending less per actual person than reports suggest)

• Conversion rates (lower than reality because the numerator is inflated)

• Audience sizes (remarketing lists contain duplicate entries)

2. Broken Attribution and ROAS Reporting

Cross-device journeys are invisible without User-ID. A user who discovers your product via a mobile ad, researches on desktop, and converts on tablet appears as three unrelated sessions with no connection.

This breaks attribution models. The mobile ad gets no credit. The desktop session looks like direct traffic. The tablet conversion is misattributed. Your Return on Ad Spend (ROAS) calculations are fundamentally wrong, leading to budget misallocation.

3. Incomplete Customer Lifetime Value (LTV) Analysis

GA4's Lifetime Value reports depend on User-ID to stitch together a user's complete journey. Without it, each device's activity is siloed. A customer who makes three purchases across three devices appears as three low-value customers instead of one high-value repeat buyer.

This undermines:

• Churn prediction models (you can't see true retention)

• Segmentation strategies (high-value users are hidden among device-level noise)

• Predictive audiences (machine learning trains on fragmented data)

4. Inaccurate Engagement Metrics

Session duration, pages per session, and engagement rate are all distorted when a single user's activity is split across multiple device-based profiles. A user who browses 10 pages on mobile and 10 on desktop appears as two users with 10 pages each, rather than one user with 20 pages—impacting content performance analysis.

5. Compliance Risk (If Using PII)

If your implementation sends PII as a User-ID, you're violating Google's Terms of Service. This can result in:

• Account suspension (Google can disable your GA4 property)

• GDPR/CCPA violations (exposing user data to third parties)

• Legal liability (regulatory fines in privacy-conscious jurisdictions)

6. Database Reconciliation Failures

Many organizations attempt to reconcile GA4 data with their CRM, data warehouse, or customer database. Without User-ID, this reconciliation is impossible. You can't join GA4 behavioral data with backend customer records, limiting your ability to:

• Calculate true customer acquisition cost

• Attribute revenue to specific marketing channels

• Build unified customer data platforms (CDPs)

The Investigation (How to Debug)

You don't need Watson to confirm this issue—but you do need to know where to look. Here's how to manually verify your User-ID implementation.

Step 1: Check Data Collection in DebugView

1. Navigate to Admin > DebugView in your GA4 property.

2. Enable debug mode on your device (in GTM, enable Preview mode; for gtag.js, add ?debug_mode=true to your URL).

3. Log in to your site as an authenticated user.

4. In DebugView, click on any event (e.g., page_view, login).

5. Scroll to the Event Parameters section and look for user_id.

What to look for:

• ✅ user_id is present with a value (e.g., user_12345)

• ❌ user_id is missing

• ❌ user_id shows as undefined or null

Step 2: Verify Data Layer in GTM Preview Mode

If using Google Tag Manager:

1. Enable Preview mode in GTM.

2. Navigate to your site and log in.

3. In the GTM Preview pane, select the event that should contain the User-ID (e.g., login, DOM Ready).

4. Click the Data Layer tab.

5. Look for your User-ID variable (e.g., userId, user_id, customer_id).

What to look for:

• ✅ The variable exists in the data layer with a value

• ❌ The variable is missing

• ❌ The variable appears after the GA4 tag has already fired (timing issue)

Step 3: Check Reporting Identity Settings

1. Go to Admin > Data display > Reporting identity.

2. Verify that either Blended or Observed is selected.

What to look for:

• ✅ Blended or Observed is selected

• ❌ Device-based is selected (User-IDs won't be used in reports)

Step 4: Inspect User Explorer Report

1. Navigate to Reports > User > User explorer (or use Explore > User explorer).

2. Look at the User ID column.

What to look for:

• ✅ User IDs are populated (e.g., user_12345, cust_67890)

• ❌ All entries show Client IDs (long strings like 1234567890.1234567890)

• ❌ The User ID column is missing entirely

Step 5: Run a BigQuery Query (Advanced)

If you have BigQuery export enabled:

sqlCopy code

SELECT

  user_id,

  user_pseudo_id,

  COUNT(DISTINCT user_pseudo_id) AS device_count

FROM

  `your_project.analytics_XXXXXX.events_*`

WHERE

  _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY))

    AND FORMAT_DATE('%Y%m%d', CURRENT_DATE())

GROUP BY

  user_id, user_pseudo_id

ORDER BY

  device_count DESC

What to look for:

• ✅ Multiple user_pseudo_id values per user_id (cross-device tracking working)

• ❌ user_id is null for all rows

Step 6: Compare Metrics

Calculate the percentage of users with User-IDs:

1. Go to Reports > Life cycle > Acquisition > User acquisition.

2. Note the total Users metric.

3. Go to Explore and create a segment for users where User ID is not null.

4. Compare the segment size to total users.

What to look for:

• ✅ The percentage aligns with your expected logged-in user rate (e.g., 40% of users log in, 40% have User-IDs)

• ❌ 0% or near-0% have User-IDs despite having a login system

The Solution (How to Fix)

Implementing User-ID requires coordination between development, analytics, and tag management. Follow these steps in order.

Step 1: Generate a Compliant User Identifier

Work with your development team to create a unique, persistent, non-PII identifier for each user. Options include:

• Database primary key: user_12345

• UUID: 550e8400-e29b-41d4-a716-446655440000

• Hashed email: sha256(user@example.com) → 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8

Requirements:

• Must be consistent across sessions and devices

• Must not contain PII (no emails, names, phone numbers)

• Should be available immediately upon authentication

• Maximum 256 characters

Step 2: Push User-ID to the Data Layer (For GTM Users)

On every page where a user is authenticated, push the User-ID to the data layer before any GA4 tags fire.

Option A: Hardcoded on Page Load

htmlCopy code

<script>

  window.dataLayer = window.dataLayer || [];

  dataLayer.push({

    'user_id': 'user_12345' // Replace with dynamic value from backend

  });

</script>

Open in CodePen

Place this code in the <head> section, before your GTM container snippet.

Option B: On Login Event

javascriptCopy code

// After successful login

dataLayer.push({

  'event': 'login',

  'user_id': 'user_12345'

});

Open in CodePen

Critical: For SPAs, push the User-ID on every route change where the user remains authenticated.

Step 3: Create a Data Layer Variable in GTM

1. In GTM, go to Variables > New.

2. Choose Variable Type > Data Layer Variable.

3. Set Data Layer Variable Name to user_id (must match your data layer key exactly).

4. Set Data Layer Version to Version 2.

5. Name the variable DLV - User ID.

6. Save.

Step 4: Configure the GA4 Configuration Tag

1. Open your GA4 Configuration Tag in GTM.

2. Scroll to Fields to Set.

3. Click Add Row.

4. Set Field Name to user_id (lowercase, underscore).

5. Set Value to {{DLV - User ID}} (your Data Layer Variable).

6. Save and submit the container.

Alternative for gtag.js (non-GTM):

javascriptCopy code

gtag('config', 'G-XXXXXXXXXX', {

  'user_id': 'user_12345'

});

Open in CodePen

Step 5: Set Reporting Identity to Blended or Observed

1. In GA4, go to Admin > Data display > Reporting identity.

2. Select Blended (recommended for most use cases).

3. Click Save.

Blended vs. Observed:

• Blended: Includes Google's modeling to fill gaps (more complete data, but includes estimates).

• Observed: Uses only observed data (more accurate, but may have gaps).

Step 6: Configure Cross-Domain Tracking (If Applicable)

If your login flow spans multiple domains:

1. In your GA4 Configuration Tag, go to Fields to Set.

2. Add a row: Field Name = linker, Value = {"domains":["example.com","auth.example.com"]}.

3. Ensure the User-ID persists across domains (use cookies or session storage).

Step 7: Test the Implementation

1. Enable GTM Preview mode.

2. Log in to your site.

3. Verify in DebugView that user_id appears in events.

4. Wait 24-48 hours for data to populate in standard reports.

5. Check the User explorer report for User-IDs.

Step 8: Persist User-ID Across Sessions (Advanced)

By default, if a user logs out or returns in a new session, the User-ID is lost. To maintain continuity:

1. Store the User-ID in a first-party cookie or localStorage upon login.

2. Read the stored value on subsequent page loads and push it to the data layer.

3. Clear the stored value only on explicit logout.

Example using localStorage:

javascriptCopy code

// On login

localStorage.setItem('user_id', 'user_12345');

// On every page load

window.dataLayer = window.dataLayer || [];

dataLayer.push({

  'user_id': localStorage.getItem('user_id') || undefined

});

Open in CodePen

Note: Simo Ahava's "#GTMtips: Once userId, Always userId" approach provides a detailed methodology for this pattern.

Step 9: Document and Monitor

• Document which identifier you're using and where it's generated.

• Set up alerts in GA4 for sudden drops in User-ID coverage.

• Schedule quarterly audits to ensure the implementation remains intact after site updates.

Case Closed

Manually diagnosing User-ID implementation issues requires checking data layers, GTM variables, GA4 configuration tags, reporting identity settings, and cross-domain setups—a process that can take 30-60 minutes per property.

The Watson Analytics Detective dashboard spots this Advice-level check instantly, alongside 60+ other data quality issues. It automatically calculates your User-ID coverage percentage, flags missing identifiers, and highlights reporting identity misconfigurations—giving you a complete audit in seconds, not hours.

Whether you're troubleshooting cross-device attribution, reconciling GA4 data with your CRM, or simply ensuring accurate user counts, Watson eliminates the guesswork.

Investigate your GA4 data quality: www.analyticsdetectives.com/watson