Proxy the Admaxxer pixel through Nuxt route rules

Prefer no code changes? A managed first-party subdomain does the same job with one DNS record; the comparison below helps you choose.

Why route the pixel through your own domain

• Requests stay on your domain. The script and every event go to your own hostname, so blockers and DNS filters that work from lists of tracking hostnames have no admaxxer.com request to match.
• A simpler Content Security Policy. Both requests are same-origin, so 'self' already covers them. See CSP troubleshooting.
• Always the current pixel. You forward the script instead of copying it, so pixel updates reach your visitors with no re-install.

What it doesn't change

Visitors who opt out stay opted out, and tools that inspect scripts on your own pages can still interfere. A proxy also changes which network address Admaxxer sees — read what Admaxxer sees through your proxy before you switch.

Before you start

• A Nuxt 3 or later app built with its server (nuxt build). Route-rule proxies need that server; if you deploy a fully static site (nuxt generate), forward the paths at your host instead (see the Netlify, Vercel or NGINX guides).
• Your Admaxxer Website ID (it starts with admx_), from the pixel install page.

What your proxy must forward

With data-proxy-origin set, the pixel sends every request to that address instead of admaxxer.com. Forward each of these paths to the same path on https://admaxxer.com. A proxy that forwards only some of them silently loses data: custom events, purchases and identify calls each travel on a path of their own.

Pass requests through unchanged (same method, same JSON body), addressed to admaxxer.com in both the Host header and the TLS server name. Two browser headers must survive the trip:

• User-Agent. Requests without one are treated as bots and quietly discarded.
• Origin or Referer. Admaxxer only accepts events from your site's domains; with neither header, events are rejected with a 403.

Cookies aren't needed: the pixel sends its visitor and session IDs inside the request body.

Already using one of these paths?

The pixel appends these paths to whatever data-proxy-origin you give it, so you can keep everything under a folder. With data-proxy-origin="https://yourdomain.com/admx" and the script at /admx/pixel.js, the pixel calls /admx/api/event, /admx/api/event/batch and so on. Forward each one to the same path on admaxxer.com without the /admx prefix.

Step 1: Add the route rules and the snippet

In nuxt.config.ts, add the four proxy rules and load the pixel through app.head. Remove any other Admaxxer snippet from your app, and use your own Website ID and the exact hostname your pages load from:

nuxt.config.ts

export default defineNuxtConfig({
  routeRules: {
    "/pixel.js": { proxy: "https://admaxxer.com/pixel.js" },
    "/api/event": { proxy: "https://admaxxer.com/api/event" },
    "/api/event/batch": { proxy: "https://admaxxer.com/api/event/batch" },
    "/api/identify": { proxy: "https://admaxxer.com/api/identify" },
  },
  app: {
    head: {
      script: [
        {
          src: "https://yourdomain.com/pixel.js",
          async: true,
          "data-website-id": "admx_your_website_id",
          "data-proxy-origin": "https://yourdomain.com",
        },
      ],
    },
  },
});

• Each proxy rule forwards one exact path to the same path on Admaxxer, passing the browser's headers and body through.
• data-proxy-origin sends every event through those rules. Without it the script still loads from your domain, but events go straight to admaxxer.com.
• Keep exactly one Admaxxer snippet per page. If two load, only the first one runs.
• /pixel.js always serves the standard script. For another variant, such as script.plus.js for Pro tracking, proxy /js/script.plus.js instead and point src at it.

Outside Nuxt's head config, the equivalent plain HTML snippet is:

<script async
  src="https://yourdomain.com/pixel.js"
  data-website-id="admx_your_website_id"
  data-proxy-origin="https://yourdomain.com">
</script>

Step 2: Restart or redeploy

Restart nuxt dev after editing nuxt.config.ts, then build and deploy as usual. The rules apply wherever your Nuxt server runs.

Step 3: Check that it works

Run these from any terminal, replacing yourdomain.com with your site's hostname:

# 1. The script loads through your domain: expect HTTP 200 and a JavaScript content type
curl -sI https://yourdomain.com/pixel.js

