Reducing the impact of ad blockers on Snowplow tracking

Last updated: November 19, 2026

Why ad blockers stop some of your events

Ad blockers, privacy browsers and DNS filters stop browser requests that match public filter lists, and Snowplow tracking is on those lists. A blocked request never reaches your collector, so the pipeline has no record of it: no failed event, no error and no alert. The only symptom is lower volume than another source of truth, such as your backend database or your server-side events.

Two separate requests can be blocked on a web page:

  • Loading the tracker script. If sp.js (or the tag manager that loads it) is blocked, no events are tracked at all for that visitor.

  • Sending events to the collector. If the collector hostname or request path is blocked, the tracker runs but every request it sends is dropped.

No setup reaches 100% coverage, and the filter lists are updated continuously. The practices in this article reduce how much data you lose, make the losses measurable, and move your most important events to a channel that ad blockers cannot see.

These practices are about reliable first-party collection. They do not replace consent: keep honoring your users' consent and privacy choices through your consent management setup.

How blockers decide what to block

Blockers compare each request against filter lists. What they can match depends on where they run, which is why one fix does not cover every blocker.

Blocker type

Common examples

What it can match

What reduces blocking

Browser extensions

uBlock Origin, Adblock Plus with "Block additional tracking" enabled, AdGuard

Full URL: hostname, path and file name

Neutral first-party hostname, custom POST path, self-hosted and renamed tracker script

Privacy features built into browsers

Brave Shields, Microsoft Edge Tracking Prevention set to Strict

Mostly hostnames and URL patterns from similar lists

Same as extensions, plus first-party hosting

DNS filters

Pi-hole, NextDNS, AdGuard DNS, corporate and router filters

Hostname only, because the path is never visible to DNS

A hostname that is not listed. Path changes have no effect

Browser extensions only affect websites. DNS filters apply to every app on the device or network, so they can also block native mobile apps and server-to-server calls made from inside a filtered network.

What the major lists match today

