AD2MartechGet in touch
Programmatic

Fix Undefined User Data in Google Ads Enhanced Conversions

September 15, 2026

The Root Cause of Undefined User Data in Tag Manager

When Google Ads displays a diagnostic alert stating "Needs Attention" or reports low match rates for Enhanced Conversions, the underlying cause is almost always an undefined, null, or empty value passed into the user data payload at the exact millisecond the conversion tag executes. Google Tag Manager (GTM) evaluates variables instantly upon trigger fire. If your conversion tag fires before the DOM populates, before the user submits the form, or before a dynamic front-end framework updates its global state, GTM captures empty variables and forwards broken payloads to Google's conversion endpoints.

Relying on direct DOM scraping through GTM built-in CSS Selectors is the primary driver of this failure mode. Modern web applications built on React, Vue, Svelte, or Angular frequently use dynamic CSS class names (such as Tailwind or CSS Modules) that shift during build deployments. Furthermore, single-page applications (SPAs) re-render components asynchronously, causing custom JS or element variables to evaluate as undefined when the conversion trigger fires. Resolving this issue requires shifting from fragile front-end scraping to a structured, event-driven architecture.

Diagnostic Audit: Pinpointing Where the Payload Fails

Before modifying tags or writing new scripts, isolate the exact point of failure using a structured diagnostic process across GTM Preview Mode, browser developer tools, and the Google Ads interface.

Step 1: Inspecting GTM Preview Mode Execution Order

Open GTM Preview Mode and complete a test conversion. In the left-hand Summary sidebar, click on the specific event that triggers your Google Ads Conversion Tag (for example, form_submit or purchase).

  • Navigate to the Tags tab, click your Google Ads Conversion Tag, and locate the Include user-provided data from your website field.
  • Click into the underlying User-Provided Data Variable.
  • Examine the evaluated values for email, phone_number, and address keys. If any return undefined or "", inspect the execution order. If the variable evaluates correctly on a later event (like Container Loaded) but returns undefined on the conversion event trigger, you have a tag timing race condition.

Step 2: Inspecting the Network Payload in Chrome DevTools

To verify what GTM actually transmits to Google's servers, inspect the outgoing network request rather than relying strictly on the GTM preview interface.

  1. Open Chrome DevTools and navigate to the Network tab.
  2. Filter by /pagead/1p-user-list/ or googleadservices.com/pagead/conversion/.
  3. Trigger the conversion action on your site.
  4. Select the matching network request and open the Payload or URL Parameters tab.
  5. Look for the em parameter (which represents the SHA-256 hashed email string). If the em parameter is missing entirely, or if it returns an empty string or a hash of an empty space, Google Ads is receiving unpopulated user data.

Refactoring to an Event-Driven Data Layer Schema

The most resilient method to prevent undefined user data is to mandate that your application backend or front-end form handler executes a explicit dataLayer.push() immediately before or concurrently with the conversion event. This eliminates DOM scraping entirely.

Defining the Optimal Data Layer Structure

Instruct your engineering team to push normalized customer values into the Data Layer upon successful form validation or transaction completion. Raw data can be sent as plain text if GTM's native User-Provided Data Variable handles the hashing, but passing clean, pre-trimmed strings prevents silent validation failures.

window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
  'event': 'enhanced_conversion_data',
  'user_data': {
    'email': 'alex.merchant@example.com',
    'phone_number': '+14155552671',
    'address': {
      'first_name': 'Alex',
      'last_name': 'Merchant',
      'street': '100 Montgomery St',
      'city': 'San Francisco',
      'region': 'CA',
      'postal_code': '94104',
      'country': 'US'
    }
  }
});

When passing raw user data to GTM, strictly observe standard normalization parameters:

  • Email: Remove leading and trailing whitespace; convert all characters to lowercase prior to hashing.
  • Phone Number: Format using the E.164 standard (e.g., +14155552671). Remove hyphens, parentheses, and spaces.
  • Postal Code: Strip spaces and dashes; ensure country codes follow ISO 3166-1 alpha-2 format.

Configuring the GTM User-Provided Data Variable

Once the Data Layer push is implemented, map these parameters inside Google Tag Manager.

