Skip to content
New5 AI ad images in every free trial

Shopify

What Is Server-Side Tracking? Shopify and Meta Conversions API Guide

What server-side tracking is and how it works on Shopify: web pixel plus order webhooks, Meta Conversions API, hashed match keys, event_id dedup and setup.

By PixlBridge Team

Updated 19 min read

On this page

Server-side tracking is how a Shopify store keeps reporting sales to Meta even when the shopper’s browser blocks the pixel. The Meta Pixel was built for a web where every browser ran every script. Today, ad blockers, browser privacy features and consent choices stop some of those browser reports, and Meta’s ads can only learn from the events that reach it.

This guide explains what server-side tracking is, how it works and how it compares with browser (client-side) tracking. Then it gets practical for Shopify and the Meta Conversions API (CAPI): which events to send, how deduplication and Event Match Quality work, how to set it up and check it, and how the PixlBridge Shopify app does it under the hood.

What is server-side tracking?

Server-side tracking sends website events, such as product views, checkouts and purchases, from a server to an ad or analytics platform, instead of relying only on a script in the visitor’s browser. For a Shopify store advertising on Facebook and Instagram, that means sending events to Meta through the Conversions API (CAPI), usually alongside the Meta Pixel.

The difference is who does the reporting. With the browser pixel, the shopper’s browser tells Meta “a purchase happened”. With server-side tracking, a server (yours, or your tracking app’s) tells Meta through an HTTPS call to graph.facebook.com/{pixel_id}/events, with the same event name plus customer details that help Meta match the event to a person. Orders come from the store’s own systems, so a blocked script or an expired cookie no longer decides whether Meta hears about a sale.

Why it matters: Meta uses the conversions it receives twice, to report which ads led to sales and to decide who sees your ads next. An event it never receives counts in neither. Server-side tracking can recover some of the events browsers miss, and it can attach order details the browser never had.

How server-side tracking works

Whatever the platform, the flow has the same five steps:

  1. The shopper acts. They view a product, add it to the cart, start checkout or place an order.
  2. The event is collected. A collector in the storefront records the action with browser identifiers, such as Meta’s _fbp and _fbc cookies, and the store’s backend reports the order itself. On Shopify, these are a web pixel and order webhooks.
  3. A server prepares it. The tracking server validates the data and merges the browser and order reports of the same action into one event. It normalizes the customer details (puts them in the exact format Meta expects), hashes them (turns them into codes that can’t be turned back into the original) and gives the event a stable event ID.
  4. The server delivers it. It sends the event to the platform’s API (for Meta, the Conversions API) and tries again if the platform is briefly unavailable.
  5. The platform uses it. Meta keeps one copy if the browser also sent the event with the same ID, matches the event to a person, and uses it for reporting and for optimizing your ad delivery.

The two sources fill each other’s gaps. The browser knows the visit: the page, the device and the ad click. The order knows the sale: the value, the currency, the products and the customer’s contact details. Combined into one event, they give Meta more to work with than either could alone.

Why browser tracking misses events

The Meta Pixel still does useful work, but a browser-only setup no longer sees every event. The main reasons:

  • Ad blockers and privacy extensions block requests to Meta’s domains, so the pixel never loads or never reports.
  • Browser tracking prevention, such as Safari’s Intelligent Tracking Prevention, shortens the life of cookies set by scripts, so _fbp and _fbc may be gone when a shopper comes back days later to buy.
  • iPhone privacy features. Link Tracking Protection removes click IDs such as fbclid from links opened in Mail, Messages and Safari Private Browsing.
  • Consent choices. Where your store asks for consent, a pixel shouldn’t run for visitors who decline, and server-side tracking doesn’t change that.
  • Everyday failures: slow mobile connections, tabs closed before the script loads, and in-app browsers that behave differently from a normal browser.

How much each cause costs you depends on your shoppers’ devices and browsers, so the figure that matters is your own: compare the purchases Meta receives from the browser with your Shopify orders for the same days. For the full picture, see why tracking pixels miss conversions and what to do about it.

Server-side vs client-side tracking

Client-side tracking collects and sends events from the visitor’s browser, usually through a pixel or tag. Server-side tracking sends them from a server. Neither is strictly better; they fail in different ways:

