Google Wants You to Use the new_customer Parameter. Here’s What That Means

The Old Way: Customer Match Lists

For years, the standard approach to tracking new vs. returning customers in Google Ads has been (and still is) Customer Match lists.

You export your customer email list from your database, upload it to Google Ads, and Google will match those emails to users.

Anyone not on the list = new customer. Anyone on the list = existing customer.

Simple enough.

The Problems With Customer Match

First, match rates can sometimes be terrible.

Most advertisers see 29% to 62% match rates. That means Google can only identify about half your existing customers, at best. (To be fair, I do come across accounts that have great match rates, I’m not saying the match rate is never good.)

Second, there’s a delay.

You upload the list, Google processes it, and by the time it’s live your data is already stale. Someone who purchased yesterday might not be on the list yet.

Third, privacy. Cookies are dying, users are blocking tracking, and email matching gets harder every year.

So Google needed a better solution.

The New(ish) Way: New_Customer Parameter

Instead of relying solely on uploaded email lists, Google wants you to tell them directly at the moment of conversion whether this customer is new or returning.

It’s a simple parameter you add to your conversion tracking:

new_customer: true  // first-time buyer
new_customer: false // returning customer

You’re using your own first-party data (your database, your order history) to determine if this person has purchased before. Then you pass that information to Google at conversion time.

It’s real-time. No upload delays. No processing time. The moment someone converts, Google knows their status.

It’s accurate. YOU know your customers better than Google does. If your database says they’ve purchased before, they’ve purchased before. No guessing based on email matching.

It can feed Google’s AI.

This “ground truth” data helps train Google’s customer detection model, which makes the whole system smarter over time.

Use Both Methods

Google recommends using the new_customer parameter AND Customer Match lists together.

Why?

Customer Match still has value. It provides historical context and helps with audience targeting beyond just conversion tracking. The parameter gives real-time conversion data.

Together, they create the most accurate system.

The parameter is the priority, though.

If you can only do one, do the parameter. It’s more accurate and more useful for conversion optimization.

“Unknown” customers in Google Ads

If you’ve been using Google’s New Customer Acquisition (NCA) mode in Google Ad campaigns, you’ve undoubtedly seen the dreaded “Unknown” when attempting to segment your conversions by New vs Returning.

The new_customer parameter should help bring “Unknowns” way down.

Update to Google Ads “Unknown” Customers

Just today I’m starting to see a notification in Google Ads that calls out this exact situation.

Here is what Google is stating inside this notification:

“We’re making new customer acquisition reporting clearer in Performance Max, Search, and Shopping campaigns. Previously, when segmenting your lifecycle goals reporting
 by new vs. returning customers, you may have seen conversions labeled as “Unknown”. Now, you won’t see these “Unknown” conversions in reporting because we’ve improved our ability to estimate whether an “Unknown” customer is a new or existing customer.“

I don’t really love this honestly.

It just seems like a “Trust Me Bro” situation.

I’d love to get more details on what was improved but I’m not sure we will get that.

If anything, the references of “Unknown” could be how Google pushes more advertisers to use the new_customer parameter.

So What’s Next?

If you’re on Shopify and using the official Google & YouTube app, you already have this set up.

If you’re on a custom site or using Google Tag Manager, you’ll need to implement it manually. That means:

• Adding the parameter to your conversion tracking
• Determining new vs. returning customer status server-side
• Passing that value to the dataLayer
• Configuring your Google Ads tags to use it

Example Implementations via GTM

Shopify (Manually)

If you’re NOT using the official Youtube & Google app, you’ll need to create a Custom Web Pixel. This is the NEW way to add tracking code to Shopify since the old “Additional Scripts” method is being completely removed.

Create a Custom Web Pixel

1. Go to Settings → Customer Events
2. Click Add custom pixel
3. Name it something like “Google Ads New Customer Tracking”
4. Paste this code:

analytics.subscribe('checkout_completed', (event) => {
  // Shopify provides isFirstOrder directly in the event data
  const isNewCustomer = event.data.checkout.order?.customer?.isFirstOrder;
  
  window.dataLayer = window.dataLayer || [];
  window.dataLayer.push({
    'event': 'purchase',
    'new_customer': isNewCustomer,
    'transaction_id': event.data.checkout.order?.id,
    'value': event.data.checkout.totalPrice.amount,
    'currency': event.data.checkout.currencyCode
  });
});

5. Click Save

Shopify’s Checkout Extensibility provides a checkout_completed event that fires when an order is completed. The event data includes customer.isFirstOrder—a boolean that Shopify calculates for you.

