Back to BlogFacebook CAPI

Facebook Pixel vs Conversions API: Why Your Numbers Don't Match (and How to Fix It)

Pixel and CAPI counts will never be identical, and that's healthy. Learn which gaps are normal, which signal a broken setup, and how to diagnose both in 2026.

Facebook Pixel vs Conversions API: Why Your Numbers Don't Match (and How to Fix It)
Table of contents

Key Takeaways

- Facebook Pixel runs in the browser and undercounts because of ad blockers, Safari ITP, and iOS 17/18 privacy controls. The Conversions API (CAPI) runs on your server and captures conversions the Pixel never sees. - A consistent, moderate gap between the two is **expected and healthy**, they are not supposed to report identical numbers. - Real trouble starts when **deduplication fails**: the same conversion sent by Pixel and CAPI with a mismatched `event_id` or `event_name` gets double-counted or confuses Meta's matching. - In Q4 2025 to Q1 2026, Meta's Andromeda audience-signal re-evaluation dropped many accounts' deduplication scores 40-70 points with **no setup change**, a 2026-specific cause to rule out. - Diagnose in Events Manager → Test Events using the Deduplication column; confirm both sources send the **same `event_id` and `event_name`** plus `fbp`/`fbc` and hashed PII.

You open Events Manager, look at your Lead events, and the Pixel says 1,000 while the Conversions API says 1,340. Your gut says something is broken. Usually, it isn't, and the first job of this guide is to teach you the difference between a number gap that is working as intended and one that is quietly wrecking your optimization.

The Problem

The Facebook Pixel and the Conversions API measure the same conversions through two completely different pipes. The Pixel fires from the visitor's browser. CAPI fires from your server. Because they sit in different places, they catch different events, and they will never report identical totals.

That surprises people, so they go hunting for a bug that doesn't exist. Meanwhile, the discrepancy that actually matters, a deduplication failure, hides in plain sight. When the same purchase is reported by both the Pixel and CAPI but the two events don't share an identity, Meta can't tell they're the same action. It either counts the conversion twice (inflating your numbers and teaching the algorithm to chase phantom buyers) or it muddies its matching and drags down your Event Match Quality.

The stakes are not cosmetic. Meta's delivery system optimizes against the conversions you report. Double-counted Leads make a bad audience look profitable. Undercounted Purchases make a winning campaign look like a loser and get it paused. Either way, the bid algorithm is learning from corrupted data, and your ROAS pays for it.

Why It Happens

There are two separate questions hiding inside "why don't my numbers match," and conflating them is the most common diagnostic mistake.

1. Why the Pixel undercounts (this gap is normal). The browser Pixel is the fragile one. It silently loses events to:

  • Ad blockers, which block the fbevents.js script outright, roughly 25-40% of desktop audiences in some verticals.
  • Safari Intelligent Tracking Prevention (ITP), which caps client-set cookies (including _fbp) to a 7-day lifetime and strips many third-party signals.
  • iOS 17 and iOS 18 privacy features, Link Tracking Protection strips fbclid from URLs in Mail, Messages, and Private Browsing, so the Pixel never gets a click ID to store.
  • Network failures and early bounces, where the visitor leaves before the Pixel finishes firing.

CAPI sidesteps all of this because it sends events server-to-server, after the conversion is already confirmed in your backend. So CAPI reporting more events than the Pixel is the expected, healthy state. Per Meta's own Conversions API documentation, the API exists specifically to "reduce the cost per action" by recovering signal the browser drops.

2. Why deduplication breaks (this gap is a bug). When you run Pixel and CAPI in parallel, which you should, Meta needs to recognize overlapping events and count them once. It does that by matching on a shared event_id plus event_name. Dedup fails when:

  • The Pixel and CAPI generate different event_id values for the same action (the single most common cause).
  • The event_name differs between sources (Lead server-side vs Purchase client-side, or a custom event on one side only).
  • One source is missing fbp/fbc or hashed PII, so Meta can't confidently align the two.
  • Events arrive outside the 48-hour dedup window, so the second one is treated as new.

For the rules Meta applies, see Meta Business Help on event deduplication and the Events Manager Test Events tab.

The 2026 wildcard: Andromeda

There's a cause that didn't exist a year ago. During Q4 2025 through Q1 2026, Meta rolled out its Andromeda audience-signal re-evaluation, which changed how overlapping signals are scored. Many advertisers watched their deduplication scores fall 40 to 70 points with no change to their own setup. If your match quality cratered around that window and your configuration was untouched, Andromeda, not your code, is the likely culprit. The fix is the same hygiene below; the point is to not waste a day chasing a regression you didn't cause.

