Skip to content
New5 AI ad images in every free trial

Conversions API

Client-Side vs Server-Side Tracking: Key Differences for Ecommerce

Client-side vs server-side tracking: how browser pixels and server events differ in accuracy, privacy and setup, why ecommerce stores use both and how to start.

By PixlBridge Team

Updated 19 min read

On this page

Ecommerce ad tracking reports what shoppers do on your store, from viewing a product to buying it, back to the platforms that showed them your ads. Client-side vs server-side tracking is the question of who sends those reports: the shopper’s browser, or your server. The answer affects how many of your sales Meta, Google and TikTok hear about, and how well they can match each sale to the ad behind it.

Browser tracking is where most stores start: a pixel runs on every page and reports each action as it happens. It’s quick to set up, but ad blockers, browser privacy features and closed tabs stop a share of those reports, so some sales never reach the platform. Server-side tracking sends events from your store’s backend, where the browser can’t get in the way, but it takes more setup and has limits of its own.

This guide puts the two side by side: how each works, the key differences in one table, the pros and cons, why most stores use both, how deduplication stops a sale from counting twice, how to set up each on a Shopify store (the steps carry over to other platforms), the common mistakes, and how PixlBridge handles the server side for Meta.

Client-side vs server-side tracking: key differences

Client-side (browser-side) tracking sends events from the shopper’s browser: a script such as the Meta Pixel reports each page view, add to cart and purchase as it happens. Server-side tracking sends them from your store’s server to the ad platform, through an API such as the Meta Conversions API. The browser sees browsing best; the server sees orders best.

Client-side (browser) trackingServer-side tracking
Sent byThe shopper’s browser, through a pixel or tagYour store’s server, or an app working for it, through the platform’s API
Sees bestBrowsing as it happens: page views, product views, searches, adds to cartOrders and customer details from your store’s records
Ad blockers and browser privacyCan block the script or cut its cookies shortCan’t block a request your server sends
IdentifiersBrowser cookies (such as Meta’s _fbp and _fbc), IP address, user agentHashed email, phone and address from the order, plus the browser IDs when they’re passed on
Order detailsWhat the confirmation page exposesThe full order: value, currency, items, order ID
SetupA platform app or a code snippetAn integration, an app or developer work
UpkeepScript errors, duplicate pixelsFailed deliveries, expired access, data errors
Consent and privacyUsually runs only when your cookie banner allows itDepends on the setup; privacy law and your privacy policy still apply
ExamplesMeta Pixel, Google tag, TikTok PixelMeta Conversions API, TikTok Events API, GA4 Measurement Protocol

Neither method replaces the other: most stores that advertise run both, with one shared event ID per action so each sale is counted once.

How client-side (browser-side) tracking works

With client-side tracking, the work happens on the shopper’s device. The platform’s script loads with each page, watches for the actions you’ve set up, and sends each one to the platform as a small request from the browser.

  1. A shopper opens a page on your store.
  2. The page loads the tracking script, for example the Meta Pixel.
  3. The script notices an action, such as a product view, and builds an event (ViewContent) with details like the product and its price.
  4. The browser sends the event to the platform. The platform’s cookies, the IP address and the user agent travel with the request.
  5. The platform uses the event for reporting, audiences and ad delivery.

Common client-side tools are the Meta Pixel, the Google tag (which sends events to Google Analytics 4 and Google Ads) and the TikTok Pixel. Google Tag Manager’s web container manages such tags in one place, but the tags it loads still run in the browser.

How server-side tracking works

With server-side tracking, the event leaves from a server instead of the shopper’s browser. Your store records what happened, and your server, or an app connected to your store, sends the event to the ad platform’s API.

  1. A shopper does something on your store, such as placing an order.
  2. Your store records it and passes the details to a server, often through a webhook: an automatic message the store sends when something happens.
  3. The server prepares the event in the platform’s format: event name, time, order value and currency, plus customer details, normalized and hashed the way the platform requires.
  4. It sends the event to the platform’s API, server to server, and can try again if the platform doesn’t answer.
  5. The platform processes it like any other event.

