Skip to main content
FHAVI

Research · Tracking

Browser pixel vs server-side tracking: how deduplication actually works

Deduplication is not a feature you switch on. It is a join on two fields — event name and event id — inside a 48-hour window, and when the join fails nothing errors. You simply get two purchases where there was one.

8 min read

In brief

  • Meta keeps one purchase only when three things match: the same pixel ID, the same event name, and the same event id. The id alone is not the key.
  • The window is 48 hours and the first copy to arrive is the one that survives. That means deduplication never corrects a wrong value — it only collapses a duplicate.
  • Deduplication is checkable on a single real order, in about ten minutes, without access to anyone's ad account. Most stores have never done it.

The one thing to remember

Browser pixel and server-side events are two different paths for the same purchase. Meta holds a rule for collapsing them into one: the same pixel ID, the same event name, and the same event id, received within 48 hours. The first copy to arrive is kept and the later copy is discarded.

That is the whole mechanism. Everything below is about the ways it fails in practice — and none of those failures raise an error anywhere you can see.

Why this matters commercially

If the join fails, you do not see a warning. You see a purchase count that is higher than your order table, a cost per purchase that is lower than reality, and a bidding algorithm that has been trained on both copies. A store can run for months this way and only discover it when revenue and reported conversions stop agreeing.

Why both paths exist, briefly

The browser pixel runs in the customer's page. It sees the session: the click that arrived with an fbclid parameter, the cookies written on landing, the pages viewed before the product was added. It is the only path that sees the customer as a person moving through the store.

It is also the path you do not control. A closed tab, a content blocker, an in-app browser that restricts storage, or simply a slow connection can stop the request before it leaves the device. The events that survive are biased toward fast devices and forgiving browsers.

A server event runs in your application, from the order record. It sees what the browser cannot: that the order actually exists, its true value after discounts and shipping, and a transaction id that will not be regenerated. It does not see the click unless your landing page stored the click identifiers.

So the two paths are complementary by construction: the browser has the click, the server has the order. Sending both is the recommended setup. Sending both without a shared id is worse than sending either alone.

The join, precisely

The two sides do not use the same field name, and on the wire neither of them looks like the documentation. This is where most manual audits go wrong: an engineer compares the browser request to the server body, decides the names do not match, and "fixes" a setup that was already correct.

Where the value livesBrowser pixelServer event
Event nameevent on the /tr request: ev=Purchaseevent_name: "Purchase"
Event ideventID — the fourth argument to fbq('track', …)event_id
Valuecd[value], cd[currency] on the requestcustom_data.value, custom_data.currency
Timestampsent by the pixel automaticallyevent_time — within roughly 7 days of now
Click identifiers_fbp and _fbc cookies, read from the browseruser_data.fbp, user_data.fbc — passed in, or absent
  • The name must match exactly, including case. Purchase from the browser and purchase from the server are two events, not one.
  • The id must be identical strings. A UUID generated once per order is fine; a new UUID per retry is not.
  • The pixel ID completes the key — two different pixels sending the same event id are unrelated events.

The 48-hour window is a join window, not a retry budget

Meta collapses the duplicate only if the second copy arrives within 48 hours of the first. Inside that window, later copies are discarded. Outside it, the same event counts again.

That turns an ordinary engineering habit into a reporting bug. A nightly job that rebuilds yesterday's purchases is fine if it reuses the original id. The same job that mints a fresh id per attempt adds a second Purchase every time it runs, and nothing in either system complains.

The same applies to the server event's own timestamp: an event_time older than about seven days is rejected, and a rejected event takes the rest of its batch with it. A millisecond timestamp — thirteen digits — read as seconds lands tens of thousands of years in the future and fails the same way.

The rule that follows

Mint the id once, when the order exists, and pass that same value to both paths. Treat a retry as the same event, not a new one. If you cannot reuse the id, do not resend.

One order, three ways it goes wrong

A customer buys one item for £84.50. Store A has a browser pixel and no server event. Store B sends both. Store C sends both, correctly. Nothing about the storefront differs; the reporting does.

SetupWhat arrivesWhat Meta keepsWhat the owner sees
A — browser onlyOne Purchase, £84.50One purchaseUnder-counted on the sessions where the browser failed, but no duplicate
B — both, no shared idPurchase (browser) and Purchase (server), different idsTwo purchases, £169.00Reported purchases higher than orders; cost per purchase lower than it really is
C — both, shared idPurchase, £84.50, id order-1842, twiceOne purchase, £84.50, first arrival keptReported purchases equal orders

