When setting up server-side attribution, the golden standard is to implement a **hybrid tracking setup**. This means you run both the traditional browser-based pixel (Meta Pixel) and the server-side Conversions API (CAPI) simultaneously. The browser pixel provides real-time, click-stream signals, while CAPI serves as the bulletproof backup when browser scripts are blocked or deleted.
However, sending two signals for a single conversion presents a major issue: **double-counting**. If a customer completes a purchase, Meta will receive a browser event and a server webhook event. Without proper **event deduplication**, Meta will report two sales in your Ads Manager, inflating your reported ROAS to a fake 200%+ and leading you to scale unprofitable campaigns.
In this article, we'll cover how Meta's deduplication engine works, why it fails, and how to verify that your tracking matches event parameters perfectly.
The Mechanics of Meta Deduplication
Meta's servers automatically deduplicate matching events by inspecting two required parameters that must be identical in both payloads:
- Event Name (
event_name): The standard event type (e.g.,Purchase,AddToCart,InitiateCheckout). - Event ID (
event_id): A unique, transaction-specific string generated at the moment the action occurs.
When Meta receives a browser event and a server event with the same event_name and `event_id` within 48 hours, it discards the server event and keeps the browser event (which has direct cookie history), or combines their attributes to enrich the user match. Only one purchase is counted toward your ad budget.
🔄 The Deduplication Rule: If Meta receives an event with `event_id = shopify_1024` from the browser, and later receives `event_id = shopify_1024` from the server, they are merged. If the server sends no ID, or a different ID, Meta counts it as **two separate purchases**.
Why Deduplication Fails in E-commerce
In standard integrations, deduplication issues are common due to timing and code structure discrepancies:
- Client-Side ID Generation: If your browser code generates a random number for `event_id` in JavaScript (e.g., `Math.random()`), the server webhook (which doesn't run the client script) has no way of knowing what that random number was. It will generate its own order token, creating an ID mismatch.
- Deduplication Time Window: Meta's deduplication window is active for 48 hours. If your server queue is delayed (e.g., a webhook is retried hours later or held up by order approval apps) and arrives after the window closes, deduplication fails.
- Single-Source Fallbacks: If you disable the browser pixel completely because of ad blocker rates, you do not need deduplication since CAPI is the sole emitter. However, you lose optimization signals from users who do allow tracking.
GotTracked's Automated Event ID Synchronization
GotTracked solves the deduplication challenge natively for Shopify merchants by anchoring the `event_id` to structural Shopify parameters rather than random browser scripts:
- For Purchase events, GotTracked uses the Shopify Order ID or Checkout Token as the `event_id` on both client and server. Since both the client pixel (at thank-you page load) and the server webhook have access to the checkout metadata, the generated IDs match perfectly.
- For AddToCart and ViewContent events, GotTracked generates a persistent session token upon page load. This token is shared via first-party cookies with the browser scripts, ensuring matching event IDs prior to checkout.
Verifying Your Deduplication Status
You can check if your event deduplication is working directly in Meta Events Manager under the **Deduplication** column. A healthy hybrid integration should show **90%+ deduplication overlap** for all standard events. If you see high rates of duplicate purchases, check that your browser tracking script and your server webhook setup are referencing the exact same checkout identifiers.
Frequently Asked Questions
What is CAPI deduplication and why does it matter?
When you run both a browser pixel and server-side CAPI simultaneously, the same purchase event can be sent twice — once from the browser, once from the server. Without deduplication, Meta counts both, inflating your reported conversions and causing the ad algorithm to optimise on false data.
How does Meta deduplicate CAPI and pixel events?
Meta matches events by event_name (e.g., 'Purchase') and event_id. If two events share the same event_name and event_id within a 48-hour window, Meta discards the duplicate and counts only one. The event_id must be unique per conversion instance.
What should I use as the event_id for deduplication?
The best practice is to use a unique order ID or a UUID generated at the moment of the conversion event. For a Shopify purchase, the Shopify Order ID is ideal — it's unique per transaction and available both in the browser (via thank-you page JS) and on the server (via Order webhook).
How do I check if my CAPI deduplication is working?
In Meta Events Manager, go to your pixel's event overview. If deduplication is working correctly, you'll see a 'Deduplicated' count next to matched events, and your total conversion count should roughly equal your actual order count (not double it).
Does poor deduplication hurt my ad performance?
Yes. Duplicate events cause Meta's algorithm to think it has more conversion data than it actually does, which leads to overconfident budget allocation and worse real-world ROAS. It also inflates your reported ROAS, making underperforming campaigns look profitable.
Start Recovering Your
Lost Attribution Today
GotTracked sets up in under 15 minutes and is free for the first 2,000 pioneer merchants.
Join 450+ marketers already scaling.
100% Data Privacy Standards