Trackless - cookieless analytika
Try it free

How to measure a Shopify store without own analytics cookies

Trackless is cookieless analytics for e-shops. It stores no measurement identifier or analytics cookies of its own in the visitor's browser. Because this connection runs through a browser pixel, assess the legal basis, cookie banner and whether the pixel should be gated by consent against the full site setup. On Shopify we use a custom pixel in Customer events because closed Shopify hosting cannot run a server-side module. The pixel measures traffic, purchase-funnel steps and completed orders. A checkout_completed order is stored as browser_unverified: it enters normal order, revenue and conversion analytics, but not billing or the pricing band. This connection does not yet include an official server-side app/webhook integration for server_verified orders. Your data stays on our EU server and the first 30 days are free.

What to expect on Shopify
  • Trackless stores no own analytics cookies or measurement identifier, but this connection runs a browser snippet or pixel. Assess the legal basis, cookie banner and whether the snippet should be gated by consent against the full site setup.
  • Blocking: the pixel runs in the browser - under aggressive blocking, some visits may be missed.
  • What it measures: visits, search, product views, cart, checkout and completed orders with their declared value, currency and number. Pixel orders are browser_unverified.
See the full connection overview → Video guide

How it works

  • The pixel runs in the browser, so under aggressive blocking of measurement scripts, some visits may be missed. In normal setups Trackless is not usually blocked; trends and source ratios remain meaningful.
  • One custom pixel. You add it once under Customer events. It measures traffic and the purchase funnel, and stores checkout_completed as a browser_unverified order. You never touch your theme code.
  • Your data stays yours. Measurement ends on our EU server; we do not share the data with advertising systems.

Step 1: Get your measurement token

Sign up at trackless.cz, log in and under My sites click Add site. Choose Shopify and Trackless will immediately show you the tracking token - a string that starts with tlc_. You will paste it into the pixel in a moment.

Step 2: Add a custom pixel to Shopify

In your Shopify admin open Settings → Customer events. At the top, switch from App pixels to Custom pixels, then click Add custom pixel. Name it e.g. "Trackless", paste this pixel into the code field as plain JavaScript (without a <script> tag), and replace VAS_MERICI_TOKEN with your token from step 1. Replace Shopify's starter code completely. Then click Save at the top and start the pixel with Connect:

var TRACKLESS_TOKEN = 'VAS_MERICI_TOKEN';
var TRACKLESS_ENDPOINT = 'https://trackless.cz/collect';
function num(x) {
    x = String(x == null ? '' : x).replace(/[^\d,.\-]/g, '');
    if (x.indexOf(',') > -1) { x = x.replace(/\./g, '').replace(',', '.'); }
    return Number(x) || 0;
}
function digits(x) { return String(x == null ? '' : x).replace(/\D/g, ''); }
function send(ctx, e) {
    try {
        var d = (ctx && ctx.document) || {}, loc = d.location || {}, nav = (ctx && ctx.navigator) || {};
        fetch(TRACKLESS_ENDPOINT, {
            method: 'POST',
            keepalive: true,
            headers: { 'Content-Type': 'text/plain' },
            body: JSON.stringify({
                v: 1, t: TRACKLESS_TOKEN,
                u: String(loc.href || '').slice(0, 2048),
                r: String(d.referrer || '').slice(0, 1024),
                l: String(nav.language || '').slice(0, 35),
                e: e || null
            })
        });
    } catch (err) { /* mereni nikdy nesmi shodit obchod */ }
}
analytics.subscribe('page_viewed', function (event) {
    try { send(event.context, null); } catch (err) { /* nikdy neshodit obchod */ }
});
analytics.subscribe('search_submitted', function (event) {
    try {
        var q = event.data && event.data.searchResult && event.data.searchResult.query;
        if (!q) { return; }
        send(event.context, { event_type: 'search', search_query: String(q).slice(0, 200), page_type: 'search' });
    } catch (err) { /* nikdy neshodit obchod */ }
});
analytics.subscribe('collection_viewed', function (event) {
    try {
        var col = (event.data && event.data.collection) || {};
        send(event.context, { event_type: 'view_category', id_object: digits(col.id), page_type: 'category' });
    } catch (err) { /* nikdy neshodit obchod */ }
});
analytics.subscribe('product_viewed', function (event) {
    try {
        var pv = (event.data && event.data.productVariant) || {}, pr = pv.product || {}, pc = pv.price || {};
        send(event.context, {
            event_type: 'view_item', id_object: digits(pr.id),
            value: num(pc.amount), currency: String(pc.currencyCode || '').toUpperCase(), page_type: 'product'
        });
    } catch (err) { /* nikdy neshodit obchod */ }
});
analytics.subscribe('product_added_to_cart', function (event) {
    try {
        var cl = (event.data && event.data.cartLine) || {}, m = cl.merchandise || {}, pr = m.product || {};
        var cost = (cl.cost && cl.cost.totalAmount) || m.price || {};
        send(event.context, {
            event_type: 'add_to_cart', id_object: digits(pr.id),
            quantity: Number(cl.quantity) || 1, value: num(cost.amount),
            currency: String(cost.currencyCode || '').toUpperCase()
        });
    } catch (err) { /* nikdy neshodit obchod */ }
});
analytics.subscribe('checkout_started', function (event) {
    try {
        var c = (event.data && event.data.checkout) || {}, tp = c.totalPrice || {};
        send(event.context, {
            event_type: 'begin_checkout', value: num(tp.amount),
            currency: String(tp.currencyCode || c.currencyCode || '').toUpperCase(), page_type: 'checkout'
        });
    } catch (err) { /* nikdy neshodit obchod */ }
});
analytics.subscribe('checkout_completed', function (event) {
    try {
        var c = (event.data && event.data.checkout) || {};
        var id = (c.order && c.order.id != null) ? digits(c.order.id) : '';
        if (!id) { return; }
        var tp = c.totalPrice || {};
        send(event.context, {
            event_type: 'order', page_type: 'order', id_object: id,
            value: num(tp.amount), currency: String(tp.currencyCode || c.currencyCode || 'CZK').toUpperCase()
        });
    } catch (err) { /* nikdy neshodit obchod */ }
});