Client-side (browser)Server-side
Sent fromThe visitor’s browserA server: yours or your tracking app’s
Meta connectionMeta PixelConversions API
Can be stopped byAd blockers, tracking prevention, a page closed too earlyMisconfiguration or server errors, which show up in logs
IdentifiersCookies (_fbp, _fbc), IP address, user agentHashed email, phone, name and address, plus browser identifiers passed on by the store
Order detailsWhat the page showsThe full order from the store
ConsentMust follow your consent settingsMust follow them too

Accuracy, privacy and setup effort are covered in more depth in client-side vs server-side tracking compared.

Do you still need the Meta Pixel?

Can server-side tracking replace the Meta Pixel? It can, but you usually don’t want it to. Meta accepts events sent only from a server, so a store with no browser pixel still gets events Meta can use for reporting and optimization. Meta’s recommended setup, though, is redundant: keep the pixel and send the same events through the Conversions API, so each covers the other’s gaps.

Two details matter. Server-side doesn’t mean no browser code: on Shopify, a web pixel still runs in the storefront to collect the browser identifiers that help server events match, but it reports to the tracking server rather than straight to Meta. And when a browser pixel and a server both send the same event, Meta has to recognize them as one, which is what deduplication (below) is for. For a side-by-side look at the two connections, see Meta Pixel vs Conversions API.

Shopify server-side tracking: web pixels and order webhooks

Shopify gives apps two sources of events. A good setup uses both and combines them.

Web pixels: what happens in the storefront

Web pixels are small scripts that apps add through Shopify’s customer events system. They run in a sandbox Shopify controls, follow the store’s customer privacy settings, need no theme edits and work in Shopify’s checkout. A web pixel subscribes to Shopify’s standard customer events: page viewed, product viewed, collection viewed, search submitted, product added to cart, checkout started, payment info submitted and checkout completed. For server-side tracking, its job is to report each event to the app’s server with the details only the browser has, such as Meta’s cookies, the page URL and the user agent.

Order webhooks: what happens in Shopify’s backend

Webhooks are Shopify’s server-to-server notifications. When an order is created, paid or updated, or a checkout changes, Shopify posts the details to the app, signed so the app can check they really came from Shopify. Webhooks carry the authoritative commerce data: order value, currency, line items and order ID, plus the customer’s email, phone, name and address for apps Shopify has approved for protected customer data. They never touch the shopper’s browser, so an order is reported even when the browser blocked every script.

The app then merges the web pixel’s and the webhook’s reports of the same purchase into one event, with the order’s money and customer details and the browser’s identifiers, under one event ID. The PixlBridge section below shows one way to do it.

What is the Meta Conversions API?

The Meta Conversions API (CAPI) is Meta’s connection for sending website events, such as purchases, from a server directly to Meta. It’s the server half of Meta’s tracking; the Meta Pixel is the browser half. Both send to the same Meta Pixel in Events Manager, with the same standard events: PageView, ViewContent, Search, AddToCart, InitiateCheckout, AddPaymentInfo and Purchase.

Each server event is a small record. The fields that matter most:

  • event_name: the standard event, such as Purchase.
  • event_time: when it happened. Meta accepts events up to seven days old.
  • event_id: a unique ID for this action, used for deduplication.
  • action_source and event_source_url: where the event happened (website) and on which page.
  • user_data: customer information parameters. Email, phone, name and address are normalized and SHA-256 hashed; the fbp and fbc values, IP address and user agent are sent as they are.
  • custom_data: for commerce events, the value, currency and products (content_ids).

Shopify stores use CAPI to deliver the events browsers lose, to enrich purchases with details from the order, and to give Meta more conversions to learn from. It improves the data Meta receives; it doesn’t guarantee better results. Campaign performance still depends on your offer, creative, audience and landing pages.

Deduplication and event IDs

When the browser pixel and the server both report the same purchase, Meta receives two records of one sale. Deduplication is how Meta keeps only one. Meta treats a browser event and a server event as duplicates when they share the same event_name and the same event_id and arrive within 48 hours of each other.

An event ID is a unique identifier for one action, created once and sent by every channel that reports that action. Deduplication breaks in three common ways:

  • Different IDs. The pixel uses one ID and the server another, so Meta counts the purchase twice.
  • Different event names. A browser Purchase and a custom server event such as Order are never merged.
  • Two server senders. Two apps that both send purchases through CAPI, each with its own IDs, double count even without a browser pixel.

