Skip to content

Meta AdsPublished 10 min read

Meta Conversions API Deduplication: A Practical Guide

How to run the Meta Pixel and the Conversions API side by side without counting every lead or purchase twice.

Muhammad Qitmeer, founder of Augere Labs
Muhammad Qitmeer
Co-founder and CEO, Augere Labs
Share

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.

FieldPixel (browser)Conversions API (server)Must match?
Event nameFirst argument of the track call, e.g. Leadevent_nameYes, exactly
Event IDeventID in the options objectevent_idYes, exactly
Event timeSet by Meta on receiptevent_time in Unix secondsNo, but should reflect the real action time
Browser IDRead from the _fbp cookiefbp in user dataShould match; helps matching and the fallback
Click IDRead from the _fbc cookiefbc in user dataShould 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:

  1. 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.
  2. 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.

OptionHow dedup is handledGood forWatch out for
Native partner integration (Shopify, WooCommerce, WordPress plugins)The integration generates and shares IDs if configured correctlyStandard stores and sites with no custom trackingRunning it alongside a GTM Pixel or a second plugin creates duplicates
Conversions API GatewayMirrors Pixel events server-side and handles dedup itselfTeams that want CAPI without building eventsHosting and maintenance; it only sends what the Pixel already sends
Server-side GTMYou pass the event ID from web to server containerClients with several platforms (GA4, Google Ads, Meta) to routeNeeds hosting, a first-party subdomain and an owner
Direct API from backend or CRMDeveloper sends the shared ID with each eventLead gen where the real outcome lives in the CRMNeeds 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.

  1. Open Test Events in Events Manager for the client's dataset. Copy the test event code.
  2. 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.
  3. Submit a real form on the site, in a normal browser session, using the URL Test Events gives you or your own browser.
  4. 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.
  5. 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.
  6. 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.

Just one quick fix, not a whole account? Our founder takes small fixed-price jobs on Fiverr: Meta Conversions API and duplicate event fix

Frequently asked questions

What fields does Meta use to deduplicate Pixel and Conversions API events?

Meta matches the event name and the event ID. The Pixel's event name and eventID must exactly equal the server event's event_name and event_id for the two to be merged.

How long is Meta's deduplication window?

Meta documents a 48-hour window for matching browser and server events. In practice, send server events within seconds of the action so optimization gets the signal quickly.

Can I use the order ID as the event ID?

Yes, for purchases the order ID is a good event ID because both the browser and the backend know it. For leads, generate a random ID at submission and pass it to both channels.

Do I still need the Pixel if I have the Conversions API?

Meta recommends using both. The Pixel provides browser context and the Conversions API survives blockers and browser limits, as long as both carry the same event ID.

How do I check if deduplication is working?

Use Test Events with a test event code on server events, submit a real form, and confirm one browser and one server event arrive with the same name and ID and are shown as deduplicated. Then check the event details in Events Manager over a few days.

Muhammad Qitmeer

Written by

Muhammad Qitmeer, founder of Augere Labs

Augere Labs is the white-label tracking partner behind marketing agencies. If a client account has numbers you don't trust, I'm happy to look at it with you and tell you straight what's wrong.

Connect on LinkedIn