Common server-side tools are the Meta Conversions API (CAPI), the TikTok Events API and the GA4 Measurement Protocol. Server-side Google Tag Manager is a server container you host: it receives tracking requests and forwards them to the destinations you choose.

Server-side doesn’t always mean the browser is out of the picture. A product view happens only in the browser, so many server-side setups capture browsing events there with a lightweight script and send them on from the server. Purchases are different: the order exists in your store’s records, so the server can report it even when the browser reported nothing. What is server-side tracking? walks through both halves on a Shopify store, step by step.

Pros and cons of each method

Client-side tracking: pros

  • Quick to start. Platform apps and integrations add a pixel without code, and there’s no server to run.
  • Sees the shopping session. Page views, product views, searches and adds to cart happen in the browser and leave no order behind. These browsing events feed retargeting audiences, such as people who viewed a product but didn’t buy.
  • Carries the browser’s own signals. It reports in real time and carries the platform’s cookies, including the click ID from the ad, which help connect a visit to the ad that brought it.

Client-side tracking: cons

  • Blockers. Ad blockers and privacy extensions can stop the script or its requests.
  • Browser privacy features. Safari’s tracking prevention and similar features shorten cookie lifetimes and can strip click IDs from links, so a purchase days later is harder to tie to the ad click.
  • Fragile delivery. Slow connections, a tab closed before the script loads, in-app browsers and script conflicts all lose events.
  • Limited to the page. The pixel knows only what the page shows, and actions that never touch a browser, such as a subscription renewal or a phone order, can’t be reported at all.
  • Page weight. Every extra tag adds JavaScript your pages have to load.

How much these cost you depends on your shoppers’ devices and browsers. Tracking pixel limitations explains why browsers lose events in more detail.

Server-side tracking: pros

  • The browser can’t block it. Ad blockers, closed tabs and script errors don’t stop a request your server makes, so orders your store records can reach the platform even when the pixel missed them.
  • Exact order data. Value, currency, items and order ID come from your store’s records, and events that happen away from the site can be sent too.
  • Better matching. Hashed email, phone and address from checkout help the platform connect an event to a person. Meta scores how well your events match as Event Match Quality (EMQ), from 0 to 10.
  • Control and visibility. You decide what’s sent, can fix or filter values before they leave, and can see failed deliveries and retry them.

Server-side tracking: cons

  • More setup. At minimum an app or integration; a custom build needs API access, event mapping, webhooks and hosting.
  • Ongoing upkeep. Access tokens expire, permissions change and platforms update their APIs, so deliveries need watching.
  • Data quality is on you. A wrong timestamp, value or currency goes straight into your reports.
  • Deduplication. Running it next to a pixel means every event both of them send needs a matching ID (more below).
  • Privacy law still applies. A cookie banner may not control server events, but sending from a server doesn’t take the data outside privacy law: your privacy policy must still disclose it, and some laws require consent for sharing it with ad platforms.

Which should you use? Both, for most stores

When you weigh server-side vs client-side tracking for ecommerce, the answer for a store running paid ads is both, for three reasons:

  • More of your events arrive. When the pixel is blocked, the server still reports the purchase; when a server delivery fails, the browser event is still there.
  • Each event can carry both sets of identifiers. The browser contributes its cookies and the ad click ID; the server adds hashed customer details from the order. Together they help the platform match more events to people, which feeds both attribution and the delivery system that decides who sees your ads.
  • It’s what the platforms recommend. Meta recommends running the pixel and the Conversions API together, and Google describes GA4’s Measurement Protocol as a supplement to its tag, not a replacement.

Browser tracking alone can be enough for a store that doesn’t advertise yet or only wants basic traffic numbers. Server-only also works, though you give up the browser’s real-time signals unless your setup collects them there. For Meta’s two tools side by side, see Meta Pixel vs Conversions API.

Running both comes with one rule: each action has to be counted once.

How the two work together: deduplication with event_id

When the pixel and the server both report the same purchase, the platform receives two events for one sale. Deduplication is how it keeps one.

Meta’s rule is simple: a browser event and a server event are duplicates when they have the same event_name and the same event_id and arrive within 48 hours of each other. Meta keeps one. The pixel passes the ID as eventID, the Conversions API as event_id:

