- Browser pixels fire from the user's device — fully exposed to blocks by ITP, ATT, and ad-blockers
- Server-side CAPI fires from your server — invisible to browser-level restrictions
- Running both (pixel + CAPI) with deduplication gives the highest possible data coverage
- CAPI events carry higher-quality signals: hashed email, phone, and purchase value
- GotTracked's App Proxy makes pixel requests appear as first-party, defeating DNS blockers
If you've been running Shopify ads for more than a year, you've probably heard about "server-side tracking" as the solution to attribution loss. But what exactly is the difference between a browser pixel and a Conversions API (CAPI) setup — and does CAPI actually work better?
This article breaks down both approaches technically, compares their accuracy in real-world conditions, and explains why most merchants need both running together.
How Browser Pixels Work
The Meta Pixel, Google Tag, and TikTok Pixel are snippets of JavaScript code that run inside the visitor's browser. When a user visits your store and triggers an event (AddToCart, Purchase), the pixel's JavaScript collects data about that event and sends an HTTP request to the ad platform's servers.
What the browser pixel sends:
- The
fbclid(click ID) stored in the browser's cookie - The user's browser fingerprint and IP address
- Event data (value, currency, product ID)
- Hashed email/phone if the user is logged into your store
⚠️ The critical weakness: All of this data collection happens inside the browser. If the browser blocks the cookie, strips the click ID, or blocks the network request — none of this data reaches the ad platform.
How Server-Side CAPI Works
The Conversions API (CAPI) bypasses the browser entirely. Instead of JavaScript firing in the user's browser, your server sends conversion events directly to Meta's API using a server-to-server HTTP request.
What CAPI sends:
- The same event data (value, currency, product ID)
- Hashed customer PII from your Shopify order data (email, phone, name, zip)
- The preserved click ID (
fbclid) if it was cached server-side - Order ID for deduplication against browser pixel events
Because this request originates from your server, it is completely immune to browser-side blocking. No ad-blocker, ITP setting, or ATT opt-out can intercept a server-to-server API call.
Head-to-Head Comparison
| Criteria | Browser Pixel | Server-Side CAPI |
|---|---|---|
| Blocked by Safari ITP | Yes — cookies capped at 7 days | No — server-to-server |
| Blocked by iOS 14+ ATT | Partially — limits data available | No — uses first-party order data |
| Blocked by ad-blockers (uBlock, Brave) | Yes — network requests blocked | No — server request unblockable |
| Real-time event firing | Yes — fires immediately | Slight delay (webhook latency) |
| Event Match Quality (Meta EMQ) | 4–6 / 10 typical | 8–10 / 10 with hashed PII |
| Attribution accuracy | ~64% post-iOS 14 | ~99% with click ID caching |
| GDPR / CCPA compliance | Requires consent banner | SHA-256 hashing, no raw PII |
| Setup complexity | Simple JavaScript snippet | Requires server-side integration |
Why You Should Run Both (Not Just CAPI)
Despite CAPI's clear advantages, running CAPI alone creates a different problem: you lose real-time signals. CAPI events fire when Shopify's Order Webhook triggers — which can be seconds to minutes after the purchase. Browser pixels fire instantly, giving Meta's algorithm faster feedback.
The professional setup is a hybrid approach:
- Browser pixel fires immediately on every event (for real-time signals)
- CAPI fires from the server on purchase events (for accuracy and match rate)
- Deduplication is configured so Meta counts each purchase exactly once
The Click ID Problem (And How GotTracked Solves It)
The single hardest part of CAPI implementation for Shopify merchants is preserving the click ID. Meta's CAPI can only match a server event to an ad click if you send the original fbclid with the event.
GotTracked solves this with Cart Attributes Healing: when a visitor arrives from an ad, their fbclid, gclid, ttclid, and UTM parameters are immediately written to Shopify's server-side Cart Attributes — completely immune to browser cookie restrictions. These attributes persist for 30 days and survive across sessions and devices.
✅ The result: Even if a customer adds to cart today and completes the purchase 3 weeks later on a different device, GotTracked can still send a perfectly matched CAPI event with the original click attribution — something no browser pixel can do.
What This Means for Your ROAS
A 30% improvement in Event Match Quality (EMQ) means the algorithm is making decisions based on a much more accurate picture of your customer base. This translates to:
- Better audience targeting and lookalike quality
- More accurate cost-per-acquisition reporting
- Less budget wasted on audiences that don't convert
- Faster exit from the learning phase on new campaigns
Frequently Asked Questions
Can I use server-side CAPI without the browser pixel?
Yes, but it's not recommended. Browser pixels capture real-time signals (PageView, AddToCart) with precise timestamps that improve ad optimisation. CAPI alone can miss early-funnel events. Running both in parallel with deduplication gives the best results.
Does server-side CAPI require a developer?
Without a solution like GotTracked, yes — CAPI requires backend API integration, webhook handling, and hashing logic. GotTracked automates all of this as a Shopify app, requiring no code or developer involvement.
Can browser pixels and CAPI send duplicate events to Meta?
They can, which is why deduplication is critical. Meta matches events by event_id: if a browser pixel and a CAPI call share the same event_id, Meta counts it only once. GotTracked automatically generates and synchronises event IDs across both channels.
Is server-side tracking GDPR compliant?
Yes, when implemented correctly. GotTracked hashes all PII (email, phone number) using SHA-256 before sending to any ad platform, making the data irreversible and compliant with GDPR, CCPA, and Apple ATT framework requirements.
How much better is CAPI accuracy compared to browser pixels?
In typical Shopify setups, browser pixels achieve around 55–70% attribution accuracy post-iOS 14. Adding server-side CAPI raises this to 90–99%, recovering 30–50% of previously untracked conversions.
Start Recovering Your
Lost Attribution Today
GotTracked sets up in under 15 minutes and is free for the first 2,000 pioneer merchants.