Shopify gibt Ihnen keine Log-Dateien. Hier ist eine vollstaendige technische Anleitung, um sie mit Cloudflare (oder jedem Edge-CDN) zu erhalten.

Ein grosser blinder Fleck im E-Commerce wurde gerade geloest

Seit dem Tag, an dem Shopify gestartet wurde, hat die Plattform rohe Server-Logs vollstaendig aus den Haenden der Shop-Betreiber ferngehalten. Sie erhalten Conversion-Funnels und Verkaufsberichte. Was Sie nicht erhalten, ist das Einzige, was Ihnen tatsaechlich zeigt, was Ihren Server erreicht: das HTTP-Request-Log.

Jahrelang war das ein kleines Aergernis. Wen interessieren rohe Logs, wenn man Seitenaufrufe und Conversion-Raten hat? Google Analytics trackt Ihre menschlichen Besucher. Ihre Werbeplattform trackt Ihre Kampagnen. Alles laeuft bestens.

Dann kam die KI.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - sie alle senden gerade Bots in Ihren Shop. Einige crawlen Ihre Seiten, um Trainingsdaten aufzubauen. Andere rufen Ihre Produktinhalte in Echtzeit ab, um die Frage eines Kunden zu beantworten. Und der Clou? Traditionelle Analytics-Tools wie Google Analytics koennen nichts davon sehen. Sie basieren auf clientseitigem JavaScript, das Bots niemals ausfuehren. Der Grossteil der KI-Interaktion mit Ihrem Shop ist fuer Sie unsichtbar.

Das ist der neue blinde Fleck im E-Commerce. KI-Bots fuehren Ihre Tracking-Skripte nicht aus. Sie akzeptieren keine Cookies. Sie tauchen nicht in Ihren GA4-Berichten auf. Aber sie lesen definitiv Ihre Produktseiten, ziehen Ihre Beschreibungen in KI-generierte Antworten ein und bestimmen mit, ob Kunden Ihre Marke ueberhaupt entdecken.

Neue Tools mit Fokus auf “Agent Analytics” entstehen, um Website-Betreibern zu helfen, KI-Crawler-Aktivitaeten und KI-generierte Verweise durch serverseitiges Tracking, Bot-Klassifizierung und IP-Verifizierung zu verstehen. Die Branche erkennt, dass das alte clientseitige Analytics-Modell fuer das Zeitalter der KI-gesteuerten Inhaltsentdeckung grundlegend ueberholt ist. Deshalb haben wir das WISLR AI Visibility Dashboard entwickelt - um Marken ein klares Bild davon zu geben, wie KI-Plattformen mit ihren Inhalten interagieren, von Crawl-Raten ueber Abrufanfragen bis hin zu KI-gesteuertem Referral-Traffic.

Aber wenn Sie auf Shopify sind, haben Sie ein einzigartiges Problem: Sie kontrollieren den Server nicht. Sie koennen kein serverseitiges Tracking direkt installieren. Sie koennen Ihre Zugriffsprotokolle nicht live verfolgen. Sie koennen nicht nach GPTBot greppen. Shopifys Infrastruktur ist eine Blackbox, und es gibt keine Anzeichen dafuer, dass sie diese oeffnen wollen.

Damit ist jetzt Schluss. So holen Sie sich Ihre Logs zurueck.

Diese Anleitung fuehrt Sie durch den Aufbau einer eigenen vollstaendigen Request-Logging-Pipeline fuer einen Shopify-Shop mit Cloudflare. Jeder HTTP-Request. Vollstaendige Geodaten. Performance-Metriken. Und vor allem eine umfassende Bot-Erkennung und -Klassifizierung, damit Sie endlich genau sehen koennen, welche KI-Systeme Ihren Shop besuchen, wie oft und welche Seiten sie interessieren.

Wie funktioniert Cloudflare Request-Logging fuer Shopify?

 Visitor requests your Shopify store
         │
         ▼
 Cloudflare CDN (your domain proxied through Cloudflare)
         │
         ▼
 Cloudflare Worker (runs on every request)
    ├──→ Passes request through to Shopify origin (visitor gets normal response)
    └──→ POSTs a JSON log entry to your log receiver (non-blocking, via ctx.waitUntil)
              │
              ▼
         Cloudflare Tunnel
         (CNAME on your domain → tunnel → localhost on your server)
              │
              ▼
         Node.js HTTP Receiver (localhost:9090)
              │
              ▼
         JSON log files written to disk

