GPTBot, ClaudeBot, ChatGPT-User: Welche AI-Bots gerade deine Website lesen

Denn "AI-Bot" ist nicht eine Sache. Es tauchen drei sehr unterschiedliche Besucher auf, mit komplett verschiedenen Absichten. Wer die Namen in seinen Server-Logs zum ersten Mal sieht, googelt sie meist wörtlich: Was ist ClaudeBot? Was macht ChatGPT-User auf meiner Seite? Hier ist die Einordnung, Bot für Bot.

Die drei Arten von AI-Bots

1. Training-Crawler: GPTBot und ClaudeBot

GPTBot (OpenAI) und ClaudeBot (Anthropic) sammeln Daten für das Training zukünftiger Modelle. Sie entscheiden mit, was ein Modell später über dich, deine Marke und dein Produkt weiß. Wer diese Crawler blockt, verschwindet aus dem Weltwissen der nächsten Modellgeneration.

Das ist die langfristige Ebene: keine unmittelbare Wirkung, aber sie prägt, wie AI dich in Monaten beschreibt.

2. Search-Indexer: OAI-SearchBot und PerplexityBot

OAI-SearchBot (OpenAI) und PerplexityBot (Perplexity) bauen den Index auf, aus dem AI-Suche ihre Antworten zieht. Das ist das Äquivalent zum klassischen Googlebot, nur für die neue Generation von Antwortmaschinen. Wer hier nicht drin ist, kommt in AI-Suchergebnissen nicht vor.

3. Live-Reader: ChatGPT-User, Claude-User und Perplexity-User

Das ist die spannendste Kategorie. ChatGPT-User, Claude-User und Perplexity-User bedeuten: Ein echter Mensch hat der AI gerade eine Frage gestellt, und sie lädt in genau diesem Moment deine Seite, um zu antworten.

Das ist kein anonymer Crawler. Das ist ein Käufer, der gerade eine Entscheidung trifft, und die AI holt sich deine Seite als Grundlage für die Antwort. Live-Reads sind kein Zukunftsthema. Sie passieren jetzt.

Warum deine Analytics das nicht zeigt

Google Analytics und die meisten Tracking-Tools laufen über JavaScript im Browser. AI-Bots führen dieses JavaScript nicht aus, sie holen sich das rohe HTML. Ergebnis: Der komplette AI-Traffic ist in deinem Standard-Analytics unsichtbar. Ein blinder Fleck, der jeden Monat größer wird.

Sichtbar wird er nur serverseitig, dort wo jeder Request ankommt, bevor irgendein Skript läuft. Genau dort setzt man an.

Bot-Übersicht auf einen Blick

So trackst du AI-Bots selbst

Du brauchst dafür kein Enterprise-Tool. Ausreichend sind:

1. Rund 50 Zeilen serverseitige Middleware, die jeden Request auf bekannte AI-User-Agents prüft (GPTBot, ClaudeBot, ChatGPT-User und so weiter).
2. Ein kostenloses PostHog-Dashboard, das die Treffer nach Bot-Name, Seite und Zeit auswertet.

Der wichtige Punkt: Das muss serverseitig laufen, an der ersten Schicht, die den Request sieht. Hier eine konkrete Version für Next.js (App Router). Das Prinzip ist überall gleich: User-Agent gegen eine Liste bekannter Bots prüfen, bei einem Treffer ein Event an PostHog schicken, und den Request ganz normal weiterlaufen lassen.

// proxy.ts (Next.js App Router). In Express, Cloudflare Workers oder PHP
// ist es dasselbe Prinzip an der ersten serverseitigen Schicht.
import { NextResponse, type NextRequest, type NextFetchEvent } from "next/server";

const POSTHOG_KEY = process.env.NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN;
const POSTHOG_HOST = "https://eu.i.posthog.com"; // US: https://us.i.posthog.com