We reviewed the public lists most often used by these tools (EasyPrivacy, EasyList, HaGeZi Pro, Peter Lowe's list and StevenBlack hosts) in November 2026. These patterns are blocked:

Pattern

Example of a blocked URL

Lists

Snowplow-hosted default endpoints on snplow.net, including Snowplow Mini

https://<pipeline>.collector.snplow.net/...

EasyPrivacy (third-party requests), HaGeZi Pro

The default POST path, on any hostname

https://c.yoursite.com/com.snowplowanalytics.snowplow/tp2

EasyPrivacy

The tracker served from a public CDN

https://cdn.jsdelivr.net/npm/@snowplow/...

EasyPrivacy

Tracker file names and folders that say "snowplow" or sp.js on common CDNs

/snowplow.js, /snowplow/sp.js, cloudfront.net/.../sp.js

EasyPrivacy

Hostnames containing "snowplow" or generic collection words

snowplow-collector.yoursite.com, events-collector.yoursite.com, datacollector.yoursite.com/.../event

EasyPrivacy, HaGeZi Pro

Individual first-party collector hostnames, once list maintainers notice them

Short names such as c., e. or t. on a company domain have been added

EasyPrivacy, HaGeZi Pro

Two behaviors matter when you plan a fix:

  • Hostname rules block every path. When a list adds your collector hostname, changing the POST path does not help. You need a new hostname.

  • Lists react to changes. New hostnames and paths can be picked up within days or weeks of going live. Treat these practices as ongoing hygiene, and move critical events server-side so they do not depend on the browser at all.

Best practices to reduce blocking

The practices are ordered by impact. Practices 1 to 4 harden the web tracker, practice 5 moves your most important events out of reach of browser blockers, and practice 6 helps you rule out other causes of missing events.

1. Send web events to a first-party custom collector domain

Never send production web traffic to your default *.collector.snplow.net endpoint. The whole snplow.net domain is listed, so every request to it is blocked for visitors who use these tools.

Set up first-party tracking so your collector is a subdomain of your main site, for example x7.yoursite.com for yoursite.com. This also gives you first-party cookies. Pair it with the Cookie Lifetime Extension service for Safari.

A few related points:

  • Use the DNS records Snowplow provides for the custom domain. Avoid a CNAME from your hostname to the default snplow.net endpoint, because some blockers can follow the CNAME and match the listed target.

  • Snowplow Mini endpoints are also on snplow.net. Expect them to be blocked in browsers with blockers enabled, including your own during testing (see Troubleshooting net::ERR_BLOCKED_BY_CLIENT).

  • Native mobile apps are not affected by browser extensions, so this change is most urgent for web.

2. Choose a neutral hostname on your main domain

The first-party tracking guide recommends avoiding words such as "track", "collect" and "analytics". In practice, also avoid:

  • snowplow, sp, spm, collector, events, telemetry, pixel, data, datacollector, metrics

  • A separate domain registered only for tracking. Some lists block a whole registrable domain, which takes every subdomain with it. A subdomain of the domain your site already runs on is harder to block without breaking the site.

  • Hostnames that describe the purpose. Two or three random characters, such as x7 or qk3, carry no signal.

If your current hostname is already listed, plan a move to a new one. The "Check whether you are blocked and measure the impact" section below explains how to check.

3. Use a custom POST path

The default path /com.snowplowanalytics.snowplow/tp2 is blocked on any hostname. Replace it with a two-segment path made of random characters, such as /k8vq2r/m4z. Avoid your company name, reverse-domain names like /com.yourcompany/..., and the strings tp2, track, collect or event.

Roll it out in this order so no events are lost:

  1. Ask Snowplow Support to add the new path to your Collector configuration. You'll see it under Pipeline Configuration > Tracker request paths in Console once it's live.

  2. Update every web tracker to use it, including tags in your tag manager:

window.snowplow('newTracker', 'sp', 'https://x7.yoursite.com', {
  appId: 'my-web-app',
  postPath: '/k8vq2r/m4z',  // must be live on the Collector first
});
  1. Keep the old path enabled for a few weeks. Cached pages and events queued in visitors' browsers still use it.

The Collector returns 200 OK for any path, so a typo in postPath does not show up as an HTTP error. Check that events arrive as good events after the change. More detail is in Custom POST path.

4. Serve the tracker from your own domain under a neutral name

If the script never loads, nothing else matters.

  • Do not load the tracker from a public CDN in production. cdn.jsdelivr.net/npm/@snowplow/ is blocked by EasyPrivacy. Snowplow's CDN hosting page recommends self-hosting for production.

  • Self-host sp.js under a random file name on a path of your own site, for example https://www.yoursite.com/assets/a8f3k2q1.js. Follow Host the JavaScript tracker. Avoid folder or file names containing snowplow or sp.js.

  • For single-page apps, bundle the tracker with npm. The tracker code then ships inside your own application bundle. The ad blocker guidance calls this the more resilient option.

  • Optionally create a white-label build that renames the global GlobalSnowplowNamespace object.

  • Be careful with tag managers. Some blockers block the tag manager script itself, and then no tag inside it fires. Load the tracker directly in your page code for pages where data completeness matters most.

  • Keep the name stable but rotate when needed. Blockers can also match script content, so a rename lowers the risk without removing it.

5. Track business-critical events server-side

Server-side tracking is the strongest protection, because the request goes from your server to the collector and never passes through the visitor's browser. The ad blocker guidance ranks it as the strongest option.

Good candidates are events your business already records on the server: sign-ups, purchases, subscription changes, job or order completions. A common pattern:

  1. Keep the web tracker for behavioral events such as page views, clicks and engagement.

  2. Send the critical outcome event from your backend with one of the server-side trackers (Node.js, Python, Java, Ruby, Go and others).

  3. Attach identifiers you already have, such as your user ID and the visitor's first-party cookie values, so you can join server-side and web events in your models.

Server-side requests that leave a network protected by a DNS filter can still be blocked if your collector hostname is listed, so use the same neutral hostname for backend traffic.

6. Rule out look-alike causes

Some event loss looks like ad blocking but is not:

  • Events fired right before a page navigation. If your code tracks an event and then immediately redirects, the request can be cancelled. Enable the keepalive option, or delay the navigation until the tracker has queued the event.

  • Schema validation failures. After a release, events with an outdated or mismatched schema version go to failed events instead of your warehouse. These do show up in Console, so check failed events before assuming blocking.

  • Proxies and firewalls in front of the collector. A WAF, CDN or reverse proxy you manage can drop or rewrite requests before they reach Snowplow.

Check whether you are blocked and measure the impact

Test in real browsers

Test your production pages in a small matrix of browsers and blockers, with default settings unless noted:

Setup

Why it matters

Chrome with uBlock Origin Lite

Widely used extension that applies EasyPrivacy

Chrome with Adblock Plus, "Block additional tracking" enabled

This setting turns on EasyPrivacy

Firefox with uBlock Origin

Full uBlock Origin feature set, including CNAME inspection

Brave with Shields on Standard and on Aggressive

Blocking is built into the browser

Microsoft Edge with Tracking Prevention on Strict

Blocks known tracking endpoints

Any browser on a network using a DNS filter with HaGeZi Pro, such as NextDNS or AdGuard DNS

Shows hostname-level blocking that path changes cannot fix

For each setup:

  1. Open DevTools > Network and filter by your collector hostname and your tracker file name.

  2. Load a page and trigger a few events.

  3. Look for requests that fail with net::ERR_BLOCKED_BY_CLIENT (browser blocking) or ERR_NAME_NOT_RESOLVED (DNS blocking). A request that never appears usually means the tracker script itself was blocked.

  4. In uBlock Origin, open the logger to see the exact filter rule that matched. The rule tells you whether the hostname, the path or the script is the problem.

The Snowplow Inspector browser extension also shows which events the tracker tried to send, which helps separate "never sent" from "sent and blocked".

Check the filter lists directly

Search the public lists for your collector hostname, your registrable domain, your POST path and your tracker file name. Rules look like ||x7.yoursite.com^ for a hostname or /k8vq2r/ for a path. The EasyList repository and the HaGeZi repository are searchable on GitHub.

Snowplow Support can also check your collector domains and POST paths against the major lists. Open a ticket and include every domain your trackers send to.

Measure how much you lose

Blocked events leave no trace in the pipeline, so measure the gap against a source the browser cannot block:

  • Server-side vs web events. Compare counts of an outcome you track on both sides, such as orders or sign-ups, per day.

  • Users seen only server-side. If you send server-side events with a user ID, count users who have server-side events but no web events in the same period. A high share points to the tracker script being blocked.

  • Backend records vs events. Compare a table in your own database, such as completed orders, with the matching Snowplow events.

This query is an example of the second check, written for Snowflake. It assumes your backend tracker sends platform = 'srv' and your web tracker platform = 'web'; adjust the filters and table name to your setup:

WITH by_user AS (
  SELECT
    user_id,
    MAX(CASE WHEN platform = 'srv' THEN 1 ELSE 0 END) AS has_server,
    MAX(CASE WHEN platform = 'web' THEN 1 ELSE 0 END) AS has_web
  FROM atomic.events
  WHERE collector_tstamp >= CURRENT_DATE - 7
    AND user_id IS NOT NULL
  GROUP BY user_id
)
SELECT
  COUNT_IF(has_server = 1 AND has_web = 0) AS server_only_users,
  COUNT_IF(has_server = 1) AS server_users,
  ROUND(100 * server_only_users / NULLIF(server_users, 0), 1) AS pct_server_only
FROM by_user;

Run the same check before and after each change from the best practices above, so you can see what each one recovered. Expect a residual gap: some visitors block all scripts, and some browsers block first-party tracking by default.

Lessons from customer investigations

A first-party setup that still lost about a quarter of one event

A software company compared a key front-end event against its own database and found 24 to 30% of the events missing in Snowplow. They had already done the usual work: a first-party collector domain, a custom POST path, and a relaxed firewall in front of the collector. Server-side events for the same users arrived in full.

The investigation found three causes, none of them in the pipeline:

  1. The tracker script was loaded from a public CDN (cdn.jsdelivr.net/npm/@snowplow/...), which EasyPrivacy blocks. uBlock Origin blocked it in testing. About half of the affected users had server-side events and no web events at all, which matches a blocked script.

  2. The event fired immediately before a page redirect, so the browser cancelled the request.

  3. After the fix was deployed, a schema version mismatch sent the events to failed events until the tracking code and schema were aligned.

The takeaways: harden the script as well as the collector, use keepalive or wait before navigating, and validate new tracking in a test environment before release.

Patterns we see across customers

  • Collector hostnames such as sp., collector., analytics., telemetry., events-collector. and names containing snowplow are added to lists most often.

  • When a hostname is listed, lists usually block it outright, so every POST path on it is blocked too. A new path alone did not help these customers; a new hostname did.

  • New paths and hostnames have been picked up by EasyPrivacy and HaGeZi within days to weeks of going live. Customers with steady data put their key outcome events on server-side tracking.

  • Ad blockers can block a tag manager's own script, which stops every tag it would have loaded.

Frequently asked questions

Can we reach 100% of visitors?

No. Some visitors block all scripts or use browsers that block tracking by default. These practices narrow the gap; server-side tracking closes it for the events you send from your backend.

Do blocked events show up as failed events?

No. A blocked request never reaches the collector, so nothing is recorded. Failed events only contain requests that arrived and then failed validation or enrichment.

Are mobile apps affected?

Not by browser extensions. DNS filters on a device or network can still block a listed hostname for mobile apps, so use the same neutral collector hostname there.

Does changing the POST path or hostname cause downtime?

No, if you roll it out in order. Snowplow Support enables the new path or domain first, you then update your trackers, and the old one stays enabled until traffic to it stops.

Is this a way around user consent?

No. These practices make sure first-party data you are allowed to collect actually arrives. Keep applying your consent rules in your trackers and consent management platform.

Who can help us check our setup?

Snowplow Support. Open a ticket with your collector domains, POST paths, how you load the tracker script, and any comparison numbers you have. We'll review them against the current lists and recommend changes.

Sources