Duplicate events: why Meta, GA4 and Google Ads count more sales than your store made

Duplicate events are the measurement failure that gets the fewest complaints, because the number goes up. The store closes the day with a total of orders, and Meta's Events Manager, GA4 or Google Ads show more purchases than that. Nobody opens a ticket for too many sales. But the campaign is optimiz

Wascer teamServer-side tracking15 min read
Eventos duplicados: admin da loja com 100 pedidos e Gerenciador de Eventos da Meta com 180 compras, em um exemplo
Duplicate events: store admin with 100 orders and Meta Events Manager with 180 purchases, in an example

Duplicate events are the measurement failure that gets the fewest complaints, because the number goes up. The store closes the day with a total of orders, and Meta's Events Manager, GA4 or Google Ads show more purchases than that. Nobody opens a ticket for too many sales. But the campaign is optimizing on purchases that never happened, and the ROAS that goes into the meeting is inflated.

Picture, as an example, a store that recorded 100 paid orders in a day. In Events Manager, the same day shows 180 purchase events. In GA4, 130. None of these numbers is a real case: it is the shape the problem usually takes, with each platform overcounting by a different proportion, because each one deduplicates in its own way.

This article explains how deduplication works on each platform, according to the official documentation; the four most common causes of a purchase counted twice; how to test your setup; and how to build the sending so that the same sale arrives only once.

Duplication is not an attribution difference

Before looking for duplicate events, separate two readings that are often mixed up.

Attribution is how a platform credits a sale to an ad. It uses click and view windows, and the same sale can show up in Meta's report and in Google Ads', each one crediting itself. That makes the sum of channels exceed revenue, but those are not duplicate events. Google Ads' own help notes that the transaction ID does not resolve view-through conversions.

Duplication is the same order arriving twice as a purchase event on the same platform. It is an implementation defect, and it is what this article fixes.

That is why the diagnosis starts with the raw event, not with the campaign report: paid orders in the admin against purchase events received in Events Manager and against purchases in GA4, on the same day. If the number of events exceeds the number of orders, copies are getting in.

How each platform deduplicates duplicate events

Each platform has its own deduplication key. Understanding the key means understanding the cause.

Meta: event_id and event_name, only between browser and server

Meta recommends sending the same purchase through two paths: the Pixel, in the browser, and the Conversions API, on the server. To avoid counting it twice, it compares the ID and the name of the events. According to the documentation, the Pixel's eventID must match the Conversions API's event_id, and the Pixel's event must match the server's event_name. When both match, Meta generally keeps the event that arrived first.

There are two conditions almost nobody reads:

  1. 48-hour window. Events are only deduplicated if they arrive within 48 hours of the first one.
  2. Only across different sources. The documentation says deduplication does not happen when only one source is used, browser only or server only. And it goes further: if you send two browser events in a row with the same information, Meta discards neither. The same applies to two server events.

The event_id can be any unique string chosen by the advertiser. The order number is the natural choice, because it exists both in the browser and on the server.

GA4: transaction_id

Google Analytics deduplicates purchase events with the same transaction ID. GA4's help adds three caveats that matter: the same transaction ID should not be used for different users; deduplication by transaction ID applies to data collected by web streams, not app streams; and the transaction ID should never be empty, because GA4 deduplicates all purchases with transaction_id="" against each other. In that last case, the error flips: you start losing sales.

Google Ads also uses the transaction ID. Its help describes the exact scenario: if the customer returns to the conversion page or reloads it, the same tag can fire again. When two conversions of the same action arrive with the same transaction ID, the duplicate is not counted. The ID must be unique per transaction; using the same ID for different orders makes Google Ads undercount.

The action's counting setting also matters. With "Every", Google Ads counts every conversion after an ad interaction, and the help describes this option as a good choice for sales. Without a transaction ID, every tag fire becomes a conversion.

Platform

Deduplication key

What the key does not cover

Meta (Pixel + Conversions API)

event_id equal to eventID and the same event name, within 48 hours

Two browser events or two server events: neither is discarded

GA4

Same transaction_id

App streams; an empty transaction_id deduplicates all purchases against each other

Google Ads

Same transaction ID in the same conversion action

View-through conversions; IDs repeated across different orders

Duplicate events: how Meta deduplicates the Pixel and the Conversions API by event_id

The four most common causes of duplicate events

With the keys in hand, the causes reveal themselves. Almost every case of duplicate events falls into one of these four.

1. Pixel and Conversions API without the same event_id

The store turns on the Conversions API, through a platform app, an integration or a server-side container, and does not make sure the server sends the same identifier as the Pixel. Sometimes the Pixel goes out without an eventID; sometimes each side generates a random code; sometimes the name does not match (Purchase on one side, a custom event on the other). For Meta, these are two different purchases.

This is the most misleading cause, because the installation "is right": both paths work, both show up in Events Manager, and using both is exactly what Meta recommends. Only the key is missing.

2. Pixel installed twice

The store installs the Pixel through the e-commerce platform's official app. Months later, an agency adds the same Pixel to the theme or to a Google Tag Manager tag. Or the store switches apps and the old one is never removed. Result: every purchase generates two browser events.

