Shopify geeft je geen logbestanden. Hier is een complete technische handleiding om ze te verkrijgen met Cloudflare (of elke Edge CDN).

Een grote blinde vlek in e-commerce is eindelijk opgelost

Sinds de dag dat Shopify werd gelanceerd, heeft het platform ruwe serverlogboeken volledig buiten bereik van winkeleigenaren gehouden. Je krijgt conversietrechters en verkooprapportages. Wat je niet krijgt is het enige dat je echt vertelt wat je server raakt: het HTTP-verzoeklogboek.

Jarenlang was dit een klein ongemak. Wie maalt er om ruwe logbestanden als je paginaweergaven en conversiepercentages hebt? Google Analytics volgt je menselijke bezoekers. Je advertentieplatform volgt je campagnes. Het leven is goed.

Toen kwam AI.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - ze sturen allemaal nu bots naar je winkel. Sommige crawlen je pagina’s om trainingsdata op te bouwen. Andere halen je productinhoud in realtime op om de vraag van een klant te beantwoorden. En het vervelende? Traditionele analysetools zoals Google Analytics kunnen hier niets van zien. Ze zijn afhankelijk van client-side JavaScript die bots nooit uitvoeren. Het grootste deel van de AI-interactie met je winkel is onzichtbaar voor je.

Dit is de nieuwe blinde vlek in e-commerce. AI-bots voeren je trackingscripts niet uit. Ze accepteren geen cookies. Ze verschijnen niet in je GA4-rapporten. Maar ze lezen absoluut je productpagina’s, nemen je beschrijvingen op in AI-gegenereerde antwoorden en bepalen mede of klanten je merk ooit ontdekken.

Nieuwe tools gericht op “agent analytics” komen op om site-eigenaren te helpen AI-crawleractiviteit en AI-gegenereerde verwijzingen te begrijpen via server-side tracking, botclassificatie en IP-verificatie. De industrie erkent dat het oude client-side analysemodel fundamenteel niet werkt voor het tijdperk van AI-first contentontdekking. Daarom hebben we het WISLR AI Visibility Dashboard gebouwd - om merken een duidelijk beeld te geven van hoe AI-platforms met hun content omgaan, van crawlfrequenties tot fetch-verzoeken tot AI-gestuurd verwijzingsverkeer.

Maar als je op Shopify zit, heb je een uniek probleem: je hebt geen controle over de server. Je kunt geen server-side tracking rechtstreeks installeren. Je kunt je toegangslogboeken niet bekijken. Je kunt niet zoeken naar GPTBot. De infrastructuur van Shopify is een black box, en ze hebben geen haast getoond om deze te openen.

Dat is nu voorbij. Hier lees je hoe je je logboeken terugkrijgt.

Deze handleiding leidt je door het bouwen van je eigen complete request logging pipeline voor een Shopify-winkel met Cloudflare. Elk HTTP-verzoek. Volledige geolocatiegegevens. Prestatiemetrieken. En het allerbelangrijkste: volledige botdetectie en -classificatie, zodat je eindelijk precies kunt zien welke AI-systemen je winkel bezoeken, hoe vaak, en welke pagina’s ze interesseren.

Hoe werkt Cloudflare request logging voor Shopify?

 Bezoeker vraagt je Shopify-winkel aan
         │
         ▼
 Cloudflare CDN (je domein geproxied via Cloudflare)
         │
         ▼
 Cloudflare Worker (draait bij elk verzoek)
    ├──→ Stuurt verzoek door naar Shopify origin (bezoeker krijgt normaal antwoord)
    └──→ POST een JSON-logvermelding naar je log-ontvanger (non-blocking, via ctx.waitUntil)
              │
              ▼
         Cloudflare Tunnel
         (CNAME op je domein → tunnel → localhost op je server)
              │
              ▼
         Node.js HTTP-ontvanger (localhost:9090)
              │
              ▼
         JSON-logbestanden geschreven naar schijf

Er worden geen poorten publiek geopend. De Cloudflare Tunnel regelt het veilige transport van Cloudflare’s edge naar je server via een alleen-uitgaande verbinding.