// Browser: the Meta Pixel on the order confirmation page
fbq("track", "Purchase", { value: 59.00, currency: "USD" }, { eventID: "order-1001" });

// Server: the same purchase sent to the Conversions API (other fields left out)
{ "event_name": "Purchase", "event_id": "order-1001", "action_source": "website",
  "custom_data": { "value": 59.00, "currency": "USD" } }

The ID has to be something both sides know when they send. For a purchase, the order or checkout ID works. For browsing events, the browser can create an ID and pass the same value to the server; on Shopify, every customer event already has its own ID that both sides can use. Other platforms follow the same idea with an event ID or the order’s transaction ID, so check each platform’s documentation.

What happens without deduplication

Say your store takes 100 orders in a week. The pixel reports most of them, the server reports them too, and the IDs don’t match. Meta now counts close to 200 purchases. Your cost per purchase looks about half of what it is, Meta-reported ROAS (return on ad spend) roughly doubles, and budget decisions follow sales that never happened.

How to check it

In Events Manager, each event’s details show the connection method it arrived through (browser or server) and how many events were deduplicated. Then compare the Purchase count with your store’s orders for the same days. Events Manager counts the events it receives, so if it shows clearly more purchases than you had orders, something is reporting the same sales twice.

How to set up browser-side and server-side tracking on Shopify

The steps below use Shopify and Meta as the example, and the same order works on other platforms: get the browser side clean first, then add the server side, then make the two agree.

1. List the events that matter

Most ecommerce stores track the same standard events, named here the way Meta names them:

  • PageView: a page opens.
  • ViewContent: a shopper views a product.
  • Search: a shopper searches your store.
  • AddToCart: a product goes into the cart.
  • InitiateCheckout: checkout starts.
  • AddPaymentInfo: payment details are entered.
  • Purchase: an order is completed, with its value, currency and order ID.

Purchase matters most: it’s the event sales campaigns usually optimize for, and the one your reported ROAS is built on.

2. Set up the browser side

On Shopify, pixels belong in Settings → Customer events: app pixels that apps add for you, and custom pixels you add yourself. Both run in a sandbox, separate from your theme. For Meta, the usual route is Meta’s Facebook & Instagram app (a sales channel in your Shopify admin): you connect your Meta business, ad account and pixel (newer versions of Events Manager call it a dataset), and the app adds the Meta Pixel to your store. Its data-sharing setting decides what it sends, and Shopify describes three levels:

  • Standard: the Meta Pixel only, collecting browsing behavior.
  • Enhanced: the pixel plus the Conversions API, which sends the purchase event from Shopify’s servers to Meta’s, and shares customer details such as name, location, email and phone for matching.
  • Maximum: the same, plus Meta’s latest advertising technology.

Higher levels share more customer data, so make sure your privacy policy says so. Three rules keep the browser side clean:

  • One installation per pixel. A pixel added by an app and again in theme code, or by two apps, reports every event twice.
  • Track checkout through Customer events. Code pasted into your theme doesn’t run on Shopify’s checkout and thank-you pages; app pixels and custom pixels do.
  • Connect consent first. Shopify’s customer privacy settings decide when pixels run, so set up your cookie banner there, and accept it when you test.

On other platforms, add the pixel through the platform’s official integration or a tag manager, and fire Purchase on the order confirmation page with the order’s value, currency and ID.

3. Add the server side

Pick one way to send server events, and one sender per event:

  • Your platform’s own integration. On Shopify, that’s the Facebook & Instagram app at its Enhanced or Maximum level (see step 2).
  • A dedicated server-side app, such as PixlBridge for Meta: you install it, connect your ad account and pixel, and it sends events from its servers.
  • A custom build or a server-side tag manager, if you have developers: it needs an access token from Events Manager, event mapping, hashing, retries and hosting.

