Server-side conversion tracking: how to enable without double-counting

How to enable server-side conversion tracking in Meta and Google Ads without double-counting: shared event_id, transaction ID, hashing, and what to check.

ADS Beast editorial teamPublished Updated 8 min read

This article was prepared with AI. The ADS Beast editorial team is responsible for its content.

Server-side conversion tracking sends conversion events from your server to Meta or Google Ads instead of relying only on the browser. That makes measurement less dependent on ad blockers and cookie restrictions. To prevent double-counting you do not have to switch the browser pixel off: Meta deduplicates a browser event and a server event when both carry the same event name and the same event_id and arrive within 48 hours of each other (Meta for Developers). In Google Ads the same job is done by a transaction ID.

In short:

  • Server-side conversion tracking sends events from your backend through the platform's API, alongside or instead of the browser pixel.
  • Double-counting happens when both client-side and server-side events fire for the same action without a shared ID.
  • On Meta, deduplication relies on a matching event name and event_id; in Google Ads, on a transaction ID.
  • Meta recommends running the Conversions API alongside the Pixel, so the shared event_id matters more than switching the pixel off.
  • Mismatched data between ad platforms and CRM often persists even after enabling server-side tracking unless identifier hashing and timing are aligned.

What is server-side conversion tracking and how it relates to the pixel

Server-side conversion tracking is the process of sending conversion data (for example a purchase or a sign-up) from your own server to an ad platform's endpoint. Unlike a browser pixel, it does not depend on JavaScript running in the visitor's browser, so it keeps working when scripts are blocked or the pixel fails to load. On Meta it is not meant to replace the pixel: Meta recommends implementing the Conversions API alongside the Meta Pixel and deduplicating the two streams. You can also send an event from the server only, and then there is nothing to deduplicate against.

How double-counting happens and how platforms deduplicate

Double-counting occurs when the same conversion registers twice: once from the browser (via pixel or gtag) and once from your server, with nothing that tells the platform the two are one action. Meta treats two events as the same when the event name matches and the Pixel's eventID equals the Conversions API's event_id; it can also match on event name plus fbp or external_id. Events are deduplicated only if they arrive within 48 hours of the first one, and Meta generally keeps the event it received first. In Google Ads, when two conversions for the same conversion action carry the same transaction ID, the second is treated as a duplicate and is not counted (Google Ads Help). If your pixel fires with one ID and your server generates a different one, you get two conversions.

Server-side tracking without double-counting. Share one event_id: Same event name and event_id from pixel and server; Send hashed identifiers: SHA-256 email or phone after normalization; Send event_time correctly: Unix seconds, no older than 7 days for Meta; Check the platform diagnostics: Events Ma
Each step is required: skipping one produces duplicate or rejected conversions.

What identifiers you must pass—and why hashing matters

For Meta, contact details go in hashed form: email (em), phone number (ph), first name (fn), last name (ln), city (ct), state (st), zip code (zp) and country are hashed with SHA-256 after normalization. For email that means trimming spaces and converting to lowercase before hashing. Technical parameters are the opposite: client_ip_address, client_user_agent, fbc and fbp must not be hashed (Meta for Developers). Meta's systems are designed not to accept unhashed contact information. Keep normalization identical in your CRM and in your server payload, otherwise the same person produces different hashes and match quality drops.

How to verify your server-side events are accepted—and where to look

Check acceptance in three places:

  1. Meta Events Manager: shows received events, their sources and deduplication status; the Test Events tool shows which events are received, deduplicated, or dropped.
  2. Google Ads conversion settings: open the conversion action and check its status and diagnostics.
  3. Your server logs: log full request payloads, response status codes, and retry attempts. Do not rely solely on platform interfaces, because reporting there can lag behind the API response. If your server gets a success response but Events Manager shows nothing, check the timestamp and the identifier hashing first. Meta expects event_time as a Unix timestamp in seconds, and it can be up to 7 days before the moment you send the event (Meta for Developers).

Server-only, pixel plus server, or pixel only

FeatureServer-side onlyPixel plus Conversions API (redundant setup)Client-side only
Reliability under ad blockersHighHigh (the server event still arrives when the browser one is blocked)Low
Required dev effortHigh (backend changes, auth, error handling)High (backend work plus a shared event_id on both sides)Low
DeduplicationNot needed against the browser; still use unique event_id valuesRequired: same event name and event_id on both sidesNot applicable
NotesNo browser signals at allThe setup Meta recommendsFragile when scripts are blocked

Running the pixel and the server together is not a risk in itself. It double-counts only when the two events lack a shared event name and event_id. Server-only tracking removes the browser from the loop, but it also fails silently if your server cannot reach the platform's endpoint, for example because of firewall rules or rate limiting. Test connectivity before launch.

How to align server-side tracking with your CRM—and why mismatch persists

Server-side conversion tracking does not fix CRM-ad platform mismatches by itself. It only changes how data enters the ad platform. The root cause of disagreement—like why your ad account reports 127 purchases while your CRM shows 94—is usually inconsistent user identification or timing gaps. If your CRM stores email in lowercase and your server hashes uppercase email, the hashes differ. If your CRM records purchase time at payment confirmation but your server sends event_time at order creation, the timestamps diverge. You must standardize casing, whitespace, and time sources before enabling server-side tracking. Otherwise, you replace browser noise with server noise.

What breaks server-side tracking—and how to spot it early

Three failure modes dominate real-world setups:

  1. Wrong timestamps: event_time must be a Unix timestamp in seconds for the moment the conversion happened. Meta accepts events up to 7 days old; a server clock that is far off, or a timestamp in the wrong format, gets events rejected or attributed to the wrong time. Keep the server clock synced with NTP.
  2. Hash inconsistency: Same email hashed with different salts, encodings, or case handling. Validate hashes against a known reference set before deployment.
  3. Missing or mismatched event_id: Meta uses the event name and event_id to deduplicate, both between pixel and server and between repeated server events. If the browser and the server generate different IDs, or you reuse one ID for different conversions, counts go wrong. Generate one unique ID per conversion (an order number works) and pass that same value on both sides.

Do not wait for campaign reporting to catch these. Monitor HTTP status codes, rejection reasons, and event volume daily for the first week. A clear drop in accepted events against the volume you expect means something failed.

Next step: run a 30-minute audit before enabling server-side conversion tracking

Before writing a single line of backend code, audit your current setup. Check whether client-side events fire correctly, whether identifiers are collected and hashed consistently, and whether your CRM timestamps align with your frontend logic. Start there. Then move to implementation.

ADS Beast sends server-side conversions from CRM stages with deduplication. Access is by invitation: you can join the waitlist on the home page.

Related reading

See how this works in ADS Beast.