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 lives | Browser pixel | Server event |
|---|---|---|
| Event name | event on the /tr request: ev=Purchase | event_name: "Purchase" |
| Event id | eventID — the fourth argument to fbq('track', …) | event_id |
| Value | cd[value], cd[currency] on the request | custom_data.value, custom_data.currency |
| Timestamp | sent by the pixel automatically | event_time — within roughly 7 days of now |
| Click identifiers | _fbp and _fbc cookies, read from the browser | user_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.
| Setup | What arrives | What Meta keeps | What the owner sees |
|---|---|---|---|
| A — browser only | One Purchase, £84.50 | One purchase | Under-counted on the sessions where the browser failed, but no duplicate |
| B — both, no shared id | Purchase (browser) and Purchase (server), different ids | Two purchases, £169.00 | Reported purchases higher than orders; cost per purchase lower than it really is |
| C — both, shared id | Purchase, £84.50, id order-1842, twice | One purchase, £84.50, first arrival kept | Reported 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
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
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
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
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
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
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.