Whichever you choose, connect it to the same pixel as your browser events, and check that each event carries the right name, time, value and currency. Send customer details the way the platform asks: Meta wants email, phone, name and address normalized (lowercased and trimmed, for example) and SHA-256 hashed, while the browser IDs (fbp, fbc), IP address and user agent go unhashed. The Event Match Quality guide lists which details count most, and for the full walkthrough on Shopify, see how to set up the Conversions API on Shopify.

4. Make the two agree, then test

  • Match the IDs. Give the browser and server versions of each event the same name and event ID. Ready-made tools don’t always let you choose IDs, so check what each one sends; if two tools can’t share IDs for an event, let only one of them send it.
  • Walk through your store. In Events Manager, open Test events (and enter its test code in your server tool, if it takes one), then view a product, add to cart, start checkout and place a test order. Each event should arrive from the browser, the server or both. Remove the test code afterward: Meta asks for it to be used for testing only.
  • Check custom pixels. For a Shopify custom pixel, the Test button in Customer events opens your store with Shopify’s Pixel Helper, which shows the events the pixel receives.
  • Compare with your orders. Over the next few days, check Meta’s Purchase count and values against your Shopify orders, as described above.

Common tracking mistakes and how to fix them

Duplicate purchases

Two things cause most duplicates: the same event sent by two tools (a pixel installed twice, or two server senders, such as the Facebook & Instagram app at a Conversions API level plus a separate CAPI app), or browser and server events whose IDs or names don’t match.

Fix: check Settings → Customer events and your theme code for extra copies of the pixel, and decide which single tool sends each server event. The free Meta Pixel & CAPI checker shows how a store’s pixel was added, whether it’s added twice, and spots apps known to send server events. Remove an extra copy only after confirming the one you keep works.

Missing purchases or events

Events stop when a connection breaks: an expired login or access token, a permission removed from the ad account, an event switched off, failing webhooks, or a theme or app change that removed a pixel.

Fix: check the connection status and your tool’s delivery log or diagnostics, then place a test order. Re-test after any change to your theme, apps or checkout.

Wrong purchase values

If Meta’s purchase value differs from Shopify’s, the cause is usually currency, or how tax, shipping and discounts are counted. Refunds and cancellations don’t flow back into an event that was already sent.

Fix: compare a few orders with the events Meta received, and make sure every event sends the order’s currency.

Comparing the wrong numbers

Events Manager counts the events Meta received. Ads Manager reports the conversions Meta credits to your ads, using attribution windows, view-through credit (people who saw an ad but didn’t click) and modeled conversions (estimates where it can’t observe a sale). Neither will match Shopify’s order count exactly, and a gap alone doesn’t mean tracking is broken.

Fix: compare the same dates, time zone and currency, and use your Shopify orders as the record of what you actually sold.

How PixlBridge handles the server side

PixlBridge is a Shopify app that runs the server side of Meta tracking for your store. It sends your store’s events to Meta through the Conversions API from its servers, and reports your Meta ad results next to your Shopify sales: ad spend, purchases, purchase value and ROAS by campaign, ad set and ad, and blended ROAS (store sales ÷ Meta ad spend) on Home. It covers Meta only; for Google Ads, TikTok or analytics tools, use their own integrations.

Where the events come from

A Shopify web pixel (Shopify’s customer events) captures storefront activity, and Shopify’s order webhooks add the order and customer details. Page views become PageView; product and collection views, ViewContent; searches, Search; adds to cart, AddToCart; checkout steps, InitiateCheckout and AddPaymentInfo. The completed checkout and the paid order become one Purchase with full match keys. You can switch off any event type per store.

How events are sent

Email, phone, name, city, state, zip code and country are normalized and SHA-256 hashed before sending, and raw values aren’t stored. The click and browser IDs (fbc, fbp), IP address and user agent go as Meta expects. Every event has action_source: website, an event_source_url and an event_time within Meta’s 7-day limit.

