Meta Pixel and Conversions API on a landing page: measuring what your ads really bring in

Your Facebook campaign is running, clicks are landing on the landing page, forms are being submitted — but Ads Manager only shows a fraction of them. That's not a bug: since iOS 14.5 and Apple's App Tracking Transparency in 2021, and with the rise of ad blockers and consent refusals, the Meta pixel running in the browser loses part of the conversions it was supposed to count. And that signal is the raw material of the delivery algorithm: a machine optimising blind ends up paying more for every lead. Meta's own recommended answer: pair the browser pixel with the Conversions API, server-side tracking. Here's how the two work together, without over-engineering.

What the Meta pixel does on a landing page

The pixel is a small JavaScript snippet loaded in the visitor's browser. It sends standard events to Meta: PageView when a page loads, Lead when a prospect raises their hand, Purchase when a payment goes through. These events serve three purposes: measuring what the campaign brings in, feeding delivery optimisation (Meta looks for profiles similar to those who convert), and building retargeting audiences.

The detail that separates clean tracking from misleading tracking: where to fire the Lead event. Not on the button click — a visitor who clicks and then abandons the form is not a lead — but on the thank-you page, the one that only appears after a successful submission. Same logic as the conversion event on the Google Analytics 4 side: you count the confirmation, never the intent. A landing page without a dedicated thank-you page makes this clean trigger acrobatic — a technical reason, on top of the marketing ones, to have one.

Why the pixel alone is no longer enough

The pixel lives in the browser, which has become hostile territory for tracking: App Tracking Transparency limits what iOS apps pass along, content blockers stop the script from loading, Safari and Firefox shorten cookie lifespans, and a share of visitors legitimately refuses tracking. Each of these filters removes from the count conversions that actually happened.

This phenomenon is documented well beyond vendor talking points. A study by Aridor, Che and Salz published in 2023 in the RAND Journal of Economics empirically measured the GDPR's effect: after it came into force, a share of users becomes invisible to tracking via opt-out, reducing the data advertisers can observe — while the remaining data becomes, in return, more stable and predictable (study on Google Scholar). The lesson: a fraction of your conversions will always escape measurement. The goal is not to see everything — impossible and often illegal — but to make the remaining signal reliable.

And that signal has direct economic value. Work by Wernerfelt, Tuchman, Shapiro and Moakler, released in 2022 as an NBER working paper using Meta data, estimated what advertisers lose when deprived of offsite tracking data: according to the authors' estimates, the median acquisition cost rises substantially when that signal disappears (study on Google Scholar). In other words: every conversion that reports back correctly makes the next ones cheaper.

The Conversions API: the same event, sent from the server

The Conversions API (often shortened to CAPI) sends the same events to Meta, but from a server — yours, your form tool's, or an intermediary's — instead of the browser. A blocker or an iOS restriction can't intercept a request that never passes through the device. It brings three things: events that arrive even when the pixel is blocked, better event match quality (the event can carry data such as the prospect's hashed email, which helps Meta link it to an account), and a more complete signal for the delivery algorithm.

If the pixel and the API send the same event, doesn't Meta count it twice? No — on one condition: deduplication. Each event must carry a unique identifier, the event_id, identical on the browser side and the server side; when Meta receives two Lead events with the same event_id, it keeps only one. Without that shared identifier, your conversions double artificially — and your budget decisions rest on an inflated number.

Setting it up without over-engineering

Good news: for a simple landing page, you rarely need to write server code yourself. Three routes, in order of simplicity:

• Native integrations: most form tools, booking tools and CRMs offer a direct connection to the Conversions API — a few fields to fill in, deduplication handled for you. Check this first.
• Zapier or Make: with no native integration, a "new form submission → send an event to the Conversions API" scenario can be built without a developer.
• Server-side Google Tag Manager: for well-equipped teams, a server-side GTM container centralises the pixel, the API and the rest of your tracking — more robust, but a project in itself, best reserved for volumes that justify it.

In every case, the same principle: the server event fires at the confirmed form submission, with the same event_id as the pixel event on the thank-you page.

GDPR: the pixel isn't allowed to do anything before consent

Neither the pixel nor the Conversions API is exempt from European law: advertising tracking requires prior consent, collected through a properly configured cookie banner. The pixel script must send nothing before an explicit "yes", and server events carrying personal data (hashed email included) follow the same rule: sending through the server the data of visitors who refused isn't a clever workaround, it's a violation. Our GDPR guide for landing pages covers what the form itself must comply with. Yes, part of your conversions will never be measured — the world described by the Aridor, Che and Salz study above: you optimise on the signal from consenting visitors, which is enough to steer the algorithm.

Verifying that it actually works

Meta's Events Manager lists the events received, their source (browser, server or both), the deduplication rate and the match quality. At the time of writing, the Test Events tool lets you walk the journey yourself — visit, submission, thank-you page — and watch each event appear in real time, with its event_id. The test that matters: submit a real form end to end and check that exactly one Lead is counted — not zero, not two. Repeat it after every redesign: a replaced form or a changed URL breaks tracking without showing any error. And keep in mind that Meta and GA4 will never count exactly alike — each measures by its own rules.

The common mistakes

• Firing Lead when the page loads: every visitor becomes a "lead", the algorithm optimises for traffic, and the cost per real lead silently explodes.
• Firing Lead on the button click rather than the confirmed submission: abandons count as successes.
• Pixel + API without deduplication: without a shared event_id, every conversion counts twice.
• The event placed on the wrong page: a Lead on a directly accessible thank-you page counts conversions that aren't.
• A pixel firing before consent: a real legal risk, and data you have no right to use.

Reliable conversion tracking isn't an expert's luxury: it's what lets every advertising euro teach you something. But it needs a page structured to host it. LanderKit templates are Next.js pages shipped with a dedicated thank-you page — the exact place to fire your Lead — and ready to plug in the pixel, the Conversions API and a consent banner: €89 per template, €229 for the full pack, with free hosting on Vercel.