Manual Configuration Setup

  1. In GTM, navigate to Variables > User-Defined Variables > New.
  2. Select User-Provided Data as the Variable Type.
  3. Set the mode to Manual Configuration.
  4. For each field (Email, Phone, Address), create a corresponding Data Layer Variable pointing directly to the object path in your payload:
    • Email Data Layer Variable Name: user_data.email
    • Phone Data Layer Variable Name: user_data.phone_number
    • First Name Data Layer Variable Name: user_data.address.first_name
  5. Save the Variable (e.g., name it UPD - Event User Data).
  6. Attach this variable to your Google Ads Conversion Tag under User-Provided Data.

Trigger Alignment to Prevent Race Conditions

Do not trigger your Google Ads Conversion Tag on generic DOM triggers like All Pages or standard Element Visibility triggers if the user data is pushed asynchronously. Change the trigger condition to listen specifically for the custom event defined in your Data Layer payload:

  • Trigger Type: Custom Event
  • Event Name: enhanced_conversion_data

This guarantees that the Google Ads tag fires only when the user_data object is guaranteed to be fully populated in memory, eliminating undefined variable reads.

Handling Legacy Forms and Third-Party iFrames

In scenarios where you lack developer resources to alter site code—or when handling third-party platforms like HubSpot, Marketo, or Typeform embedded via iFrames—you must implement defensive front-end JavaScript logic to capture and normalize values reliably.

Extracting Data from Single-Page Application Forms

If you must rely on DOM extraction, avoid standard CSS Selectors directly in GTM variables. Instead, build a Custom JavaScript Variable that defensively checks for the existence of the input node, validates that the field contains an actual value, and normalizes the output prior to tag execution.

function() {
  try {
    var emailInput = document.querySelector('input[type="email"], input[name*="email"]');
    if (emailInput && emailInput.value) {
      var rawEmail = emailInput.value;
      // Clean and normalize
      var cleanEmail = rawEmail.trim().toLowerCase();
      // Validate basic email pattern before returning
      var emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      return emailRegex.test(cleanEmail) ? cleanEmail : undefined;
    }
  } catch (e) {
    return undefined;
  }
  return undefined;
}

Overcoming Cross-Origin iFrame Boundaries

If your form lives inside an embedded iFrame hosted on a third-party domain (e.g., hsforms.net or marketo.com), GTM running on the parent window cannot inspect input fields inside the iFrame due to browser same-origin policies. Attempting to target input selectors inside the iFrame from the parent GTM container will consistently return undefined.

To resolve this without breaking security boundaries, implement postMessage listeners:

  1. Configure the third-party form inside the iFrame to issue a native JavaScript window.parent.postMessage() payload upon submission containing the converted user data.
  2. In the parent window GTM container, deploy a Custom HTML listener tag that processes incoming message events:
<script>
window.addEventListener('message', function(event) {
  // Validate origin if necessary
  if (event.data && event.data.type === 'hsFormCallback' && event.data.eventName === 'onFormSubmitted') {
    var submissionData = event.data.data;
    // Extract email from payload depending on vendor structure
    var userEmail = submissionData.submissionValues ? submissionData.submissionValues.email : null;
    
    if (userEmail) {
      window.dataLayer = window.dataLayer || [];
      window.dataLayer.push({
        'event': 'iframe_form_submission',
        'user_data': {
          'email': userEmail
        }
      });
    }
  }
});
</script>

Monitoring and Validating Data Quality

After deploying dataLayer updates or custom JavaScript fallbacks, monitor performance across three primary thresholds to ensure long-term stability.

Google Ads Diagnostics Dashboard

Navigate to Tools and Settings > Conversions in Google Ads. Select your primary conversion action and click the Diagnostics tab. Review the following metrics over a 48-hour period:

  • Status: Should transition from "Needs Attention" to "Recording".
  • Match Rate Performance: High-performing implementations generally achieve match rates between 60% and 80%+ depending on your traffic source mix and geography (considering privacy legislation such as GDPR).
  • Data Coverage: Check the percentage of conversion events that contain valid user-provided data. Drops below 50% usually indicate that modern web browsers or ad-blockers are interrupting the trigger sequence on mobile devices or that specific form variants on your site lack dataLayer pushes.

By enforcing an event-driven data layer architecture, removing dynamic CSS selector dependencies, and tightly synchronizing tag triggers with payload availability, you permanently resolve undefined user data errors and restore full attribution integrity to your Google Ads infrastructure.