Events reach Meta within seconds and purchases within about a minute, in batches of up to 1,000. Temporary failures are retried after 1, 2, 4 and 8 minutes; after the fifth attempt an event is marked failed with Meta’s message. If Meta refuses events because of the Facebook login (for example error #270, when the person who connected isn’t an admin of the ad account), PixlBridge holds them, retries daily, and the dashboard tells you how to fix it.

How it avoids double counting

Each event_id is built from Shopify’s own identifiers, so a browser pixel that sends Shopify’s event IDs isn’t double counted. One overlap is a decision: Meta’s Facebook & Instagram app also sends purchases server-side, with its own IDs, when its data sharing includes the Conversions API (Enhanced or Maximum). Let one of them send purchases: switch off Purchase in PixlBridge, or stop the app from sending them. PixlBridge shows this reminder next to the Purchase switch and in the store health notes.

How you check it

Send a test event from My store → More: a custom event named PixlBridgeTest, with no value, so it never counts as a purchase. To watch it arrive under Test events in Events Manager, paste Meta’s test code into PixlBridge first (My store → Advanced settings → Test & tools), and remove it afterward. The “Meta Pixel + Conversions API” panel and Recent activity show the events “Sent to Meta (CAPI)”, and store health shows event counts and the share of purchases carrying each match key.

Setup

Install PixlBridge from the Shopify App Store (your account is created automatically), connect Facebook & Instagram with Facebook Login for Business, choose your ad account and Meta Pixel, and send a test event. There’s no code and no theme editing. PixlBridge processes the data on your behalf, and personal details leave only as hashes. Its web pixel follows Shopify’s customer privacy settings; purchases built from Shopify’s order webhooks are sent server-side without that check, so make sure your privacy policy covers that sharing. See how PixlBridge sends Shopify sales to Meta; after a 14-day free trial with no card, plans start at $29 a month.

Summary: run both, count each sale once

Client-side tracking reports from the shopper’s browser. It’s quick to set up and sees the shopping session, but blockers, privacy features and closed tabs cut it short. Server-side tracking reports from your store’s server. It takes more setup, but it delivers orders the browser misses, with exact values and hashed customer details.

For a store running ads, use both: give each action one shared event ID, let only one tool send each event, make sure your privacy policy covers both paths, and check the counts against your orders. That keeps the events your ads learn from close to the sales your store actually made.

Frequently asked questions

What is the difference between client-side and server-side tracking?

Client-side tracking sends events from the visitor’s browser, through a script such as the Meta Pixel. Server-side tracking sends them from your store’s server to the platform’s API, such as the Meta Conversions API. The browser is best at browsing events; the server is best at orders and customer details.

Is client-side tracking the same as browser-side tracking?

Yes. Both names describe tracking code that runs in the visitor’s browser and sends events from there, and “pixel tracking” usually means the same thing.

Is server-side tracking more accurate than client-side tracking?

It can be more complete for purchases, because your store’s server can report orders that a blocked or closed browser never sends, with exact order values. Accuracy still depends on correct event mapping, deduplication and consent settings, and better tracking doesn’t guarantee a higher ROAS.

Do I still need the Meta Pixel if I use server-side tracking?

You don’t have to, since Meta can use server events on their own, but Meta recommends running both: the pixel adds real-time browser signals and the Conversions API delivers events the browser loses. If you run both, give them matching event IDs, or let only one of them send each event.

Can ad blockers stop server-side tracking?

A browser ad blocker can’t stop a request your server sends, so purchases from your store’s records still reach the platform. Browsing events that a setup collects in the browser can still be lost, and privacy law applies to server events just as it does to the pixel.

What is event deduplication?

It’s how an ad platform keeps one copy of an action reported twice, once by the browser and once by the server. Meta merges a browser event and a server event when they share the same event name and event ID within 48 hours.

Is server-side tracking exempt from privacy rules?

No. A cookie banner controls what runs in the shopper’s browser, but privacy laws and platform rules cover the data you share whichever route it takes. Your privacy policy should disclose server-side sharing, and some laws require consent for it.

Does server-side tracking need coding on Shopify?

Not if you use an app: Meta’s Facebook & Instagram app or a server-side app such as PixlBridge sets it up without code. A custom build needs a developer for API access, event mapping, hashing and hosting.

Start free today

Ready to put this guide to work?

Free plan forever, or a 14-day Growth trial with 5 AI ad images on signup. No credit card required.

  • No card required
  • Cancel anytime
  • 30-day money-back guarantee