Wat heb je nodig om Shopify request logging in te stellen?

• Een Shopify-winkel met een aangepast domein dat via Cloudflare wordt geproxied (oranje wolk ingeschakeld)
• Een server om logboeken te ontvangen
• Node.js geinstalleerd op de server
• Een Cloudflare-account met Workers ingeschakeld
• Wrangler CLI geinstalleerd (npm install -g wrangler)
• Cloudflared geinstalleerd op de server

Stap 1: Maak de Cloudflare Worker aan

De Worker onderschept elk verzoek op je domein, stuurt het door naar Shopify en verstuurt asynchroon een logvermelding naar je ontvanger.

1a. Worker-broncode (cloudflare-worker.js)

/**
 * Shopify Request Logger
 *
 * Cloudflare Worker that:
 * 1. Logs ALL requests to a self-hosted log receiver (via Cloudflare Tunnel)
 * 2. Optionally logs detailed bot request data to a database
 */

// ============================================
// CONFIG - update these for your setup
// ============================================
const INGEST_URL = 'https://log-collector.yourdomain.com/collect';  // Your tunnel hostname
const INGEST_API_KEY = process.env.INGEST_API_KEY || '';          // Set as Worker secret

// ============================================
// BOT DETECTION PATTERNS
// ============================================
const BOT_PATTERNS = {
  // AI realtime fetchers (user-triggered queries)
  'ChatGPT-User':    { pattern: /ChatGPT-User/i,    type: 'realtime' },
  'Perplexity-User': { pattern: /Perplexity-User/i,  type: 'realtime' },
  // Add your own patterns here for other AI bots

  // Search engine crawlers
  'Googlebot':       { pattern: /Googlebot/i,        type: 'crawler' },
  'Bingbot':         { pattern: /bingbot/i,          type: 'crawler' },

  // Social link preview bots
  'FacebookBot':     { pattern: /facebookexternalhit/i, type: 'preview' },
  'LinkedInBot':     { pattern: /LinkedInBot/i,      type: 'preview' },
};

function identifyBot(userAgent) {
  if (!userAgent) return { name: 'unknown', type: 'unknown' };
  for (const [name, config] of Object.entries(BOT_PATTERNS)) {
    if (config.pattern.test(userAgent)) return { name, type: config.type };
  }
  return { name: 'other', type: 'unknown' };
}

function isKnownBot(userAgent) {
  if (!userAgent) return false;
  return Object.values(BOT_PATTERNS).some(config => config.pattern.test(userAgent));
}

async function logToReceiver(request, env, perfData = {}) {
  const url = new URL(request.url);
  const cf = request.cf || {};
  const bot = identifyBot(request.headers.get('user-agent') || '');

  const logEntry = {
    // Request basics
    timestamp:        new Date().toISOString(),
    method:           request.method,
    url:              request.url,
    path:             url.pathname,
    host:             url.hostname,
    userAgent:        request.headers.get('user-agent') || '',
    ip:               request.headers.get('cf-connecting-ip') || '',
    referer:          request.headers.get('referer') || '',
    cfRay:            request.headers.get('cf-ray') || '',

    // Bot classification
    botName:          bot.name,
    botType:          bot.type,

    // Cloudflare geo data
    country:          cf.country || '',
    region:           cf.region || '',
    city:             cf.city || '',
    postalCode:       cf.postalCode || '',
    latitude:         cf.latitude || '',
    longitude:        cf.longitude || '',
    timezone:         cf.timezone || '',
    continent:        cf.continent || '',

    // Network info
    asn:              cf.asn || '',
    asOrganization:   cf.asOrganization || '',
    colo:             cf.colo || '',
    httpProtocol:     cf.httpProtocol || '',
    tlsVersion:       cf.tlsVersion || '',

    // Client hints (helps detect headless browsers)
    secChUa:          request.headers.get('sec-ch-ua') || '',
    secChUaMobile:    request.headers.get('sec-ch-ua-mobile') || '',
    secChUaPlatform:  request.headers.get('sec-ch-ua-platform') || '',

    // Fetch metadata (helps detect programmatic requests)
    secFetchDest:     request.headers.get('sec-fetch-dest') || '',
    secFetchMode:     request.headers.get('sec-fetch-mode') || '',
    secFetchSite:     request.headers.get('sec-fetch-site') || '',

    // Performance metrics
    edgeStartTimestamp:       perfData.startTime || '',
    edgeEndTimestamp:         perfData.endTime || '',
    edgeTimeToFirstByteMs:   perfData.ttfbMs ?? '',
    clientTcpRttMs:          cf.clientTcpRtt ?? '',
    cacheCacheStatus:        perfData.cacheStatus || '',
    originResponseStatus:    perfData.responseStatus ?? '',
  };

  try {
    await fetch(INGEST_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': env.INGEST_API_KEY,
      },
      body: JSON.stringify({ logs: [logEntry] }),
    });
  } catch (e) {
    console.error(`Log ingest failed: ${e.message}`);
  }
}

