Meta deduplicates a Pixel event and a Conversions API event when both carry the same event_name and the same event_id. That means you generate one ID at the moment the person acts, pass it to the Pixel as eventID and to the server as event_id, and then confirm in Events Manager that the two are being merged. If either side invents its own ID, or the event names differ by so much as a capital letter, Meta counts the action twice.
This guide is written for agency owners, PPC managers and media buyers who look after client ad accounts and keep seeing leads in Ads Manager that the client's CRM never received. It covers why you want both channels, exactly how deduplication works, how to pass one ID from the page through Google Tag Manager to the server, how to read the result in Events Manager, and the failure modes that show up again and again in client accounts.
Why run the Pixel and the Conversions API together
The Meta Pixel runs in the browser. It has rich context: the page URL, the _fbp browser cookie, the _fbc click cookie, the user agent. It also loses data. Ad blockers stop it, browser privacy features limit its cookies, and a visitor who closes the tab before the tag finishes never gets counted.
The Conversions API (CAPI) sends the same events from a server. It is not blocked by browser extensions and can include customer information collected at the moment of conversion, such as a hashed email from the form. It has less browser context unless you pass that context along.
Meta's own guidance is to use both, a setup it calls redundant. The two channels cover each other's gaps. The price of redundancy is that most conversions now arrive twice, once from each channel, and Meta needs a reliable way to know they are the same action. That way is the event ID.
How Meta deduplication actually works
When Meta receives a browser event and a server event for the same dataset (the Pixel ID), it compares two fields:
- Event name. The Pixel's event name, such as
Lead, must match the server event's event_name exactly. Lead and lead are different events.
- Event ID. The Pixel's
eventID parameter must match the server's event_id exactly.
If both match and the events arrive within Meta's deduplication window (Meta documents this as 48 hours), Meta keeps one and discards the other. If either field differs, both count.
Meta also documents a fallback that uses the fbp browser ID and external_id when no event ID is present. Treat it as a safety net, not a plan. It is less predictable, it does not cover every case, and you cannot easily verify it. Every event you send from both channels should carry an explicit event ID.
| Field | Pixel (browser) | Conversions API (server) | Must match? |
| Event name | First argument of the track call, e.g. Lead | event_name | Yes, exactly |
| Event ID | eventID in the options object | event_id | Yes, exactly |
| Event time | Set by Meta on receipt | event_time in Unix seconds | No, but should reflect the real action time |
| Browser ID | Read from the _fbp cookie | fbp in user data | Should match; helps matching and the fallback |
| Click ID | Read from the _fbc cookie | fbc in user data | Should match |
A note on timing
Deduplication tolerates delay, but optimization does not love it. Send server events as close to the action as you can, ideally within seconds. Batching server events once a day keeps them inside the dedup window but delays the signal Meta uses to steer delivery. Set event_time to when the action happened, not when your server got around to sending it, and keep action_source set to website for website events.
Generate one ID per action, then pass it everywhere
The single most important rule: the event ID is created once, at the moment of the action, and every channel reads that same value. It is not generated separately by the Pixel tag and the server tag. Two tags each calling a random ID function will produce two different IDs, and deduplication will sit near zero.
Good event IDs are unique per action and stable across channels. For a purchase, the order ID is a natural choice because both the thank-you page and the backend know it. For a lead, generate a random ID when the form is submitted. Avoid timestamps on their own (two tabs, same second), and avoid anything that changes on page reload if the reload can fire the event again.
The data layer pattern with GTM
The cleanest pattern for most agency clients is: the site pushes one data layer event per real action, with the event ID already in it. Every tag reads from that push.
// On a successful form submission (not on button click)
var leadEventId = 'lead_' + Date.now() + '_' + Math.random().toString(36).slice(2, 10);
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
event: 'lead_submitted',
event_id: leadEventId,
form_name: 'quote_request'
});
In GTM you then create a Data Layer Variable for event_id and use it in two places:
- The Meta Pixel tag. Whether you use a custom HTML tag or a community template, the track call needs the event ID in its options object, for example
fbq('track', 'Lead', {}, {eventID: 'lead_123'}), with the value coming from your variable. Note that eventID goes in the fourth argument, not inside the custom data object. Putting it in the wrong object is a very common reason dedup fails.
- The server path. Either the web container forwards the event to a server GTM container (where a Conversions API tag reads the same event ID from the incoming event data), or the form posts the ID to the client's backend in a hidden field, and the backend includes it as
event_id in its CAPI request.
If the site cannot push to the data layer, you can generate the ID in a GTM variable, but then you must make sure the value is created once per event and reused by both tags in the same event. Some community templates do this by caching a unique ID per GTM event. Test it rather than trusting it.
Direct API from the client's backend
When the client's developer sends CAPI events straight from their backend (or from the CRM via a webhook), the event ID has to travel from the browser to the server with the form data. Add a hidden field to the form, fill it with the same ID the Pixel uses, and store it with the lead. The backend then sends event_id with that value. For purchases, use the order ID on both sides and you avoid the hidden field entirely.
Setup options compared
There is no single right way to send server events. The right choice depends on the platform, who maintains the site and whether a server container already exists.
| Option | How dedup is handled | Good for | Watch out for |
| Native partner integration (Shopify, WooCommerce, WordPress plugins) | The integration generates and shares IDs if configured correctly | Standard stores and sites with no custom tracking | Running it alongside a GTM Pixel or a second plugin creates duplicates |
| Conversions API Gateway | Mirrors Pixel events server-side and handles dedup itself | Teams that want CAPI without building events | Hosting and maintenance; it only sends what the Pixel already sends |
| Server-side GTM | You pass the event ID from web to server container | Clients with several platforms (GA4, Google Ads, Meta) to route | Needs hosting, a first-party subdomain and an owner |
| Direct API from backend or CRM | Developer sends the shared ID with each event | Lead gen where the real outcome lives in the CRM | Needs developer time; easy to forget the browser side's ID |
For many lead-gen clients, a clean GTM Pixel plus server events through either a native integration or server GTM is enough. Our server-side tracking service covers the server container route, and the post on whether server-side tracking is worth it helps decide if a given client needs it at all.
Reading deduplication in Events Manager
Events Manager is where you confirm the setup works in production. The interface changes regularly, so look for these things rather than exact menu names:
- Connection method per event. In the dataset overview, each event shows whether it arrives from the browser, the server or both. A
Lead event that should come from both but only shows one is your first clue.
- Deduplication details. Open an event and look at its details for deduplication information: how many events were received from each source and how many were deduplicated. When both channels send every lead, you want to see most server events matched to browser events.
- Event match quality and coverage. Meta shows how well server events cover browser events and how well they match people. Low coverage can mean server events are missing; very high counts with low dedup means duplicates.
- Diagnostics. Meta flags common problems here, including missing event IDs and events received from the server without a matching browser event.
A practical sanity check: compare the number of Lead events Meta reports for a week to the number of real leads the client's CRM received from all sources. If Meta reports noticeably more leads than the CRM has in total, something is double counting. Some gap in the other direction is normal, because not every lead came from Meta.
Testing before you trust it
Never declare deduplication fixed based on configuration alone. Run real tests.
- Open Test Events in Events Manager for the client's dataset. Copy the test event code.
- Add the test code to server events while testing. In server GTM or the direct API, this is the
test_event_code field. Remove it when you finish, or production events will land in the test view instead of counting.
- Submit a real form on the site, in a normal browser session, using the URL Test Events gives you or your own browser.
- Check both events arrive, one marked browser and one marked server, with the same event name and event ID. Test Events shows whether the events were deduplicated.
- Repeat for every path: each form, each thank-you page, the checkout, any booking widget. A setup that works for the contact form often fails for the embedded calendar.
- Test the edge cases: refresh the thank-you page, press back and resubmit, submit with an ad blocker on. Note what happens in each case.
In GTM Preview, confirm that the Pixel tag and the server-bound tag fired on the same data layer event and both show the same event ID value. Screenshot it. That test log is what you show the client when they ask why the lead count changed.
Common failure modes
- Each tag generates its own ID. The Pixel tag and the server tag both call a random ID function. Two IDs, no dedup.
- eventID in the wrong place. The ID is passed inside the custom data object rather than the options object of the track call, so Meta never sees it as an event ID.
- Mismatched event names. The Pixel sends
Lead while a plugin's server events send SubmitApplication or a custom name for the same action.
- Two server senders. A Shopify or WordPress integration sends server events, and a server GTM container or Gateway sends them too. The browser event dedups against one of them; the other counts extra.
- Server event fires on a different trigger. The browser fires on the thank-you page, the server fires when the CRM creates the contact, and the IDs were never linked.
- Test code left in production. Server events keep landing in Test Events and never count, so the account looks fine on browser data and then drops when someone removes the Pixel.
- Server events without user data. Deduplication works, but match quality is poor because server events carry no email, phone,
fbp or fbc. See our event match quality guide.
Many of these start with plugins and theme code that nobody remembers installing. The post on duplicate Meta Pixel events on Shopify and WordPress covers how to find them.
What we check in an audit
When we audit a client's Meta setup, deduplication is one of the first things we look at, because it affects every number the agency reports. The checks are:
- Every event received for the dataset, and from which channel: browser, server or both
- The deduplication rate per event and how the event ID is generated
- Which tool sends server events: native integration, Gateway, server GTM, CRM or custom code, and whether more than one does
- The triggers behind each event, so
Lead fires on a real submission and not on a page load or button click
- Customer information parameters sent with server events
- Meta-reported conversions compared with the client's CRM for the same period
The output is a list of what is double counting, what is missing, and what to change, with test evidence for each point. You can see the format in our sample audit.
Getting it fixed
If a client's Meta account reports more leads than their CRM can find, deduplication is the first place to look. Our Meta Conversions API service sets up one shared event ID per action, removes rogue server events and documents the tests, starting with a free tracking check.