Es werden keine Ports oeffentlich freigegeben. Der Cloudflare Tunnel uebernimmt den sicheren Transport von Cloudflares Edge zu Ihrem Server ueber eine ausschliesslich ausgehende Verbindung.

Was benoetigen Sie, um Shopify Request-Logging einzurichten?

• Einen Shopify-Shop mit einer benutzerdefinierten Domain, die ueber Cloudflare proxiert wird (orangefarbene Wolke aktiviert)
• Einen Server zum Empfangen von Logs
• Node.js auf dem Server installiert
• Ein Cloudflare-Konto mit aktivierten Workers
• Wrangler CLI installiert (npm install -g wrangler)
• Cloudflared auf dem Server installiert

Schritt 1: Den Cloudflare Worker erstellen

Der Worker faengt jeden Request auf Ihrer Domain ab, leitet ihn an Shopify weiter und sendet asynchron einen Log-Eintrag an Ihren Empfaenger.

1a. Worker-Quellcode (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-Konfiguration (wrangler.toml)

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

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

Ersetzen Sie www.yourdomain.com durch die benutzerdefinierte Domain Ihres Shopify-Shops.

1c. Worker Secrets festlegen

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

1d. Bereitstellen

npx wrangler deploy

Schritt 2: Den Log-Empfaenger auf Ihrem Server einrichten

Ein minimaler Node.js-HTTP-Server, der Log-Stapel entgegennimmt und auf die Festplatte schreibt.

2a. Empfaenger-Skript (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}`);
});

Wichtige Punkte:

• Bindet sich nur an 127.0.0.1 - nicht dem Internet ausgesetzt
• Authentifiziert Requests mit einem X-API-Key-Header
• Schreibt jeden Log-Stapel als JSON-Datei mit Zeitstempel
• 10 MB Payload-Limit pro Request

2b. Systemd-Dienst

Erstellen Sie /etc/systemd/system/log-receiver.service:

[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

Aktivieren und starten:

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

Schritt 3: Den Cloudflare Tunnel einrichten

Der Tunnel erstellt eine sichere Verbindung von Cloudflares Edge zu Ihrem Server - keine offenen Ports, keine Firewall-Regeln erforderlich.

3a. Cloudflared installieren

# 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. Authentifizieren

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

Dies speichert eine cert.pem in ~/.cloudflared/.

3c. Den Tunnel erstellen

cloudflared tunnel create shopify-log-collector

Dies gibt eine Tunnel-ID (eine UUID) aus und erstellt eine JSON-Anmeldedatei in ~/.cloudflared/.

3d. Den Tunnel konfigurieren

Erstellen Sie ~/.cloudflared/config.yml:

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: Die Subdomain, an die Ihr Worker die Logs sendet
• service: Leitet an Ihren Node.js-Empfaenger auf localhost:9090 weiter
• Catch-all-Regel: Gibt 404 fuer jeden anderen Hostnamen zurueck (von cloudflared erfordert)

3e. Den DNS-Eintrag erstellen

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

Dies erstellt einen CNAME-Eintrag in Ihrem Cloudflare DNS:

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

Der Eintrag wird ueber Cloudflare proxiert (orangefarbene Wolke) - die Tunnel-ID im CNAME ist oeffentlich nicht aussagekraeftig.

3f. Als Systemdienst installieren

cloudflared service install
systemctl enable --now cloudflared

Dies kopiert Ihre Konfiguration nach /etc/cloudflared/config.yml und erstellt eine systemd-Unit.

Tunnel ueberpruefen

systemctl status cloudflared
# Should show: active (running)

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

Schritt 4: Ihren API-Key generieren

Generieren Sie einen zufaelligen API-Key, der zwischen dem Worker und dem Empfaenger geteilt wird:

openssl rand -hex 32

Setzen Sie diesen Wert:

1. Als Worker Secret ueber wrangler secret put INGEST_API_KEY
2. In der systemd-Environment-Zeile des Empfaengers (LOG_API_KEY=…)

Schritt 5: Ende-zu-Ende-Verifizierung

1. Besuchen Sie Ihren Shopify-Shop in einem Browser
2. Pruefen Sie die Empfaenger-Logs:

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

3. Untersuchen Sie eine Log-Datei:

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

Sie sollten einen vollstaendigen Log-Eintrag mit Request-Details, Geodaten und Performance-Metriken sehen.

Beispiel-Log-Eintrag

{
  "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"
  }]
}

Wie funktioniert die vollstaendige Shopify-Logging-Pipeline?

Datenfluss

1. Visitor hits https://www.yourdomain.com/products/something
2. Cloudflare routes through the Worker
3. Worker fetches origin response from Shopify → returns it to visitor
4. Worker POSTs { logs: [entry] } to https://log-collector.yourdomain.com/collect
   (non-blocking - visitor doesn't wait for this)
5. Cloudflare resolves log-collector.yourdomain.com via tunnel CNAME
6. Tunnel forwards request to localhost:9090 on your server
7. Receiver validates X-API-Key, writes JSON file to disk

Welche Shopify-Request-Daten koennen Sie erfassen, die Shopify Ihnen nicht zeigt?

Shopifys Admin-Bereich zeigt Ihnen Seitenaufrufe, Bestellungen und Referral-Quellen. Er zeigt Ihnen nicht, welche KI-Bots Sie besucht haben, welche Seiten sie abgerufen haben, woher sie kamen oder wie schnell Ihr Server geantwortet hat. Dieses Setup erfasst ueber 40 Felder pro Request in folgenden Kategorien:

Client Hints und Fetch Metadata sind besonders nuetzlich zur Erkennung von Headless-Browsern und nicht-signierten Bots - echte Browser senden diese Header, die meisten Bots nicht.

Welche KI-Bots besuchen Ihren Shopify-Shop?

Shopify unterscheidet nicht zwischen menschlichen Besuchern und KI-Crawlern. Dieser Worker klassifiziert jeden User-Agent in zwei Kategorien, die fuer die KI-Sichtbarkeit relevant sind:

Requests von nicht erkannten User-Agents werden als other / unknown gekennzeichnet - Sie koennen diese spaeter analysieren, um nicht-signierte Crawler zu finden. Dies sind Daten, die Shopify, Google Analytics und die meisten SaaS-Analytics-Plattformen einfach nicht bereitstellen.

So speichern Sie Shopify-Bot-Daten in einer Datenbank fuer tiefere Analysen

Fuer tiefere Bot-Analysen koennen Sie den Worker erweitern, um Bot-Requests zusaetzlich zur Festplatte auch in Supabase (oder jeder anderen Datenbank) zu protokollieren. Fuegen Sie diese Worker Secrets hinzu:

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Fuegen Sie dann eine logToDatabase()-Funktion hinzu, die per POST an die REST-API Ihrer Datenbank sendet und ueber ctx.waitUntil() fuer bekannte Bot-Requests aufgerufen wird. Dies gibt Ihnen strukturierte, abfragbare Bot-Daten neben den rohen Log-Dateien.

So konfigurieren Sie Cloudflare DNS fuer einen Shopify-Shop mit Request-Logging

Damit dieses Setup funktioniert, muss Ihre Domain ueber Cloudflare proxiert werden (orangefarbene Wolke). Eine typische Shopify + Cloudflare DNS-Konfiguration:

Der www-CNAME zeigt auf Shopify - Cloudflare proxiert und cached. Der log-collector-CNAME zeigt auf Ihren Tunnel - Cloudflare leitet den Log-Traffic sicher zu Ihrem Server.

Wichtig: Die Worker-Route muss mit dem proxierten Hostnamen uebereinstimmen (z.B. www.yourdomain.com/*). Sie wird bei nicht-proxierten (graue Wolke) Eintraegen nicht ausgeloest.

So ueberwachen und warten Sie Ihre 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/

Erwaegen Sie, einen Cron-Job hinzuzufuegen, der die Festplattenbelegung ueberwacht und warnt, wenn der Speicherplatz sich Ihrem Limit naehert.

Haeufig gestellte Fragen

Warum koennen Shopify-Shop-Betreiber nicht auf Server-Logs zugreifen?

Shopify ist eine vollstaendig verwaltete SaaS-Plattform. Shop-Betreiber haben keinen Zugang zur zugrunde liegenden Server-Infrastruktur, was bedeutet, dass es keinen Zugriff auf rohe HTTP-Request-Logs, Zugriffsprotokolle oder Fehlerprotokolle gibt. Shopify bietet ein eigenes Analytics-Dashboard mit Seitenaufrufen, Bestellungen und Referral-Daten, aber dieses enthaelt keine einzelnen HTTP-Requests, Bot-User-Agents, Antwortzeiten oder Geodaten auf Request-Ebene. Es gibt keinen Shopify-Tarif, einschliesslich Shopify Plus, der Zugang zu rohen Server-Logs bietet. Der einzige Weg, diese Daten zu erfassen, ist das Abfangen von Requests auf der CDN-Ebene, bevor sie Shopifys Origin-Server erreichen.

Wie trackt man KI-Bot-Traffic auf einem Shopify-Shop?

KI-Bot-Traffic kann nicht ueber Google Analytics, Shopify Analytics oder irgendein clientseitiges JavaScript-Analytics-Tool getrackt werden, da KI-Bots kein JavaScript ausfuehren. Die einzige zuverlaessige Methode ist serverseitiges Request-Logging. Fuer Shopify-Shops bedeutet dies, Requests auf der CDN-Ebene mit einem Cloudflare Worker (oder einer gleichwertigen Edge-Funktion auf einem anderen CDN) abzufangen. Der Worker protokolliert jeden eingehenden Request, einschliesslich des User-Agent-Headers, der spezifische KI-Bots wie ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot und andere identifiziert. Dies ist der gleiche Ansatz, den aufkommende “Agent Analytics”-Plattformen verwenden, aber selbst gehostet und vollstaendig unter Ihrer Kontrolle.

Welche KI-Bots crawlen gerade Shopify-Shops?

Stand 2026 fallen die wichtigsten KI-Bots, die Shopify-Shops besuchen, in zwei Kategorien. Echtzeit-Abruf-Bots (ChatGPT-User, Claude-User, Perplexity-User) rufen Inhalte bei Bedarf waehrend Live-Nutzergespraechen ab. Training-Crawler (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) sammeln Inhalte nach einem Zeitplan fuer Modelltraining und Indexaufbau. Ohne serverseitiges Logging erscheint keiner dieser Bots in Shopifys Analytics oder Google Analytics.

Wie viele Datenfelder protokolliert Cloudflare pro Request?

Dieses Setup erfasst ueber 40 Felder pro Request, darunter Request-Grundlagen (Timestamp, Methode, URL, Pfad, User-Agent, IP, Referer), Bot-Klassifizierung (Bot-Name und -Typ), Cloudflare-Geodaten (Land, Region, Stadt, Postleitzahl, Breitengrad, Laengengrad, Zeitzone, Kontinent), Netzwerkinformationen (ASN, Organisation, Rechenzentrum, HTTP-Protokoll, TLS-Version), Client Hints (sec-ch-ua-Header, die bei der Erkennung von Headless-Browsern helfen), Fetch Metadata (sec-fetch-Header, die programmatische Requests identifizieren) und Performance-Metriken (Time to First Byte, TCP-Round-Trip-Time, Cache-Status, Origin-Response-Status).

Wie schneidet dies im Vergleich zu Shopifys integrierten Analytics ab?

Shopifys Analytics-Dashboard zeigt Seitenaufrufe, Sitzungen, Conversion-Raten und Referral-Quellen. Es zeigt keine einzelnen HTTP-Requests, Bot-User-Agents, geografische Daten auf Request-Ebene, Response-Performance-Metriken oder jegliche KI-Bot-Aktivitaet. Google Analytics, das Shopify integriert, hat die gleiche Einschraenkung, da es auf clientseitigem JavaScript basiert. Dieses Cloudflare-basierte Logging-Setup erfasst jeden Request, der Ihre Domain erreicht, einschliesslich derer von Bots, die niemals JavaScript ausfuehren, und gibt Ihnen ein vollstaendiges Bild, das Shopifys Tools nicht bieten koennen.

Kann man dieses Setup mit einem anderen CDN als Cloudflare verwenden?

Die Architektur ist auf jedes Edge-CDN anwendbar, das Edge-Funktionen und sicheres Tunneling unterstuetzt. Cloudflare Workers haben Entsprechungen auf anderen Plattformen: Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute und Akamai EdgeWorkers koennen alle Requests abfangen und Log-Daten versenden. Die Tunnel-Komponente kann durch jede sichere Verbindungsmethode ersetzt werden (SSH-Tunnel, VPN, direkter HTTPS-Endpunkt mit IP-Allowlisting). Das Grundmuster ist dasselbe: Am Edge abfangen, asynchron protokollieren, an den eigenen Empfaenger senden.