Double counting inflates the purchases Meta reports, and with them ROAS (return on ad spend), and Meta’s ad delivery learns from inflated numbers. If Events Manager shows more purchases than Shopify has orders for the same days, look for duplicates first.

How PixlBridge counts each sale once

PixlBridge builds its event IDs from Shopify’s own identifiers: Shopify’s event ID for browsing events and purchase:{checkout_token} for Purchase. Retries and the pixel-plus-webhook pair of the same purchase therefore never create a second event. A browser pixel is deduplicated against PixlBridge’s events only if it sends exactly those IDs; a pixel that sends its own IDs is not.

That leaves one overlap you must decide about: Meta’s own Facebook & Instagram app for Shopify. It sends purchases with its own IDs, from its browser pixel and, at its Enhanced or Maximum data-sharing level, through the Conversions API too, so running it alongside PixlBridge’s Purchase events can count purchases twice. Let one of them send purchases: switch off Purchase for the store in PixlBridge (My store → Advanced settings → What to report), or stop the app from sending them. PixlBridge shows this reminder next to the Purchase switch and in the store health notes.

To check deduplication in Events Manager, open an event: its overview shows the connection method each copy arrived through (browser or server) and how many were deduplicated.

Event Match Quality

Event Match Quality (EMQ) is Meta’s score from 0 to 10, shown per event in Events Manager, for how well the customer information on your events matches Meta accounts. A purchase only helps your ads if Meta can tell who made it, so EMQ affects both attribution and optimization.

Server-side tracking is what makes a good score possible. Browser events carry cookies, IP address and user agent; server events can add hashed email, phone, name and address from the order. That’s why a Purchase built from checkout data usually scores higher than a PageView, which carries browser identifiers only. The details must be normalized exactly as Meta specifies before hashing (an email, for example, is trimmed and lowercased), or they won’t match.

Treat EMQ as a diagnostic, not a target: don’t collect extra personal data just to raise it, and don’t expect a high score to rescue a weak campaign. How to raise Event Match Quality lists each parameter and what to fix first.

How to set up server-side tracking for Shopify

The route you choose decides how much you do by hand, but the steps are the same:

  1. List what already sends events. Check for a Meta Pixel in your theme, Meta’s Facebook & Instagram app and its data-sharing level, other tracking apps, and custom pixels under Settings → Customer events. Anything that already sends purchases to Meta needs a plan before you add another sender.
  2. Choose a route. Meta’s Facebook & Instagram app shares events server-side at its Enhanced and Maximum data-sharing levels. A dedicated app such as PixlBridge adds its own event handling, diagnostics and reporting. A custom build (your own server, Shopify webhooks and a Meta access token) gives full control, but needs development work and ongoing maintenance.
  3. Connect Shopify and Meta. Authorize the app, then choose the ad account and the Meta Pixel. Make sure it’s the pixel your campaigns optimize for: events sent to another pixel won’t help them.
  4. Choose the events. Purchase matters most, then InitiateCheckout, AddPaymentInfo, AddToCart and ViewContent. PageView and Search add context.
  5. Settle deduplication. Each event needs one sender, or shared event IDs across senders. Switch off overlapping purchase events before you go live.
  6. Test it. Send a test event with a test code from Events Manager, then follow a real order through to Meta (see verifying the setup, below).

With PixlBridge, connecting and testing need no code and no theme edits: install it from the Shopify App Store (your account is created automatically), connect Facebook & Instagram with Facebook Login for Business, choose the ad account and the Meta Pixel, and send a test event. For both routes in full, follow the step-by-step Conversions API setup for Shopify.

How PixlBridge does it

PixlBridge is a Shopify app that runs the server side for you: it collects your store’s events and sends them to Meta through the Conversions API. This is how its Meta Conversions API integration works under the hood.