Two variations matter more than the table suggests. If the event names differ by case — Purchase and purchase — the result is the same as B: two purchases. And if the ids match but the values do not — the browser sends 84.50 and the server sends 8450 because the server works in minor units — deduplication still keeps only one, chosen by arrival order. Meta does not average the two, and does not prefer the larger or the more correct one.

Six traps that survive a working install

  • Deduplication does not reconcile values. Whichever copy lands first wins, so a units bug becomes a permanent reporting error rather than a duplicate you would notice.
  • A noscript image is a second request, not a replay. If the script and the image both fire and only one carries the id, you have a duplicate that no console test will show.
  • Two base codes, one in the theme and one in a tag manager, are two PageViews before any purchase code runs. Adding a server event does not collapse that.
  • Reusing a purchase id for a refund makes the refund look like the duplicate Meta was told to discard. Refunds need their own event name or their own id.
  • The server cannot see _fbp or _fbc unless you pass them. A server-only purchase with a hashed email but no click cookie is a valid event and a weaker match — frequently a duplicate that fails the join and counts twice.
  • Purchase fired on the payment redirect rather than on a confirmed order counts orders that never completed. Platforms cannot subtract what they were never told was cancelled.

How to prove it on one order

  1. 1

    Place a real order you control

    Use a discount so you can find it, and note the order id before you open anything else. An order placed by a member of staff on a test card is still a real order if the payments are live.

  2. 2

    Find the browser event

    In the browser's network panel, find the request to the pixel endpoint and read ev= and the eventID argument. Write both down exactly as they appear.

  3. 3

    Find the server event

    Read the event your application sent — event_name, event_id, event_time, value and currency. Compare the strings character by character, including case.

  4. 4

    Confirm one conversion, not two

    In Events Manager, the browser and server copies should appear as one event, not two. If they appear separately, the join failed even though both arrived.

  5. 5

    Check the value the platform kept

    Compare the kept value against the order total. If the value is wrong, the cause is not deduplication — it is the value you sent, and the first copy to arrive is now the record.

  6. 6

    Repeat after any checkout change

    A theme update, a new payment method, or a migration is enough to break the join. This test takes ten minutes and should run after every change to the order flow.

What it costs when the join fails

Reporting errors do not stay in reporting. If a store reports two purchases for every order, its cost per purchase reads at half the true figure. At a £36 true cost per purchase, the dashboard shows £18 — and £18 is a number a merchant will scale on, because it looks like room to spend.

The second cost is the optimisation itself. A platform bidding toward purchases it counted twice is learning from a distorted sample: it favours whatever tends to double-report, which is usually the faster browsers and the cleaner checks page, not the customers who actually buy.

The third is the argument you cannot win. When revenue and reported conversions disagree, there is no version of the conversation where either system is obviously right — which is why the check above matters more than any dashboard.

If you are unsure which of these applies to your store, the check is one order and ten minutes. We do it as part of a tracking audit, and we will tell you plainly if the setup is already correct.

Questions

Asked about this directly

Do I need both a pixel and a server event?
For paid acquisition, yes. The browser sees the click and the session; the server sees the order that actually exists. Either alone leaves a gap: browser-only loses events to blocked or closed tabs, and server-only loses the click identifiers unless you captured them on landing.
What exactly does Meta match to remove the duplicate?
The same pixel ID, the same event name and the same event id, received within 48 hours. The id on its own does nothing if the name differs, and the name alone does nothing if the ids differ.
Why are my purchases counted twice when both events send the same order number?
The usual cause is one of three: the event names differ in case, one path sends the id in a different format, or the two events are attached to different pixel IDs. Each of those breaks the join while looking correct in both logs.
Does deduplication fix an incorrect purchase value?
No. Deduplication collapses duplicates; it does not reconcile amounts. Whichever copy arrives first is the one kept, so if the browser sends 84.50 and the server sends 8450, the platform keeps one of them as sent.

Keep reading

Other pieces in the library

All research

Numbers first, promises second

Send your store and we will tell you which of these failure modes is already happening — before you pay for a fix.

Prefer email? Write to md@fhavi.com