Here Meta's deduplication does not help even with the same eventID, because it does not discard repeated events from the same source. The same goes for the server: the platform's native integration sending the purchase through the Conversions API and a server-side container sending the same purchase again are two server events, and both count.

3. The purchase tag fires again on the thank you page

The customer reloads the thank you page, goes back to it through the browser history or opens the order link again. If the purchase tag is tied to that page loading, it fires again.

In GA4 and Google Ads, the same transaction ID holds back the repeat. In Meta, the reload generates a second browser event, which is not discarded. That is why, beyond the identifier, the purchase tag must fire once per order, not once per page load.

4. GA4 receiving the purchase from the browser and the server with different IDs

With server-side tracking, it is common for the purchase to reach GA4 through the browser tag and also through a server send, such as the Measurement Protocol or a container tag. If both carry the same transaction_id, GA4 deduplicates. If one of them uses another identifier, or none at all, that is two purchases in revenue.

Want to know whether your store has duplicate events today? Enter your site URL and see if your conversions are duplicated.

Why duplicate events are expensive

A high number looks harmless. It is not, and the cost shows up in three places.

Optimization. Conversion campaigns learn from the purchase events they receive. If part of the events are copies, the algorithm gets a positive signal twice for the same buyer and starts to value the profile and the ad that produced that copy more. When duplicate events depend on behavior (who reloads the thank you page, who goes through a theme with the duplicated Pixel), learning skews toward that behavior, not toward who buys the most.

ROAS and cost per acquisition. The ROAS in the ads manager is recorded revenue divided by spend. In a hypothetical example: BRL 10,000 spent and BRL 40,000 sold give a ROAS of 4. If half of the purchases arrive as duplicate events, the platform records BRL 60,000 and shows a ROAS of 6. Cost per acquisition drops in the same proportion. A break-even campaign looks profitable, and the decision to scale is made on revenue that never reached the bank account.

Channel reading. In GA4, revenue from duplicate events inflates the channel that received the copy. Analytics revenue stops matching store revenue, and the conversation about which channel works starts with the wrong number.

The fix: one send per path and the same identifier everywhere

The rule that fixes duplicate events on all three platforms is the same: the order number is the identity of the purchase. It goes as eventID in the Pixel, as event_id in the Conversions API, as transaction_id in GA4 and as the transaction ID in Google Ads. And each path exists once: one Pixel in the browser, one send from the server.

Meta: the same ID in the Pixel and on the server

In the browser, the identifier goes in the fourth argument of fbq, the same format as the example in Meta's documentation:

javascript
// Thank you page: fires once per order, with the order number as eventID
fbq('track', 'Purchase',
  { value: 189.90, currency: 'BRL' },
  { eventID: '5550001112223' }
);

On the server, the Conversions API receives the same value in event_id and the same name in event_name (example values):

json
POST https://graph.facebook.com/{version}/{PIXEL_ID}/events

{
  "data": [
    {
      "event_name": "Purchase",
      "event_time": 1760990400,
      "event_id": "5550001112223",
      "action_source": "website",
      "event_source_url": "https://yourstore.com/thank-you",
      "user_data": {
        "em": ["<SHA-256 of the normalized email>"],
        "client_ip_address": "203.0.113.10",
        "client_user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) ...",
        "fbp": "fb.1.1760990000000.1234567890"
      },
      "custom_data": {
        "currency": "BRL",
        "value": 189.90,
        "order_id": "5550001112223"
      }
    }
  ]
}

Purchase on both sides, 5550001112223 on both sides. If the customer came back to the thank you page and the Pixel fired, Meta discards the event that arrived later. If the Pixel did not fire, the server event is the recorded purchase. event_time accepts up to 7 days of delay; deduplication, up to 48 hours between the two events.

GA4 and Google Ads: the same transaction_id in every send

In the browser, the GA4 purchase carries the order number in transaction_id, as in the example in Google's help:

javascript
gtag('event', 'purchase', {
  transaction_id: '5550001112223',
  value: 189.90,
  currency: 'BRL',
  items: [
    { item_id: 'SKU-123', item_name: 'Product', price: 189.90, quantity: 1 }
  ]
});

If the server also sends the purchase through the Measurement Protocol, the transaction_id is the same (example values):

json
POST https://www.google-analytics.com/mp/collect?measurement_id=G-XXXXXXXXXX&api_secret={SECRET}

{
  "client_id": "1234567890.1760990000",
  "events": [
    {
      "name": "purchase",
      "params": {
        "session_id": "1760990000",
        "transaction_id": "5550001112223",
        "value": 189.90,
        "currency": "BRL",
        "items": [
          { "item_id": "SKU-123", "item_name": "Product", "price": 189.90, "quantity": 1 }
        ]
      }
    }
  ]
}

In Google Ads, the purchase conversion receives the same number as the transaction ID, whether through the Google tag in the browser or through the container's conversion tag. According to Google Ads' help, in Google Tag Manager the most reliable way to pass the transaction ID is through the site's data layer: the site pushes the order number to the data layer, and GTM reads that value and sends it to Google Ads.

One purchase tag per order, not per page load