export default {
  async fetch(request, env, ctx) {
    const startTime = Date.now();
    const url = new URL(request.url);

    // Avoid infinite loop - skip logging for your ingest hostname
    if (url.hostname === 'log-collector.yourdomain.com') {
      return fetch(request);
    }

    // Fetch the origin response (Shopify)
    const response = await fetch(request);
    const endTime = Date.now();

    // Ship log entry asynchronously (does not delay the response)
    ctx.waitUntil(logToReceiver(request, env, {
      startTime,
      endTime,
      ttfbMs: endTime - startTime,
      cacheStatus: response.headers.get('cf-cache-status') || '',
      responseStatus: response.status,
    }));

    return response;
  }
};

1b. Wrangler-configuratie (wrangler.toml)

name = "shopify-request-logger"
main = "cloudflare-worker.js"
compatibility_date = "2024-01-01"

routes = [
  { pattern = "www.yourdomain.com/*", zone_name = "yourdomain.com" }
]

Vervang www.yourdomain.com door het aangepaste domein van je Shopify-winkel.

1c. Worker Secrets instellen

wrangler secret put INGEST_API_KEY
# Paste your generated API key when prompted

1d. Deployen

npx wrangler deploy

Stap 2: Stel de log-ontvanger in op je server

Een minimale Node.js HTTP-server die logbatches accepteert en naar schijf schrijft.

2a. Ontvangerscript (receive-logs.js)

const http = require('http');
const fs = require('fs');
const path = require('path');

const PORT = 9090;
const API_KEY = process.env.LOG_API_KEY;
const LOG_DIR = '/var/log/cdn-requests';  // Choose your log directory

if (!API_KEY) {
  console.error('LOG_API_KEY environment variable is required');
  process.exit(1);
}

// Ensure log directory exists
fs.mkdirSync(LOG_DIR, { recursive: true });