// Bekannte AI-Bots. Reihenfolge zaehlt: spezifische User-Bots vor Crawlern.
const AI_BOTS: ReadonlyArray<{ pattern: RegExp; name: string }> = [
  // Live-Reader: ein echter Mensch fragt gerade die KI
  { pattern: /ChatGPT-User/i, name: "ChatGPT-User" },
  { pattern: /Claude-User/i, name: "Claude-User" },
  { pattern: /Perplexity-User/i, name: "Perplexity-User" },
  // Search-Indexer
  { pattern: /OAI-SearchBot/i, name: "OAI-SearchBot" },
  { pattern: /PerplexityBot/i, name: "PerplexityBot" },
  { pattern: /Google-Extended/i, name: "Google-Extended" },
  // Training-Crawler
  { pattern: /GPTBot/i, name: "GPTBot" },
  { pattern: /ClaudeBot/i, name: "ClaudeBot" },
  { pattern: /Bytespider/i, name: "Bytespider" },
  { pattern: /CCBot/i, name: "CCBot" },
];

function matchBot(ua: string): string | null {
  for (const { pattern, name } of AI_BOTS) if (pattern.test(ua)) return name;
  return null;
}

export default function proxy(request: NextRequest, event: NextFetchEvent) {
  const ua = request.headers.get("user-agent") ?? "";
  const bot = matchBot(ua);

  if (bot && POSTHOG_KEY) {
    const url = request.nextUrl;
    // Fire-and-forget: die Antwort geht sofort raus, der POST laeuft
    // im Hintergrund. Ein langsames PostHog verzoegert nie den Request.
    event.waitUntil(
      fetch(`${POSTHOG_HOST}/i/v0/e/`, {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          api_key: POSTHOG_KEY,
          event: "bot_crawl",
          distinct_id: bot,
          properties: {
            $process_person_profile: false, // kein Person-Profil, keine Pollution
            bot,
            path: url.pathname,
            host: url.host,
            user_agent: ua,
          },
        }),
      }).catch(() => {}),
    );
  }

  return NextResponse.next(); // Request laeuft ganz normal weiter
}

export const config = {
  // Assets ausschliessen, aber llms.txt / sitemap.xml / robots.txt durchlassen.
  matcher: ["/((?!api|_next|_vercel|.*\\.(?:png|jpe?g|gif|svg|webp|ico|css|js|woff2?)$).*)"],
};

Drei Details, die den Unterschied machen:

• $process_person_profile: false. Bots sind keine Menschen. Ohne dieses Flag verwässerst du deine echten Nutzerzahlen mit Crawler-Traffic.
• event.waitUntil statt await. Der Bot-Request darf nie darauf warten, dass PostHog antwortet. Feuern und vergessen.
• Der Matcher muss llms.txt durchlassen. Sonst siehst du genau die Datei nicht, die extra für AI-Bots existiert.

Brauchst du wirklich eine hartkodierte Liste?

Kurze Antwort: Es gibt keine echte Auto-Erkennung. Irgendwo ist immer eine Liste, die Frage ist nur, wer sie pflegt. Der Request selbst trägt nichts außer dem User-Agent-String, es gibt kein "ich bin ein AI-Bot"-Flag, und Heuristiken wie "führt kein JavaScript aus" treffen auch auf viele normale HTTP-Clients zu.

Du hast also drei Optionen, von "selbst pflegen" zu "pflegen lassen":

• Eigene Regex-Liste (der Code oben). Rund zehn Zeilen, volle Kontrolle. Neue Bots trägst du selbst nach, was bei den großen, stabilen Namen (GPTBot, ClaudeBot, ChatGPT-User) kein Thema ist.
• Ein gepflegter Datensatz statt eigenem Array: isbot, die Liste crawler-user-agents oder ai-robots-txt (monatlich aktualisiert). Du ersetzt das AI_BOTS-Array durch einen Import und musst nie wieder nachtragen.
• Die Plattform macht es. Cloudflare hat "Verified Bots" und eine eigene AI-Bot-Kategorie, also automatische Erkennung plus echte Verifizierung. Vercel hat ebenfalls Bot-Detection.

Ein Punkt, der oft untergeht: Der User-Agent ist fälschbar. Jeder kann sich als GPTBot ausgeben. Wirklich sicher ist es nur über IP-Range-Abgleich (OpenAI und Anthropic veröffentlichen ihre Ranges) oder reverse DNS, genau das macht Cloudflares "Verified" automatisch. Für ein Dashboard, das Trends zeigt, reicht der UA-Match locker. Für "blocke alles, was sich nicht verifiziert" brauchst du die IP-Prüfung.

Als ich das für einen Kunden aufgesetzt habe, hat ChatGPT-User die Startseite innerhalb von Minuten nach dem Deploy gezogen. Die Besuche passieren bereits. Die einzige Frage ist, ob du sie siehst.