Client-side tracking runs in the visitor’s browser: a script loads, reads cookies and reports the event to Meta. Server-side tracking sends the same event from your server, through the Conversions API, with the identifiers your server holds. The browser can be blocked, throttled or closed before it reports anything; a server that received the form can report the Lead whatever the visitor’s browser did. That is the difference in one line, and it is the reason the two are usually run together rather than as alternatives.
One Lead, two places it can be created
With the Pixel alone, the browser does all the work. A script loads, reads Meta’s cookies, and reports Lead when the form is sent. No script, no event: an ad blocker, a script error or a connection that dies in the in-app browser leaves the lead in your inbox and nothing in Meta.
With the Conversions API, the report comes from your server. It carries the event name, its time, an event_id, and the customer information Meta matches on: hashed email and phone, the click identifier, the IP address, the user agent. Meta says website events sent this way are linked to your Pixel and behave like Pixel events, used for the same kinds of optimisation and visible in the same places.
Both routes describe the same submission. The difference is who is still standing when the moment arrives.
Two things people mean by server-side tracking
The label hides two different changes, and many setups make only one of them. The first is where the event is sent from: your server rather than the visitor’s browser. Meta’s setup options cover that half, from the one-click option that copies what the Pixel already collected to a direct integration that builds the payload from scratch.
The second is where the identifiers are stored: in a cookie written by your server, in an HTTP response, on your own domain, instead of one written by JavaScript. No Meta setting controls that half. The browser’s cookie policy does, and it decides how long the click survives.
A setup that moves the event to the server but still reads a cookie written by JavaScript has done half the job. Server-side tracking for Facebook ads covers both halves and which setup option produces which.
What each side can and cannot see
| Client-side (Pixel) | Server-side (Conversions API) | |
|---|---|---|
| Runs when a script is blocked | no | yes, if the server saw the submission |
| Runs when the page is closed early | usually not | yes |
| Sees events after the visit, such as a call or a qualified lead | no | yes |
| Needs the browser to read the cookie | yes | no, if the server wrote it |
| Sends PageView on arrival | yes | yes, but as a duplicate of the browser event |
| Detects events automatically | yes | no, you name every event |
| Carries hashed email and phone | yes, with advanced matching | yes, from the form fields |
The last rows are the reason the Pixel does not become redundant. Automatic event detection and the landing page view metric depend on the browser code. Server-side tracking has the short definition if you need one sentence for a client.
The Safari rule that decides most of the attribution
WebKit’s tracking prevention separates cookies by who wrote them, and that separation explains why some server setups keep the click while others lose it.
- JavaScript writes the cookie: it is removed after 7 days without the visitor interacting with the site.
- JavaScript writes the cookie on a page whose URL carries a click ID: the limit drops to 24 hours. An
fbclidin the URL is a click ID. - Your server writes it in an HTTP response: neither limit applies, unless the response comes from a subdomain that resolves through a CNAME to a third party, or from a third-party IP address, where 7 days applies again.
There is no rule in that list that touches a cookie written by the host that serves the landing page, in the response that renders it. The Pixel is JavaScript, so both JavaScript limits apply to the cookies it writes. A server container on a subdomain that points at a hosting provider falls into the third case.
So “server-side” in the sense that matters for a lead gen funnel means three things at once: the landing page is served from your domain, the click cookie is set in that same response, and the form posts back to the same host. How is first-party tracking different from third-party tracking in Meta ads? takes the cookie question apart, and tracking after iOS has the history of what broke and when.
What server-side tracking does not fix
This is the part that gets oversold, so here it is as a table.
| The problem | Does the server event fix it? | Because |
|---|---|---|
| A blocker or a script error stops the Pixel | yes, for the server copy | Meta says Conversions API data suffers less from browser loading, connectivity and blockers |
| Safari shortens the cookie | only when your server writes it | the rule above |
| Something happens after the visit | yes | the server reports what the browser never saw |
| Consent | no | Meta says the API is not designed to bypass the ePrivacy Directive or App Tracking Transparency |
| Attribution windows | no | the same attribution setting applies to server events |
| Modelled conversions in Ads Manager | no | Meta can still model results where the data is partial |
| An event with no identifiers | no | nothing to match, so nothing to attribute |
The consent row deserves a sentence of its own. Moving the call to your server changes how the data travels, not whether you are allowed to send it. If your banner holds the Pixel back until someone accepts, the server event for that visitor needs the same gate, and the design of that gate is a question for your privacy counsel.
How the two sides are joined
Run both, and you have two copies of every Lead. Meta keeps one when the event names match and the Pixel’s eventID equals the server’s event_id, as long as the second arrives within 48 hours of the first. Without a shared ID, every lead reported twice is counted twice, which lowers the reported cost per lead and makes a broken setup look like a good week.
The reliable order is: the server creates the lead and its ID, sends the event with that ID as event_id, and hands the same string to the browser for the Pixel. A server that sends the Lead the moment the form arrives will often beat the browser to it, which is why the browser-first deduplication routes are less dependable.
Choosing for a lead gen account
Start from where the Lead physically exists. A form on a landing page reaches a server whatever the browser did; the Pixel’s copy exists only if its script ran.
If you control the backend the form posts to, use a direct integration, and have it set the click cookie on the same domain in the same response that serves the page. If the pages sit on a platform with a Meta partner integration, use that and confirm in Test Events that the Lead arrives as a server event carrying an event_id. With no developer and the Pixel already installed, switch on the one-click server option in Events Manager: it costs nothing, and a server copy of what the browser sees is better than no server copy at all.
What no setup repairs is a lead with no identifiers attached. How to set up the Meta Conversions API for lead generation has the payload, field by field, and the checks that tell you whether the two copies really deduplicate.