# 2. Each endpoint reaches Admaxxer. An empty body is rejected on purpose,
#    so nothing is recorded; the error reply proves the route works.
curl -s -X POST https://yourdomain.com/api/event -H 'Content-Type: application/json' -d '{}'
#    expect: {"error":"validation_failed", ...}
curl -s -X POST https://yourdomain.com/api/event/batch -H 'Content-Type: application/json' -d '{}'
#    expect: {"error":"empty_batch"}
curl -s -X POST https://yourdomain.com/api/identify -H 'Content-Type: application/json' -d '{}'
#    expect: {"error":"validation_failed", ...}

Only Admaxxer answers with those error messages. If you get your own site's 404 page or HTML instead, that path isn't being forwarded.

Then load your site with the browser's developer tools open on the Network tab. The script and the api/event requests should go to your own domain (none to admaxxer.com), and accepted events are answered with 202. Finally, open the pixel install page: the Verify install card turns green once events arrive.

What Admaxxer sees through your proxy

Visitors and sessions are counted from the IDs the pixel sends, so those numbers don't change. What changes is the network address: Admaxxer uses the address of whatever connects to it, and through a self-run proxy that is your proxy, not your visitor. Forwarding headers such as X-Forwarded-For are not used for this.

• Country. Read from a country header when one arrives with the request (CF-IPCountry, X-Vercel-IP-Country or X-Real-Country, holding a two-letter country code). Otherwise it is looked up from the connecting address, which through a proxy is your proxy's location. Route-rule proxies pass incoming request headers along, so a CF-IPCountry or X-Vercel-IP-Country header added by your host should reach Admaxxer; check your dashboard's country breakdown after deploying.
• Rate limit. Each network address can send up to 100 requests every 10 seconds to a site. Through a proxy your visitors share your proxy's address, so a busy site can reach that limit at peak times; requests over it are rejected with 429 and those events are lost.
• Excluding your own traffic. IP-based exclusion rules can't match visitors through a proxy. To keep your own visits out, run admaxxer.optOut() in your browser's console on your site (see the consent API).
• Server-side purchase matching. When a purchase captured by the pixel is passed on to ad platforms, the shopper's network address is one of the match signals. Through a proxy it is your proxy's address, which can lower match quality.

Troubleshooting

• Your own 404 page or HTML instead of Admaxxer's reply. The forwarding rule isn't matching that path. Check the exact path and hostname, and that the rule sits ahead of any catch-all rule.
• 403 with origin_not_allowed. The Origin and Referer headers aren't reaching Admaxxer, or the page's domain isn't one of your site's domains in Admaxxer.
• Requests answer 204 but no pageviews appear. 204 means Admaxxer received the event and deliberately dropped it, most often because the User-Agent header was removed (requests without one are treated as bots). A 204 is also normal for the once-a-day install check and for visitors who opted out.
• 429 responses. Your combined traffic reached the per-address rate limit described in what Admaxxer sees.
• Every visitor shows the same country. No country header is reaching Admaxxer; see what Admaxxer sees.
• Works with nuxt dev but not in production. Check that production runs the Nuxt server output rather than a static nuxt generate build.

Self-run proxy or managed subdomain?

Admaxxer can also serve the pixel from a subdomain of yours with no proxy to run: in Integrations, open First-party tracking domain, add a subdomain such as t.yourdomain.com and create the one DNS record it shows. Both options load the pixel and send events from your own domain.

Choose a self-run proxy when you can't add DNS records, don't want a separate tracking subdomain, or need every request to pass through infrastructure you control. Otherwise the managed subdomain is less to maintain; see the first-party tracking domain guide.

Undo the setup

Put the standard snippet back first (copy it from the pixel install page), then remove the four routeRules entries and redeploy. In that order, no page ever points at a path that has stopped working.

Same setup on another platform: Cloudflare Workers · NGINX · Apache · Vercel · Next.js · Netlify · WordPress

Frequently asked questions

Related guides

• First-party tracking domain — The managed alternative: one DNS record, nothing to run yourself.
• Proxy through Next.js — Four rewrites in next.config.
• Proxy through Netlify — Four proxy rules in _redirects.
• Proxy through Vercel — Four rewrites in vercel.json.
• Install the pixel — Script variants, cookieless mode and the standard snippet.