Shopify to Meta Conversions API flowThe PixlBridge web pixel in the storefront and Shopify order webhooks both reach PixlBridge, where they are merged into one event keyed by checkout token, PII is hashed, and a single Purchase is sent to the Conversions API.Storefront web pixelevent_id · fbp · fbc · UAorders/paid webhookvalue · email · phone · addressPixlBridge mergeone row per purchase:{checkout_token}SHA-256 hashed match keysMeta Conversions API1 Purchase · deduplicated
  • Web pixel. When you connect a store, PixlBridge installs its app-owned web pixel. For each customer event it sends PixlBridge a small beacon with Shopify’s event ID, the _fbp and _fbc cookies when present, the page URL and the user agent.
  • Webhooks. PixlBridge subscribes to orders/create, orders/paid, orders/updated, checkouts/create and checkouts/update. It verifies Shopify’s HMAC signature on every delivery and processes each delivery at most once.
  • One row per purchase. A purchase seen by the pixel and delivered by the webhook is stored as one row, keyed by the store and the same purchase:{checkout_token} event ID used for deduplication. The webhook wins for money fields; the pixel fills in browser identifiers.
  • A short wait for checkouts. Checkout and purchase events wait about 30 seconds before sending, so whichever source arrives second can still enrich the event. Visits and other browsing events go out right away. One purchase in, one Purchase out.

Which events are sent

PixlBridge maps Shopify’s customer events to Meta’s standard events:

Shopify eventMeta eventNotes
page_viewedPageViewbrowser identifiers only
product_viewed, collection_viewedViewContentcontent_ids = variant IDs, value, currency
search_submittedSearchup to 20 content_ids
product_added_to_cartAddToCartvalue, currency, num_items
checkout_startedInitiateCheckoutenriched with hashed customer details from checkout webhooks
payment_info_submittedAddPaymentInfosame
checkout_completed + orders/paidPurchasemerged into one event; full match keys

Each event type can be switched off per store, and every event is sent as a website event (action_source: website) with the page it happened on.

Hashed match keys

Every event carries as many of Meta’s customer information parameters as the source data allows. Personal fields are normalized the way Meta’s specification requires and then SHA-256 hashed before they are stored:

  • em: email, lowercased and trimmed
  • ph: phone, digits only with country code (inferred from the address country when the number is national)
  • fn, ln, ct: first name, last name and city, lowercase letters only
  • st, zp, country: state code, postal code (US: first five digits), two-letter country code
  • external_id: a hash of the Shopify customer ID
  • fbc and fbp: the Meta click and browser identifiers, sent as they are, recovered from cookies, from the checkout’s note attributes, or from the fbclid on the order’s landing page
  • client_ip_address and client_user_agent: from the checkout’s browser details

PixlBridge never stores raw email addresses, phone numbers or names from your orders: the hashes are the only thing written to its database. Shopify includes customer fields in order webhooks only for apps it has approved for protected customer data; PixlBridge handles that, so there’s nothing for you to set up. Without those fields, purchases would still arrive and merge, with the email from the web pixel and fbc/fbp as their match keys.

Delivery, retries and health

