Shopify

Server-side tracking for Shopify. No apps. No checkout restrictions. No signal loss.

Shopify merchants lose tracking data at every turn: checkout.shopify.com breaks cookies, theme apps bloat page load by seconds, and Shopify's new checkout extensibility model restricts third-party scripts. Datafly Signal replaces all of it with a single 5.2KB script and server-side webhooks.

Request a DemoView Platform

800KB+

Average tag payload

Typical Shopify store loads 800KB+ of third-party analytics JavaScript before the first meaningful paint.

40%+

Safari mobile users

Safari dominates mobile shopping. ITP caps client-side cookies at 7 days, fragmenting every returning visitor.

Broken

Checkout domain cookies

checkout.shopify.com is a different domain. Client-side cookies set on your storefront do not carry over.

15+

Apps per typical store

Each Shopify app injects its own JavaScript. 15 apps is typical for a mid-market store, each adding load time.

Why Shopify tracking is uniquely broken

Shopify's architecture creates tracking challenges that other platforms don't have. These are structural problems, not configuration issues.

Checkout domain breaks tracking

checkout.shopify.com is a separate domain. Client-side cookies from your storefront never reach checkout. Post-purchase attribution dies at the most critical moment.

App bloat kills performance

Each Shopify app injects its own scripts, stylesheets, and tracking pixels. 15 apps means seconds of extra load time, tanking Core Web Vitals and conversion rates.

Checkout extensibility limits

Shopify's new checkout model restricts third-party JavaScript execution. Analytics tags that worked in legacy checkout may stop working entirely as Shopify migrates merchants.

How Signal works with Shopify

A dual-track architecture that captures the complete customer journey — storefront browsing via Datafly.js and checkout completions via Shopify webhooks — then links them server-side.

Track 1: Storefront

Install Datafly.js as a single script via your Shopify theme or custom pixel. 5.2KB gzipped. Collects all storefront interactions.

  • page_view on every navigation
  • product_viewed on PDP load
  • add_to_cart from buy buttons
  • collection_viewed on listing pages
  • search on search interactions

Track 2: Webhooks

Shopify webhooks deliver checkout and order events directly to Signal server-to-server. No browser involved. No checkout domain problem.

  • orders/paid on purchase completion
  • checkouts/create on checkout start
  • refunds/create on order refund
  • orders/fulfilled on shipment
  • customers/create on registration

Cross-domain identity resolution. Signal's Identity Hub links storefront sessions to webhook events using customer email, enabling complete attribution from first page view to purchase — even across checkout.shopify.com. Zero reliance on Shopify apps for analytics.

End-to-end architecture

Two data sources, one processing pipeline, every vendor delivered server-to-server.

Storefront

Datafly.js

5.2KB gzipped

Checkout + Orders

Shopify Webhooks

Server-to-server

Datafly Signal

Identity resolution + Pipeline transformation + Delivery

GA4

Meta CAPI

TikTok

Google Ads

Pipeline as Code

One webhook, multiple destinations

This pipeline config transforms a Shopify orders/paid webhook into both a GA4 purchase event and a Meta CAPI Purchase event simultaneously. Identity is resolved server-side by linking the customer email from the webhook back to the storefront session.

  • Single webhook triggers multiple vendor deliveries
  • Customer email resolves to stored storefront session IDs
  • GA4 gets session_id and _ga cookie from identity link
  • Meta CAPI gets _fbp, _fbc, IP, and user agent from identity link
  • All PII automatically SHA-256 hashed for Meta
  • Line items mapped to vendor-specific product formats
shopify-order-paid.yamlYAML
# shopify-order-paid.yaml — Webhook to GA4 + Meta CAPI
name: shopify_order_paid
trigger:
  event: webhook
  conditions:
    - field: source
      operator: equals
      value: shopify
    - field: topic
      operator: equals
      value: orders/paid