The identifier fixes GA4 and Google Ads, but not the reload in Meta. That is why the purchase tag in the browser must fire once per order. Two common approaches: the purchase event is pushed to the data layer only when the order is confirmed, not on every visit to the page; or the purchase is sent only from the server, based on the order confirmation, and the browser handles the events before checkout. In either one, the rule is the same: one send per path.

How to test whether the fix worked

Do not trust the dashboard before reproducing the scenario that duplicates. The test takes a few minutes.

Checklist to test duplicate events in Meta, GA4 and Google Ads
  1. Events Manager, deduplication tab. In the Pixel overview, open the Purchase event details and the event deduplication tab. It shows the percentage of deduplicated events by source, and Meta displays a warning when that rate is low.
  2. Test events. Generate the code in the Test events tool and send the test_event_code in the server event during the test. Place a test order and check that the browser event and the server event arrive with the same event_id. Remove the test_event_code afterwards: Meta warns that events with it are not dropped and flow into Events Manager.
  3. GA4 DebugView. With Google Tag Manager's Preview mode or Tag Assistant on, DebugView shows events in real time. The purchase has to show up with the order number in transaction_id, never empty.
  4. Reload the thank you page. In GTM Preview mode, check whether any purchase tag fires again. In the browser's Network tab, check whether a second Pixel Purchase request shows up.
  5. Look for the second installation. In the thank you page's source code, search for the Pixel ID and the GA4 measurement ID. More than one load of the same ID is a sign of a double installation. Also check the store's list of apps and integrations.

How to tell if your store has duplicate events

You do not need a tool for the first reading. Pick a day with volume and compare:

  1. Store admin: paid orders that day.
  2. Meta Events Manager: Purchase events received on the same day.
  3. GA4: purchases (purchase) on the same day, in the monetization report.
  4. Google Ads: conversions of the purchase action by conversion date.

If a platform's number of events exceeds the number of paid orders, there are duplicate events on that platform. If only Meta is above, look first at the event_id and at a double Pixel installation. If GA4 is above, look at the transaction_id. If GA4 is far below, check that the transaction_id is not being sent empty.

How Wascer fixes duplicate events

Wascer launches and monitors a server-side Google Tag Manager container in one click: no DevOps, no Docker and no command line. You paste the container ID and get an active, monitored and scalable tagging server.

In the container, Wascer provides dedicated Meta, GA4 and Google Ads tags, and the purchase leaves from a single place, with the order number as the identifier: event_id in the Conversions API, transaction_id in GA4 and the transaction ID in Google Ads. Instead of the app's Pixel, the theme's Pixel and the native integration competing for the same sale, there is one send in the browser and one on the server, with the same key. For Shopify stores, the Sourei Wascer app sends the order data to the container.

Learn what Wascer is and how it works or visit wascer.com.

Frequently asked questions

Does using the Pixel and the Conversions API together duplicate purchases?

No, as long as both events have the same name and the same identifier. Meta compares the Pixel's eventID with the server's event_id and discards the copy, provided both arrive within 48 hours of the first one.

Why does Meta count more purchases if event_id is set up?

Because Meta's deduplication only works between browser and server. Two browser events in a row, such as those from a Pixel installed twice or from a thank you page reload, are not discarded. The same applies to two server events.

Does GA4 deduplicate purchases on its own?

It does when the purchases carry the same transaction_id, in web streams. Without a transaction_id, or with different identifiers in the browser and on the server, every send becomes a purchase. And an empty transaction_id does the opposite: all empty purchases are deduplicated against each other.

Does switching Google Ads counting to “One” fix duplication?

It is not the way to go for sales. "One" counts only one conversion per ad click, which is meant for leads, and it would hide real purchases from customers who come back and buy again. For purchases, the fix is to send a unique transaction ID per order.

Is it always duplication when the sum of the platforms exceeds revenue?

No. Each platform attributes the sale to itself according to its own click and view windows. Duplication is confirmed in the raw event: more purchase events on a platform than paid orders in the store.

Conclusion

Duplicate events do not show up as an error. They show up as a good result: more purchases, higher ROAS, lower cost per acquisition. That is why they last for months. But every copy teaches the algorithm to invest in a signal that does not exist and brings to the meeting revenue that never reached the bank account.

The fix does not depend on campaign fine-tuning. It depends on an architecture rule: the order number as the identity of the purchase on every platform, one send per path and a purchase tag that fires once per order.

Want to know whether your platforms are counting the same sale twice? Enter your site URL and see if your conversions are duplicated.

Wascer: rastreamento server-side

By Wascer

Wascer launches and monitors your server-side Google Tag Manager container in one click: no DevOps, no Docker and no command line. Technical content on tracking, Meta, GA4 and Google Ads for teams that decide with data. wascer.com

Sources

Wascer team · Published on Oct 22, 2026 · updated on Nov 6, 2026

Read next

All articles
NOV 11Google Data Manager API: O Futuro do Envio de Dados para o Google AdsOCT 30Meta Ads and GA4 don’t match: when the gap is normal and when it’s lost dataOCT 26Wrong Google Ads conversion value: why it happens and how to fix it