PixlBridge checks every few seconds for events that are ready to send, with a once-a-minute run as a backup, and posts them to Meta in batches of up to 1,000. Visits reach Meta within seconds and sales within about a minute.

  • Temporary failures (rate limits, Meta server errors, network problems) are retried with a growing wait that starts at one minute and doubles each time. After five attempts the event is marked failed, with Meta’s message attached.
  • A permanent error in a batch is isolated to the event that caused it; the rest of the batch still goes through.
  • Login problems. If Meta refuses events because of the Facebook login that connected PixlBridge (for example error #270, when that person isn’t an admin of the ad account), PixlBridge holds the events, tries again once a day, and the dashboard explains how to fix it. Fixing the login ends the wait, and held events still count as long as they’re within Meta’s seven-day limit.

The store’s health view shows event counts by type and status for the last 24 hours and 7 days, how often your events carry each match key, and warnings such as pixel not firing or webhooks missing.

Verifying the setup in Events Manager

  1. In Events Manager, open your Meta Pixel, go to Test events and copy the test code (it looks like TEST12345).
  2. In PixlBridge, open My store and choose Send a test event (in the More menu). Tick “I’m checking in Meta’s Test Events”, paste the code and send. The event shows under Test events within a minute. It’s a test event, not a sale, so your sales numbers don’t change.
  3. After your next order (or a test order you place yourself), the Purchase event’s overview in Events Manager shows it arriving through the Server connection method. If a browser pixel sends the same event IDs, the deduplication details confirm the two were merged.
  4. In PixlBridge, Recent activity on My store lists each event with “Sent to Meta (CAPI)”, and the Meta Pixel + Conversions API panel shows what was received and sent, with the reason for any failure.
  5. Once orders have come in for a few days, check Event Match Quality for Purchase in Events Manager, and which match keys your events carry on PixlBridge’s My store page.
  6. If you saved a test code under Advanced settings → Test & tools to watch every event, remove it when you’re done. While it’s set, none of the store’s sales count as real in Meta.

Privacy and consent

Server-side tracking changes the route events take, not the rules about consent. Where your store asks visitors for consent, PixlBridge’s web pixel follows Shopify’s customer privacy settings and only runs for visitors who allow analytics and marketing. Purchases also arrive through Shopify’s order webhooks, so your privacy policy should disclose that hashed purchase data is shared with Meta for ad measurement.

Because the app handles customer data on your behalf, it implements Shopify’s mandatory compliance webhooks: customers/data_request, customers/redact and shop/redact. A customer erasure request removes that customer’s hashed identifiers; uninstalling the app clears the store’s access token immediately and its data after the retention period. You remain the data controller, and PixlBridge processes data on your instructions under the PixlBridge data processing addendum.

Best practices for reliable tracking

  • Re-test after every change. A theme update, a checkout change or a new app can stop events while the integration still looks connected.
  • Watch failures, not just the setup. Delivery logs and health warnings catch failed sends and missing webhooks before they cost you weeks of data.
  • Compare received events with Shopify orders. Over the same dates, purchase counts, values and currency should line up. Meta’s attributed results will differ from Shopify’s totals because attribution works differently, but the events Meta receives shouldn’t.
  • Keep one sender per event. Every new tracking app is a chance of a second purchase sender, so check for overlap whenever you add one.
  • Collect only what you need. Send the customer details your checkout already has, hashed, and nothing extra to chase a higher score.
  • Judge results on business numbers. Better tracking improves the data, not the margin. Read ROAS next to revenue, product costs, shipping, discounts and refunds.

Summary

Server-side tracking sends your store’s events to Meta from a server, so a sale no longer depends on a script surviving the shopper’s browser. On Shopify, the strongest setup combines a web pixel (browser identifiers) with order webhooks (the order and the customer’s details) into one event per action, sends it through the Meta Conversions API with a stable event ID, and makes sure each sale is counted once. From then on, it only needs regular checks.

PixlBridge does all of this for Shopify stores with no code, and also reports your Meta ad results and ROAS next to your Shopify sales. Try it free for 14 days with no card; after that, plans start at $29 a month.

Frequently asked questions

What is server-side tracking on Shopify?

It means your store’s events, such as add to carts, checkouts and purchases, reach Meta or another platform from a server instead of only from the shopper’s browser. On Shopify, an app usually combines a web pixel in the storefront with Shopify’s order webhooks and sends the result to Meta through the Conversions API.

Is server-side tracking better than the Meta Pixel?

Neither one replaces the other. The pixel captures browser signals as they happen, while server-side tracking delivers events browsers lose and adds details from the order. Meta recommends running both, with matching event IDs so each sale is counted once.

Does server-side tracking bypass ad blockers?

Partly. The step from the server to Meta isn’t a browser request, so ad blockers can’t stop it, and orders arrive from Shopify directly. The storefront part still runs in the browser, though, so browser identifiers can be missing for some visits.

Does server-side tracking get around cookie consent?

No. It changes how events travel, not what visitors agreed to. Your consent settings and privacy policy should cover server-side sharing just as they cover the pixel.

Will server-side tracking double count my purchases?

Not when it’s set up correctly. Meta keeps one copy of a browser event and a server event that share the same event name and event ID within 48 hours. Double counting happens when two tools send the same purchase with different IDs, such as a tracking app plus Meta’s Facebook & Instagram app.

Does server-side tracking improve ROAS?

It can give Meta more complete conversion data, which helps both reporting and ad delivery, but it doesn’t guarantee a higher ROAS. Results still depend on your offer, creative, audience and margins.

How do I know server-side tracking is working?

Send a test event with a test code from Meta Events Manager and watch it arrive under Test events. Then check that real purchases arrive through the Server connection method and that their count matches your Shopify orders.

Is server-side tracking hard to set up on Shopify?

Not with an app. Meta’s Facebook & Instagram app and dedicated apps such as PixlBridge need no code, while a custom build with your own server needs development work and ongoing maintenance.

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