DimensionFacebook PixelConversions API
Data sourceClient-side, fires from the visitor's browserServer-side, fires from your server after the conversion
ReliabilityLossy; undercounts by 20-60% in privacy-heavy verticalsHigh; captures events the browser never sends
What blocks itAd blockers, Safari ITP, iOS 17/18 link/tracking protection, early bounceAlmost nothing, bypasses browser and OS restrictions
Identity signalsAuto-collects fbp/fbc and fbclid when availableYou must pass fbp/fbc + SHA-256 hashed PII explicitly
Attribution strengthWeaker, depends on cookies surviving in-browserStronger, first-party data + click IDs drive 90%+ match
Expected countLower (the floor)Higher (the more complete picture)

How to Fix It

Work these steps in order. The goal is to confirm the gap is the normal kind, then eliminate every bug kind.

1. Compare event counts by source

In Events Manager, open your dataset → Overview, pick a single event (start with Lead or Purchase), and break the count down by source. You're looking for the shape, not the exact numbers. CAPI moderately higher than Pixel, holding a steady ratio day over day, is healthy. Two patterns are red flags:

  • Numbers trending in opposite directions, Pixel climbing while CAPI falls, or vice versa.
  • Huge or erratic swings in the ratio between days.

A stable gap is fine. Divergence is a misconfiguration.

2. Read the Deduplication column in Test Events

Go to Events Manager → your dataset → Test Events. Trigger a real conversion on your site. You should see the browser event and the server event arrive, and the Deduplication column should report the pair as deduplicated. If both show up as separate, un-deduplicated events, Meta is counting that conversion twice, this is your double-counting source.

3. Confirm both sources send the same event_id AND event_name

This is the heart of it. For one user action, the Pixel call and the CAPI call must carry the identical event_id and the identical event_name. Inspect a live event payload from each side and compare the two fields character-for-character. A timestamp baked into one but not the other, or Lead vs lead casing drift, is enough to break the match. If you only fix one thing, fix this.

4. Verify fbp/fbc and hashed PII are present on both

Dedup leans on event_id, but match quality leans on identity. Confirm each event carries fbp and (when a click ID exists) fbc, plus SHA-256 hashed email and phone. A CAPI event with a matching event_id but no shared identity signals can still post a weak match and a low Event Match Quality score. Capture fbc/fbp at form submission, before iOS or ITP can strip them, and forward them server-side. For the deeper playbook on the dedup key itself, see /blog/missing-deduplication-key-facebook.

5. Rule out Andromeda before you rebuild anything

If steps 1-4 check out clean but your dedup score still dropped, line up the drop date against the Q4 2025 to Q1 2026 Andromeda window. If they match and your setup never changed, don't tear down a working configuration, tighten PII coverage and match quality instead, and let the score recover. For recovering the underlying signal lost to platform and OS changes, see /blog/ios-14-data-loss-recovery.

Normal gap vs broken setup

A **consistent, moderate gap** with CAPI higher than the Pixel is normal and healthy. Numbers trending in **opposite directions**, or **huge day-to-day swings** in the ratio, mean a misconfiguration, almost always a mismatched `event_id`/`event_name` or missing identity signals.

How DealOracle Handles This

Most dedup failures come down to one team owning the Pixel and another owning the server events, with no shared source of truth for event_id. DealOracle removes that seam. It generates one shared event_id per conversion and uses it on both the browser Pixel and the server-side CAPI call, sends a consistent event_name, recovers fbc/fbp captured at form submission, and ships SHA-256 hashed PII automatically, so deduplication just works and your two sources stay aligned.

  • One shared event_id and event_name across Pixel and CAPI, no manual coordination
  • Automatic fbc/fbp capture and recovery, before iOS or ITP strips them
  • SHA-256 hashed email, phone, and name for high Event Match Quality
  • Server-side delivery that survives ad blockers, ITP, and iOS 17/18

DealOracle sends server-side events with hashed PII, recovers fbc/fbp, and generates shared event_ids automatically, book a demo.

Bottom Line

Stop trying to make your Pixel and Conversions API numbers match, they're not supposed to. The Pixel is the lossy floor; CAPI is the more complete picture. The number that should keep you up at night isn't the gap itself, it's a deduplication failure: the same conversion counted twice or matched poorly because the two sources don't share an event_id and event_name. Confirm the gap is the normal kind, lock both sources to one shared event identity, and verify in Test Events. If your dedup score cratered in early 2026 with no changes on your end, check the dates against Andromeda before you touch anything. For the parameter-level fix that underpins all of this, start with /blog/missing-deduplication-key-facebook.

DealOracle Team

We build DealOracle to help marketers recover conversion signal lost to iOS 14, ad blockers, and privacy changes, so you can optimize with real data.

Ready to improve your tracking?

Get started with DealOracle and recover 95% of your conversion data.