const server = http.createServer((req, res) => {
  // Health check
  if (req.method === 'GET' && req.url === '/status') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
    return;
  }

  // Log ingest endpoint
  if (req.method === 'POST' && req.url === '/collect') {
    const apiKey = req.headers['x-api-key'];
    if (apiKey !== API_KEY) {
      res.writeHead(401, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ error: 'unauthorized' }));
      return;
    }

    let body = '';
    let size = 0;
    const MAX_BODY = 10 * 1024 * 1024; // 10MB limit

    req.on('data', chunk => {
      size += chunk.length;
      if (size > MAX_BODY) {
        res.writeHead(413, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'payload too large' }));
        req.destroy();
        return;
      }
      body += chunk;
    });

    req.on('end', () => {
      try {
        JSON.parse(body); // Validate JSON
      } catch (e) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'invalid JSON' }));
        return;
      }

      const filename = `logs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
      const filepath = path.join(LOG_DIR, filename);

      fs.writeFile(filepath, body, err => {
        if (err) {
          console.error(`Write failed: ${err.message}`);
          res.writeHead(500, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ error: 'write failed' }));
          return;
        }
        console.log(`Wrote ${filename} (${size} bytes)`);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ ok: true }));
      });
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: 'not found' }));
  }
});

server.listen(PORT, '127.0.0.1', () => {
  console.log(`Log receiver listening on 127.0.0.1:${PORT}`);
});

Belangrijke punten:

• Bindt aan 127.0.0.1 alleen - niet blootgesteld aan het internet
• Authenticeert verzoeken met een X-API-Key header
• Schrijft elke logbatch als een JSON-bestand met tijdstempel
• 10MB payload-limiet per verzoek

2b. Systemd-service

Maak /etc/systemd/system/log-receiver.service aan:

[Unit]
Description=Shopify request log receiver
After=network.target

[Service]
Type=simple
Environment=LOG_API_KEY=<your-generated-api-key>
ExecStart=/usr/bin/node /opt/log-receiver/receive-logs.js
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Inschakelen en starten:

systemctl daemon-reload
systemctl enable --now log-receiver

Stap 3: Stel de Cloudflare Tunnel in

De tunnel maakt een beveiligde verbinding van Cloudflare’s edge naar je server - geen open poorten, geen firewallregels nodig.

3a. Installeer cloudflared

# Debian/Ubuntu
curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb \
  -o /tmp/cloudflared.deb
dpkg -i /tmp/cloudflared.deb

3b. Authenticeren

cloudflared tunnel login
# Opens a browser (or gives you a URL) to authorize with your Cloudflare account

Dit slaat een cert.pem op in ~/.cloudflared/.

3c. Maak de tunnel aan

cloudflared tunnel create shopify-log-collector

Dit geeft een Tunnel ID (een UUID) terug en maakt een credentials JSON-bestand aan in ~/.cloudflared/.

3d. Configureer de tunnel

Maak ~/.cloudflared/config.yml aan:

tunnel: <YOUR-TUNNEL-ID>
credentials-file: /root/.cloudflared/<YOUR-TUNNEL-ID>.json

ingress:
  - hostname: log-collector.yourdomain.com
    service: http://localhost:9090
  - service: http_status:404

• hostname: Het subdomein waarnaar je Worker de logboeken POST
• service: Routeert naar je Node.js-ontvanger op localhost:9090
• Catch-all-regel: Retourneert 404 voor elke andere hostnaam (vereist door cloudflared)

3e. Maak het DNS-record aan

cloudflared tunnel route dns shopify-log-collector log-collector.yourdomain.com

Dit maakt een CNAME-record aan in je Cloudflare DNS:

log-collector.yourdomain.com  →  <TUNNEL-ID>.cfargotunnel.com

Het record wordt geproxied via Cloudflare (oranje wolk) - de tunnel-ID in de CNAME is niet publiek betekenisvol.

3f. Installeer als systeemservice

cloudflared service install
systemctl enable --now cloudflared

Dit kopieert je configuratie naar /etc/cloudflared/config.yml en maakt een systemd-unit aan.

Verifieer de tunnel

systemctl status cloudflared
# Should show: active (running)

curl https://log-collector.yourdomain.com/status
# Should return: {"status":"ok"}

Stap 4: Genereer je API-sleutel

Genereer een willekeurige API-sleutel die gedeeld wordt tussen de Worker en de ontvanger:

openssl rand -hex 32

Stel deze waarde in:

1. Als een Worker secret via wrangler secret put INGEST_API_KEY
2. In de systemd Environment-regel van de ontvanger (LOG_API_KEY=…)

Stap 5: Verifieer de volledige werking

1. Bezoek je Shopify-winkel in een browser
2. Controleer de ontvangerlogboeken:

journalctl -u log-receiver -f
# Should show: Wrote logs-1234567890-abc123.json (1234 bytes)

3. Bekijk een logbestand:

cat /var/log/cdn-requests/logs-*.json | head -1 | python3 -m json.tool

Je zou een volledige logvermelding moeten zien met verzoekdetails, geolocatiegegevens en prestatiemetrieken.

Voorbeeld logvermelding

{
  "logs": [{
    "timestamp": "2026-03-04T15:19:55.584Z",
    "method": "GET",
    "url": "https://www.yourdomain.com/products/example",
    "path": "/products/example",
    "host": "www.yourdomain.com",
    "userAgent": "Mozilla/5.0 ...",
    "ip": "198.51.100.23",
    "country": "US",
    "city": "Seattle",
    "asn": 16509,
    "asOrganization": "Amazon.com",
    "colo": "SEA",
    "edgeTimeToFirstByteMs": 109,
    "originResponseStatus": 200,
    "cacheCacheStatus": "HIT",
    "botName": "other",
    "botType": "unknown"
  }]
}

Hoe werkt de volledige Shopify logging pipeline?

Gegevensstroom

1. Bezoeker opent https://www.yourdomain.com/products/something
2. Cloudflare routeert via de Worker
3. Worker haalt origin-antwoord op van Shopify → stuurt het terug naar de bezoeker
4. Worker POST { logs: [entry] } naar https://log-collector.yourdomain.com/collect
   (non-blocking - bezoeker hoeft hier niet op te wachten)
5. Cloudflare lost log-collector.yourdomain.com op via tunnel CNAME
6. Tunnel stuurt verzoek door naar localhost:9090 op je server
7. Ontvanger valideert X-API-Key, schrijft JSON-bestand naar schijf

Welke Shopify-verzoekgegevens kun je vastleggen die Shopify je niet laat zien?

Shopify’s beheerpaneel toont je paginaweergaven, bestellingen en verwijzingsbronnen. Het toont je niet welke AI-bots op bezoek kwamen, welke pagina’s ze ophaalden, waar ze vandaan kwamen, of hoe snel je server reageerde. Deze opzet legt meer dan 40 velden per verzoek vast in de volgende categorieen:

Client Hints en Fetch Metadata zijn bijzonder nuttig voor het identificeren van headless browsers en niet-ondertekende bots - echte browsers sturen deze headers, de meeste bots niet.

Welke AI-bots bezoeken je Shopify-winkel?

Shopify maakt geen onderscheid tussen menselijke bezoekers en AI-crawlers. Deze Worker classificeert elke User-Agent in twee categorieen die belangrijk zijn voor AI-zichtbaarheid:

Verzoeken van niet-herkende User-Agents worden getagd als other / unknown - je kunt deze later analyseren om niet-ondertekende crawlers te vinden. Dit zijn gegevens die Shopify, Google Analytics en de meeste SaaS-analyseplatforms simpelweg niet bieden.

Hoe sla je Shopify-botgegevens op in een database voor diepere analyse?

Voor diepgaandere botanalyses kun je de Worker uitbreiden om botverzoeken te loggen naar Supabase (of elke andere database) naast het schrijven naar schijf. Voeg deze Worker secrets toe:

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Voeg vervolgens een logToDatabase()-functie toe die POST naar de REST API van je database, aangeroepen via ctx.waitUntil() voor bekende botverzoeken. Dit geeft je gestructureerde, doorzoekbare botgegevens naast de ruwe logbestanden.

Hoe configureer je Cloudflare DNS voor een Shopify-winkel met request logging?

Om deze opzet te laten werken, moet je domein geproxied worden via Cloudflare (oranje wolk). Een typische Shopify + Cloudflare DNS-configuratie:

De www CNAME wijst naar Shopify - Cloudflare proxiet en cachet. De log-collector CNAME wijst naar je tunnel - Cloudflare routeert logverkeer veilig naar je server.

Belangrijk: De Worker-route moet overeenkomen met de geproxiede hostnaam (bijv. www.yourdomain.com/*). Deze wordt niet geactiveerd op niet-geproxiede (grijze wolk) records.

Hoe monitor en onderhoud je je Shopify log pipeline?

# Check receiver status
systemctl status log-receiver

# Check tunnel status
systemctl status cloudflared

# Tail live logs
journalctl -u log-receiver -f

# Count stored log files
ls /var/log/cdn-requests/*.json | wc -l

# Check disk usage
du -sh /var/log/cdn-requests/

Overweeg een cron job toe te voegen om schijfgebruik te monitoren en een waarschuwing te geven wanneer de opslag je limiet nadert.

Veelgestelde vragen

Waarom kunnen Shopify-winkeleigenaren geen toegang krijgen tot serverlogboeken?

Shopify is een volledig beheerd SaaS-platform. Winkeleigenaren hebben geen toegang tot de onderliggende serverinfrastructuur, wat betekent dat er geen toegang is tot ruwe HTTP-verzoeklogboeken, toegangslogboeken of foutlogboeken. Shopify biedt een eigen analysedashboard met paginaweergaven, bestellingen en verwijzingsgegevens, maar dit omvat geen individuele HTTP-verzoeken, bot user agents, reactietijden of geolocatiegegevens op verzoekniveau. Er is geen Shopify-abonnement, inclusief Shopify Plus, dat toegang tot ruwe serverlogboeken biedt. De enige manier om deze gegevens vast te leggen is het onderscheppen van verzoeken op de CDN-laag voordat ze Shopify’s origin-servers bereiken.

Hoe volg je AI-botverkeer op een Shopify-winkel?

AI-botverkeer kan niet worden gevolgd via Google Analytics, Shopify Analytics of enige client-side JavaScript-analysetool, omdat AI-bots geen JavaScript uitvoeren. De enige betrouwbare methode is server-side request logging. Voor Shopify-winkels betekent dit het onderscheppen van verzoeken op de CDN-laag met een Cloudflare Worker (of een vergelijkbare edge-functie op een andere CDN). De Worker logt elk binnenkomend verzoek, inclusief de User-Agent header, die specifieke AI-bots identificeert zoals ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot en andere. Dit is dezelfde aanpak die wordt gebruikt door opkomende “agent analytics”-platforms, maar zelf gehost en volledig onder je eigen controle.

Welke AI-bots crawlen momenteel Shopify-winkels?

Per 2026 vallen de voornaamste AI-bots die Shopify-winkels bezoeken in twee categorieen. Realtime fetch-bots (ChatGPT-User, Claude-User, Perplexity-User) halen content op aanvraag op tijdens live gebruikersgesprekken. Trainingscrawlers (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) verzamelen content volgens een schema voor modeltraining en indexopbouw. Zonder server-side logging verschijnt geen van deze in Shopify’s analyses of Google Analytics.

Hoeveel gegevensvelden logt Cloudflare per verzoek?

Deze opzet legt meer dan 40 velden per verzoek vast, waaronder verzoekbasis (tijdstempel, methode, URL, pad, user agent, IP, referer), botclassificatie (botnaam en type), Cloudflare-geolocatiegegevens (land, regio, stad, postcode, breedtegraad, lengtegraad, tijdzone, continent), netwerkinfo (ASN, organisatie, datacenter, HTTP-protocol, TLS-versie), client hints (sec-ch-ua headers die helpen bij het detecteren van headless browsers), fetch metadata (sec-fetch headers die programmatische verzoeken identificeren) en prestatiemetrieken (time to first byte, TCP round trip time, cachestatus, origin-antwoordstatus).

Hoe verhoudt dit zich tot Shopify’s ingebouwde analyses?

Shopify’s analysedashboard toont paginaweergaven, sessies, conversiepercentages en verwijzingsbronnen. Het toont geen individuele HTTP-verzoeken, bot user agents, geografische gegevens op verzoekniveau, prestatiemetrieken van reacties, of enige AI-botactiviteit. Google Analytics, waarmee Shopify integreert, heeft dezelfde beperking omdat het afhankelijk is van client-side JavaScript. Deze op Cloudflare gebaseerde logging-opzet legt elk verzoek vast dat je domein raakt, inclusief verzoeken van bots die nooit JavaScript uitvoeren, waardoor je een compleet beeld krijgt dat Shopify’s tools niet kunnen bieden.

Kun je deze opzet gebruiken met een andere CDN dan Cloudflare?

De architectuur is toepasbaar op elke edge CDN die edge-functies en beveiligde tunneling ondersteunt. Cloudflare Workers hebben equivalenten op andere platforms: Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute en Akamai EdgeWorkers kunnen allemaal verzoeken onderscheppen en loggegevens versturen. Het tunnelcomponent kan worden vervangen door elke beveiligde verbindingsmethode (SSH-tunnel, VPN, direct HTTPS-eindpunt met IP-allowlisting). Het kernpatroon is hetzelfde: onderschep aan de edge, log asynchroon, verstuur naar je eigen ontvanger.