If isFirstOrder is true, they’re a new customer. If false, they’re returning.

You don’t have to query the database or count orders yourself. Shopify does it automatically.

WooCommerce

WooCommerce requires a bit of PHP knowledge, but it’s straightforward if you’re comfortable editing your theme’s functions.php file (or using a plugin like Code Snippets).

WordPress’s woocommerce_thankyou hook fires on the order confirmation page. The wc_get_customer_order_count() function checks their total orders. If it’s 1, they’re new.

add_action('woocommerce_thankyou', 'ua_add_new_customer_datalayer');

function ua_add_new_customer_datalayer($order_id) {
    // Get the order object
    $order = wc_get_order($order_id);
    
    // Get customer ID
    $customer_id = $order->get_customer_id();
    
    // If no customer ID (guest checkout), assume new customer
    if (!$customer_id) {
        $is_new = 'true';
    } else {
        // Get their total order count
        $order_count = wc_get_customer_order_count($customer_id);
        $is_new = ($order_count == 1) ? 'true' : 'false';
    }
    
    // Output the dataLayer code
    ?>
    <script>
    window.dataLayer = window.dataLayer || [];
    dataLayer.push({
        'event': 'purchase',
        'new_customer': <?php echo $is_new; ?>,
        'transaction_id': '<?php echo $order->get_order_number(); ?>',
        'value': <?php echo $order->get_total(); ?>,
        'currency': '<?php echo $order->get_currency(); ?>'
    });
    </script>
    <?php
}

BigCommerce

This is where it gets trickier. BigCommerce doesn’t make customer order count easily accessible on the order confirmation page like Shopify and WooCommerce do.

BigCommerce’s Stencil templates (the order confirmation page) don’t have a built-in variable for customer order count. You CAN get it in transactional emails ({{data.customer.orders_count}}), but not directly on the page template.

Option 1: Use a DataLayer App

Apps like Stape’s BigCommerce DataLayer app or Fueled’s BigCommerce Data Layer can handle this automatically. They integrate with your store and push properly formatted data (including new customer status) to the dataLayer.

Option 2: Custom Script via Script Manager

If you’re comfortable with JavaScript, you can add a script via BigCommerce’s Script Manager that:

1. Fetches the customer data from the Storefront API
2. Determines if they’re a new customer based on order count
3. Pushes that to the dataLayer

Here’s the basic structure (you’ll need to adapt this):

<script>
// Fetch customer order count via Storefront API
fetch('/customer/orders.php?action=account_orderstatus')
  .then(response => response.json())
  .then(data => {
    let orderCount = data.orders ? data.orders.length : 0;
    let isNew = (orderCount <= 1);
    
    window.dataLayer = window.dataLayer || [];
    dataLayer.push({
      'event': 'purchase',
      'new_customer': isNew,
      'transaction_id': '{{checkout.order.id}}',
      'value': {{checkout.order.total}},
      'currency': '{{checkout.currency.code}}'
    });
  });
</script>

After You Add the Code: GTM Configuration

Once you have the dataLayer code on your confirmation page, you need to configure Google Tag Manager to use it.

Step 1: Create a Data Layer Variable in GTM

1. Go to Variables → New
2. Variable Type: Data Layer Variable
3. Data Layer Variable Name: new_customer
4. Name it something like: DLV - new_customer
5. Save

Step 2: Update Your Google Ads Conversion Tag

1. Open your existing Google Ads conversion tag (or create one if you don’t have it)
2. Scroll down to “New customer data”
3. Check the box: “Provide new customer data”
4. Data source: Data Layer
5. In the field that appears, select your variable: {{DLV - new_customer}}
6. Save

Step 3: Test It

This is important. Don’t assume it works.

1. Make a test purchase on your site
2. Check the dataLayer on the thank you page (open browser console, type dataLayer and hit enter)
3. Look for your purchase event. Does it have new_customer: true or false?
4. In GTM Preview mode, check if your conversion tag fires with the new_customer parameter
5. In Google Ads, check if the conversion appears with customer type data (this takes 24-48 hours to show up)

If the dataLayer looks right but GTM isn’t picking it up, double-check your variable name matches exactly.

Still Not Bulletproof

Existing customers will still convert on new customer campaigns.

They just will.

There’s no 100% perfect way to prevent it.

Maybe they used a new device. Maybe their cookies were cleared. Maybe they’re blocking trackers.

The parameter helps reduce this but it won’t fully eliminate it.