pipelines:
  # GA4 Measurement Protocol — purchase event
  - integration: google-analytics-4
    transform:
      mapping:
        - source: id
          target: transaction_id
        - source: total_price
          target: value
        - source: currency
          target: currency
        - source: line_items
          target: items
          transform: array_map
          fields:
            - source: sku
              target: item_id
            - source: title
              target: item_name
            - source: price
              target: price
            - source: quantity
              target: quantity
      enrichments:
        - type: identity_link
          source: customer.email
          resolve: session_id
        - type: vendor_id
          vendor: ga4
          cookie: _ga
    output:
      format: ga4_measurement_protocol
      event_name: purchase
      validate: true

  # Meta Conversions API — Purchase event
  - integration: meta-conversions-api
    transform:
      static:
        - target: event_name
          value: Purchase
        - target: action_source
          value: website
      mapping:
        - source: total_price
          target: custom_data.value
        - source: currency
          target: custom_data.currency
        - source: line_items
          target: custom_data.content_ids
          transform: pluck
          field: sku
      user_data:
        - source: customer.email
          target: em
          transform: sha256_normalise
        - source: customer.phone
          target: ph
          transform: sha256_normalise
        - source: customer.first_name
          target: fn
          transform: sha256_normalise
        - source: customer.last_name
          target: ln
          transform: sha256_normalise
      enrichments:
        - type: identity_link
          source: customer.email
          resolve: [_fbp, _fbc, client_ip, user_agent]
    output:
      format: meta_conversions_api
      validate: true

What you can remove

Signal replaces the client-side JavaScript from all of these Shopify apps and services. One 5.2KB script instead of 625KB+ of third-party code.

Google Analytics app

80KB

Meta Pixel app

60KB

TikTok Pixel app

45KB

Google Ads conversion tag

50KB

Hotjar

120KB

Lucky Orange

90KB

Klaviyo tracking

50KB

Snapchat Pixel

35KB

Pinterest Tag

40KB

Triple Whale Pixel

55KB

Before

625KB+

10 separate scripts

After

5.2KB

One script, all vendors

Frequently asked questions

How does Datafly Signal handle Shopify's checkout restrictions?
Shopify Plus restricts custom JavaScript on checkout pages, which is why most analytics apps lose conversion data at the moment of conversion. Datafly Signal uses Shopify's native order/paid and customer/created webhooks, which fire server-side from Shopify's infrastructure to your gateway. Conversion events arrive reliably without depending on JavaScript executing in the customer's browser at checkout.
Does it work with Shopify's Web Pixel API?
Yes. Datafly.js is registered as a Web Pixel through the Shopify Customer Events API, which is the post-Shopify-Plus-checkout-changes path for first-party tracking. Events fire from the Shopify-managed sandbox to your collector. The same collector also handles non-Shopify pages on the storefront for unified tracking.
Can I deduplicate against existing Shopify analytics apps during migration?
Yes. The deterministic event_id pattern means you can run Datafly Signal alongside the Meta Pixel app, the Google & YouTube channel app, the TikTok app, etc. for as long as needed. Vendor APIs deduplicate on event_id, so parallel running gives you confidence in the server-side data before you remove apps. Most teams remove client-side apps one vendor at a time over a few weeks.
How much app bloat does this typically remove?
A typical mid-market Shopify Plus storefront runs 15-30 analytics, attribution, and pixel apps. Each adds initialization overhead, a script load, and often a vendor cookie. Removing them in favour of the Datafly Signal collector typically drops total Shopify-themed JavaScript from 800KB+ to under 100KB and improves Largest Contentful Paint by 1-3 seconds, depending on prior setup.
Does Datafly Signal handle Shopify's subscription and B2B flows?
Yes. Subscription renewals, B2B order events, gift card sales, draft orders, and POS orders all fire native Shopify webhooks that the gateway accepts. The blueprint mapping is the same as for standard checkout orders — the difference is which Shopify webhook source the event came from, which becomes a property on the event for downstream segmentation.

Related

Meta Conversions API

Replace the Meta Pixel Shopify app with server-side Meta CAPI delivery.

Google Ads

Replace the Google & YouTube Shopify channel with server-side Enhanced Conversions.

Page Performance

Removing 15+ Shopify analytics apps is one of the largest single page-weight wins available.

Commerce Media

For Shopify retailers running their own retail media network with brand partners.

Remove the tag bloat from your Shopify store

See how Datafly Signal replaces 15+ analytics apps with a single 5.2KB script and server-side webhooks. Faster pages, complete attribution, zero checkout restrictions.

Request a DemoView Platform