The pixel settings have a Customer privacy section. Because Trackless stores no own analytics cookies or own measurement identifier in the browser, set the Permission option according to your legal assessment and the full store setup. In the same area also open Data sale and set it according to whether your store sells or shares data for advertising purposes. Trackless itself does not pass data to advertising systems; if your store does not sell data, set Data sale accordingly. The pixel deliberately avoids the old "additional scripts" and checkout.liquid, which Shopify is phasing out (by August 2026 for non-Plus plans) - so your measurement survives the upcoming checkout changes.

Step 3: Check that measurement is running

Open your store in a private browser window and browse a few pages. Within minutes the visit shows up in your dashboard at trackless.cz. Use a test order to verify that an order and revenue marked browser_unverified arrive. Shopify runs the custom pixel in its sandbox on both development and live stores, so the sandbox is not a reliable test-mode marker.

What you'll measure

  • The pixel runs in the browser, so under aggressive blocking of measurement scripts, some visits may be missed. In normal setups Trackless is not usually blocked; trends and source ratios remain meaningful.
  • Sources and channels: UTM parameters, referrers and Google Analytics 4-style channels - including visits from AI assistants.
  • Devices, browsers and operating systems.
  • Visitors' countries and languages.
  • Completed orders from checkout_completed, including the declared value, currency and order number. They appear in analytics as browser_unverified.
  • The path to purchase as a funnel: product view - add to cart - checkout - checkout_completed, plus what visitors searched for.

Limits, so you know what you're getting into

  • The pixel runs in the browser, so under aggressive blocking of measurement scripts, some visits may be missed. In normal setups Trackless is not usually blocked; trends and source ratios remain meaningful.
  • Shopify also runs the custom pixel in a sandbox on live stores. Trackless therefore accepts the known Shopify sandbox Origins and an Origin-less Shopify sandbox request, but this exception does not verify the order number or amount. The order is stored as browser_unverified, appears in normal analytics and is excluded from billing and the pricing band. server_verified revenue would require an official server-side app/webhook integration, which this connection does not currently have.
  • Also running a store on an open platform (PrestaShop, WooCommerce, Joomla / VirtueMart, OpenCart, Magento 2, Shopware 6 or Sylius)? Use our server-side modules there - they measure directly on the server, they do not depend on a browser snippet running, and depending on the platform can also handle orders, line items and margins.

Frequently asked questions

Do I need visitor consent or a cookie banner for Trackless?

There is no one-size-fits-all answer. Trackless stores no own measurement identifier or analytics cookies in the browser, but this connection runs a browser snippet or pixel. Assess the legal basis, cookie banner and whether the snippet should be gated by consent against the full site setup and the other tools you run.

Will the pixel slow my store down?

No. Shopify runs custom pixels separately in an isolated environment (a sandbox) managed by Shopify, not as code inserted into your store theme. And if measurement fails, the store keeps working as if the pixel weren't there.

Can I use Trackless together with Google Analytics 4 or Shopify analytics?

Yes. Trackless runs next to them and does not affect them. Expect different numbers: Trackless is less dependent on its own analytics cookies than client-side analytics, so it may record some visits that cookie-dependent tools count only partially or as modelled data when analytics cookies are rejected.

How much does Trackless cost?

The first 30 days are free. The pricing band is then based only on server-verified orders and revenue (server_verified); pixel orders (browser_unverified) do not increase it. See the pricing for exact figures.

Your site says "without JavaScript" - and this is a pixel in JavaScript. How does that add up?

Our server-side modules and plugins for open platforms (PrestaShop, WordPress/WooCommerce, Joomla / VirtueMart, OpenCart, Magento 2, Shopware 6 and Sylius) measure directly on the store server without our own measurement JavaScript. On this platform the available route is a browser snippet or pixel. It sends the page URL, referrer, language and events to the Trackless endpoint; it stores no own cookies or measurement identifier. Visitor identity is computed on the server from the request. This limits own identifiers in the browser, but the legal assessment and any consent gating depend on the deployment.

Try it on your own store

Signing up takes a minute, adding the pixel a few more. The first 30 days cost nothing.

Try 30 days free See the live demo

← Back to the home page