JavaScript und KI-Crawler: So prüfen Sie, was ChatGPT sieht

Ein Crawler ist ein Programm, das Seiten automatisch abruft. Rendern heißt hier: Er führt die Skripte einer Seite aus und liest das Ergebnis. Die Belege dazu sind dünn und verschieden belastbar. Die Tabelle nennt deshalb je System die Art der Quelle und ihr Datum. Die Zahlen in der Spalte „Quelle“ sind die Nummern der Quellenliste am Ende des Beitrags.

Die Protokolle (Server-Logs) stammen von einer einzigen Nachrichtenseite. Gezählt wurde dort die Kennung, also der Name, mit dem sich ein Programm beim Server vorstellt, und die Auswertung kommt von einem Anbieter solcher Werkzeuge (Forge AI Bot Log, 24.09.2026). Die Messung von 2024 hat die Cloud-Plattform Vercel mit MERJ veröffentlicht, Microsoft Copilot fehlte darin, weil es keine eigene Kennung nutzt (Vercel und MERJ). Die Übersicht stammt von searchVIU, einem Anbieter von SEO-Werkzeugen (searchVIU, 03.11.2026). Eine neuere Messung in vergleichbarer Größe haben wir nicht gefunden. In den Crawler-Dokumentationen von OpenAI und Perplexity kommt JavaScript nicht vor. Eine Aussage von OpenAI zu den Berichten seit September 2026 haben wir nicht gefunden.

Warum das zählt: Was erst im Browser entsteht, fehlt für Systeme ohne JavaScript. Auf der Nachrichtenseite rief ChatGPT-User eine Seite mit Spritpreisen in 30 Tagen 157-mal ab, Claude-User 80-mal. Beide sahen keinen Preis, weil Skripte die Preise einfügten. Googlebot stellt Seiten mit JavaScript dar, deshalb fällt die Lücke in der Google-Suche oft nicht auf. Wie Google damit umgeht, erklärt unser Leitfaden technisches SEO im Abschnitt Sieht Google Inhalte, die erst JavaScript erzeugt?

Agenten, die einen echten Browser steuern, führen Skripte aus. Im Protokoll sehen sie oft aus wie normale Besucher mit Chrome (Forge AI Bot Log). Für solche Agenten gilt diese Anleitung nicht.

Erledigt, wenn Sie wissen, welche dieser Systeme für Ihre Kunden zählen.

Warum: Ein Crawler ohne JavaScript bekommt genau dieses Roh-HTML. Ihr Browser zeigt die fertige Seite, nachdem alle Skripte gelaufen sind. Deshalb sehen Sie eine Lücke beim Surfen nicht. Die Prüfung hat drei Schritte: zuerst dieser Abruf, dann der Vergleich mit dem Browser, zuletzt die Frage nach der Ursache.

So gehen Sie vor:

1. Kopieren Sie aus dem Browser einen Satz, den Ihre Kunden lesen sollen, etwa Ihre Leistung mit dem Ort. Nehmen Sie möglichst einen Teil ohne Umlaute.
2. Setzen Sie Adresse und Satz in den Befehl für Ihr System ein.
3. Lesen Sie die Ausgabe: 1 oder mehr heißt, der Satz steht im Roh-HTML. grep zählt Zeilen, nicht Treffer. Bei 0 prüfen Sie zuerst, ob der Abruf geklappt hat (dritter Schritt der Prüfung).

curl -sL https://www.example.de/leistung/ | grep -c "Ihr Kernsatz"

(curl.exe -sL https://www.example.de/leistung/ | Select-String -SimpleMatch "Ihr Kernsatz").Count
(Invoke-WebRequest -UseBasicParsing -Uri https://www.example.de/leistung/).Content.Contains("Ihr Kernsatz")

Die erste Zeile in PowerShell gibt eine Zahl aus, die zweite True oder False. Windows 10 und 11 bringen curl mit (curl-Projekt). Schreiben Sie dort curl.exe, denn curl allein steht in PowerShell 5.1 für Invoke-WebRequest (Microsoft zu Invoke-WebRequest). Dessen Schalter -UseBasicParsing ist seit einem Sicherheitsupdate vom 09.12.2025 nötig, sonst fragt PowerShell bei jedem Abruf nach, ob Skriptcode der Seite laufen darf.

Typische Fehler:

• Umlaute unter Windows. Mit curl.exe und Select-String fand die Suche in unserem Test am 09.11.2026 nichts, sobald der Satz einen Umlaut enthielt: Die Konsole liest die Antwort mit einem älteren Zeichensatz. Die Zeile mit Invoke-WebRequest fand den Text. Wollen Sie bei curl.exe bleiben, setzen Sie vorher [Console]::OutputEncoding = [Text.Encoding]::UTF8.
• Zeilenumbruch im Quelltext. Steht der Satz im HTML auf zwei Zeilen verteilt, findet grep ihn nicht. Nehmen Sie drei oder vier Wörter oder das Skript im nächsten Abschnitt.
• Text nur in Daten. Steht der Satz nur in einem Datenblock, etwa in JSON für die Anwendung, zählt grep ihn mit, obwohl er ohne JavaScript nicht auf der Seite steht. Vercel und MERJ halten für möglich, dass KI-Modelle solche Daten trotzdem verwerten. Verlassen Sie sich nicht darauf.

Beispiel: An einer eigenen Probeseite mit vollständig clientseitigem Aufbau ergab grep -c eine 0, an der statischen Fassung derselben Seite eine 1.

Erledigt, wenn Sie für jede wichtige Seite wissen, ob ihr Kernsatz im Roh-HTML steht.

Unser Skript vergleicht beide Fassungen für die ganze Seite und listet jeden Textblock, der nur im DOM steht. Der Schalter --dump-dom gibt die Seite aus, nachdem Chrome die Skripte ausgeführt hat (Chrome-Dokumentation). Mit --virtual-time-budget bekommen nachgeladene Inhalte acht Sekunden virtuelle Zeit.

So gehen Sie vor: Speichern Sie das Skript als roh-gegen-dom.py. Sie brauchen Python 3 und Chrome oder Edge. Rufen Sie es unter Windows mit python, unter macOS und Linux mit python3 auf, gefolgt von Adresse und Kernsatz. Unsere Codebeispiele stehen unter der Lizenz MIT-0.

#!/usr/bin/env python3
"""Vergleicht den Text im ausgelieferten HTML mit dem Text nach dem Ausführen von JavaScript.

Aufruf: python3 roh-gegen-dom.py https://www.example.de/seite/ "ein Satz aus Ihrer Seite"

Braucht Python 3 und Chrome oder Edge. Lizenz: MIT-0 (datafalke.de).
"""
import html.parser
import shutil
import subprocess
import sys
import tempfile
import urllib.error
import urllib.request

BROWSER = [
    r"C:\Program Files\Google\Chrome\Application\chrome.exe",
    r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
    "google-chrome", "chromium", "chromium-browser",
]
KENNUNG = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
OHNE_TEXT = {"title", "script", "style", "template"}
BLOCK = {"p", "li", "h1", "h2", "h3", "h4", "h5", "h6", "td", "th", "div", "section", "main",
         "article", "header", "footer", "nav", "aside", "form", "tr", "pre", "blockquote", "figcaption"}


class Text(html.parser.HTMLParser):
    def __init__(self):
        super().__init__()
        self.aussen, self.bloecke, self.skripte, self.datenbloecke = 0, [[]], 0, 0

    def handle_starttag(self, tag, attrs):
        if tag == "script":
            typ = dict(attrs).get("type") or ""
            if typ in ("", "text/javascript", "application/javascript", "module"):
                self.skripte += 1
            else:
                self.datenbloecke += 1
        if tag in OHNE_TEXT:
            self.aussen += 1
        if tag in BLOCK:
            self.bloecke.append([])

    def handle_endtag(self, tag):
        if tag in OHNE_TEXT and self.aussen:
            self.aussen -= 1

    def handle_data(self, daten):
        if not self.aussen:
            self.bloecke[-1].append(daten)


def normal(text):
    return " ".join(text.replace("\u00ad", "").split())


def lies(quelltext):
    text = Text()
    text.feed(quelltext)
    bloecke = [normal("".join(block)) for block in text.bloecke]
    return [block for block in bloecke if block], text.skripte, text.datenbloecke


def roh(url):
    anfrage = urllib.request.Request(url, headers={"User-Agent": KENNUNG})
    try:
        antwort = urllib.request.urlopen(anfrage, timeout=30)
    except urllib.error.HTTPError as fehler:
        antwort = fehler
    zeichensatz = antwort.headers.get_content_charset() or "utf-8"
    return antwort.getcode(), antwort.read().decode(zeichensatz, "replace")


def dom(url):
    browser = next(filter(None, map(shutil.which, BROWSER)), None)
    if browser is None:
        sys.exit("Kein Chrome oder Edge gefunden: Pfad in BROWSER eintragen.")
    profil = tempfile.mkdtemp()
    try:
        ergebnis = subprocess.run(
            [browser, "--headless", f"--user-data-dir={profil}", "--virtual-time-budget=8000", "--dump-dom", url],
            capture_output=True, timeout=120)
    finally:
        shutil.rmtree(profil, ignore_errors=True)
    return ergebnis.stdout.decode("utf-8", "replace")


def main():
    url = sys.argv[1]
    satz = normal(sys.argv[2]) if len(sys.argv) > 2 else None
    status, quelltext = roh(url)
    roh_bloecke, skripte, datenbloecke = lies(quelltext)
    dom_bloecke, _, _ = lies(dom(url))
    roh_text, dom_text = " ".join(roh_bloecke), " ".join(dom_bloecke)
    nur_im_dom = [block for block in dom_bloecke if block not in roh_text]
    print("Status:    ", status)
    print("Skripte:   ", skripte, "ausführbar,", datenbloecke, "Datenblock (etwa JSON-LD)")
    print("Wörter:    ", len(roh_text.split()), "im Roh-HTML,", len(dom_text.split()), "im DOM")
    if satz:
        print("Kernsatz:  ", "Roh-HTML", "ja" if satz in roh_text else "nein",
              "| DOM", "ja" if satz in dom_text else "nein")
    print("Nur im DOM:", len(nur_im_dom), "Textblock" if len(nur_im_dom) == 1 else "Textblöcke")
    for block in nur_im_dom[:5]:
        print("  -", block[:90])


if __name__ == "__main__":
    main()

Was Sie erwarten dürfen: Die Tabelle zeigt die Ausgaben an fünf eigenen Probeseiten auf unserem Testrechner. Statisch heißt: fertige Dateien, serverseitig (SSR): der Server baut das HTML bei jedem Abruf, clientseitig (CSR): JavaScript baut die Seite im Browser (web.dev zu den Rendering-Arten). Auf echten Websites sind die Zahlen größer, das Muster bleibt.

Messung vom 09.11.2026 · curl 8.21.0, GNU grep 3.0, Python 3.12, Chrome 156, Abrufe von fünf eigenen Probeseiten mit Python und curl, Ausgabe des Vergleichsskripts

So lesen Sie die Zeilen:

• Statisch: Der Text ist für jeden Crawler lesbar.
• Serverseitig: Der Text ist für jeden Crawler lesbar, Skripte machen die Seite nur bedienbar.
• Gemischt: Der nachgeladene Absatz fehlt ohne JavaScript.
• Clientseitig: Der Text fehlt ohne JavaScript; die 4 Wörter sind ein Hinweis im noscript-Element.
• Nur Daten: grep zählt den Satz, auf der Seite steht er erst nach dem Skript.

Statisch und serverseitig sehen für einen Crawler gleich aus: Beide bestehen die Prüfung. Baut der Server die Seite bei jedem Abruf neu, kann ein Block mit wechselnden Angaben wie einer Uhrzeit als „nur im DOM“ erscheinen, weil das Skript die Seite zweimal abruft. Das ist kein Fehler im Rendering. So sah die Ausgabe für die gemischte Probeseite aus:

Status:     200
Skripte:    1 ausführbar, 0 Datenblock (etwa JSON-LD)
Wörter:     19 im Roh-HTML, 27 im DOM
Kernsatz:   Roh-HTML ja | DOM ja
Nur im DOM: 1 Textblock
- Wartungsverträge gibt es für Anlagen bis 100 kWp.

Ohne Python zählen Sie den Kernsatz im DOM direkt. Geben Sie einen eigenen Profilordner an, damit ein geöffnetes Chrome nicht stört:

google-chrome --headless --user-data-dir=/tmp/df-probe --dump-dom https://www.example.de/leistung/ | grep -c "Ihr Kernsatz"
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless --user-data-dir=/tmp/df-probe --dump-dom https://www.example.de/leistung/ | grep -c "Ihr Kernsatz"

$chrome = "C:\Program Files\Google\Chrome\Application\chrome.exe"
Start-Process $chrome -ArgumentList "--headless", "--user-data-dir=$env:TEMP\df-probe", "--dump-dom", "https://www.example.de/leistung/" -NoNewWindow -Wait -RedirectStandardOutput dom.html
(Select-String -Path dom.html -SimpleMatch "Ihr Kernsatz" -Encoding utf8).Count

Unter Windows schreiben Sie das DOM zuerst in eine Datei, denn in unserem Test am 09.11.2026 blieb die direkte Weitergabe mit | leer.

Typischer Fehler: Im Reiter „Elements“ der Entwicklertools steht das DOM, also die Seite nach den Skripten. Den Quelltext, den der Server geschickt hat, zeigt die Ansicht „Seitenquelltext“ (Strg+U, am Mac Befehl+Wahl+U). Diese Kurzprobe ohne Terminal beschreibt unser Ratgeber zur Sichtbarkeit in ChatGPT.

Erledigt, wenn die Zeile „Nur im DOM“ für Ihre wichtigsten Seiten 0 zeigt oder nur Texte nennt, die Ihren Kunden nichts sagen.

Rufen Sie die Seite einmal normal und einmal mit der Kennung eines Crawlers ab, und lesen Sie dann die robots.txt:

curl -s -o /dev/null -w "%{http_code} %{size_download}\n" https://www.example.de/leistung/
curl -s -o /dev/null -w "%{http_code} %{size_download}\n" -A "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot" https://www.example.de/leistung/
curl -s https://www.example.de/robots.txt | grep -i -A1 "gptbot"

curl.exe -s -o NUL -w "%{http_code} %{size_download}\n" https://www.example.de/leistung/
curl.exe -s -o NUL -w "%{http_code} %{size_download}\n" -A "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot" https://www.example.de/leistung/
curl.exe -s https://www.example.de/robots.txt | Select-String -Pattern "gptbot" -Context 0,1

Jede der beiden Abrufzeilen gibt Status und Größe der Antwort in Byte aus. Die Kennung im Beispiel nennt OpenAI für seinen Crawler GPTBot (Crawler-Dokumentation von OpenAI). Die Schalter -A und -w beschreibt das curl-Handbuch. Antwortet schon der erste Abruf mit 403, blockiert Ihr CDN vermutlich curl allgemein. Tragen Sie dann mit -A die Kennung eines Browsers ein.

Auf unserer Probeseite mit Sperre nach Kennung lieferte der normale Abruf 200 318, der Abruf mit der Kennung von GPTBot 403 97. Die Probeseite mit einer Sperre in der robots.txt antwortete auf beide Abrufe mit 200 318. Der Abruf mit Kennung zeigt die Sperre also nicht, die Datei schon.

Warum das zählt: Von außen sieht jede dieser Ursachen gleich aus, denn KI-Dienste haben Ihren Text nicht. Behoben werden sie an verschiedenen Stellen: im Code der Website, in der robots.txt oder in den Einstellungen von Firewall und CDN (dem Netz, das Ihre Seiten ausliefert). Welche Kennungen es gibt und was Sie erlauben sollten, steht in unserem Beitrag KI-Crawler und robots.txt. Wie Sie Firewall und CDN prüfen, beschreibt dort der Abschnitt zu Firewall und CDN.

Typischer Fehler: Aus Status 200 mit der Kennung von GPTBot wird geschlossen, dass GPTBot die Seite lesen darf. Die robots.txt prüft curl nicht.

Erledigt, wenn für jede Seite ohne Kernsatz feststeht, welche Ursache vorliegt.

1. Rendering ändern. Bei Anwendungen, die im Browser entstehen, helfen serverseitiges Rendering oder das Vorab-Erzeugen der Seiten beim Bau. Google hält das für sinnvoll, weil es Websites schneller macht und nicht alle Bots JavaScript ausführen (Google, JavaScript-Grundlagen). Welche Bauweise zu Ihrer Website passt, vergleicht unser Beitrag Statische Website oder WordPress.
2. Nachgeladene Teile ins HTML holen. Preise, Leistungen, Öffnungszeiten und Antworten auf häufige Fragen gehören in das erste HTML. Muss ein Widget bleiben, nennen Sie das Wichtigste daneben als Text. Microsoft schreibt, dass Inhalte, die sich nicht zuverlässig darstellen lassen, womöglich weder indexiert noch als Quelle für Antworten genutzt werden (Bing-Richtlinien).
3. Keine Ersatzseiten nur für Crawler. Eine eigene Fassung für erkannte Bots nennt Google Dynamic Rendering. Google bezeichnet das als Notbehelf, der zusätzliche Komplexität schafft, und empfiehlt die Wege aus Nummer 1 (Google, Dynamic Rendering).
4. Erneut prüfen. Wiederholen Sie die drei Schritte der Prüfung für jede geänderte Seite.

Bei den Websites, die wir bauen, steht der Text deshalb von Anfang an im HTML.

Typischer Fehler: Die Startseite wird umgestellt, während Preise und Leistungen auf Unterseiten weiter per Skript laden.

Erledigt, wenn die Zeile „Nur im DOM“ auf den geänderten Seiten keine wichtigen Inhalte mehr nennt.

• Sperren nach IP-Adresse oder Land. Ihr Abruf mit Crawler-Kennung kommt aus Ihrem eigenen Netz. Echte Crawler erkennen Sie an der IP-Adresse des Betreibers. Wie Sie Abrufe zählen, zeigt unser Ratgeber KI-Traffic messen.
• Der Zeitpunkt. Crawler können sich ändern, ohne dass es jemand ankündigt. Darauf deuten die Berichte vom September 2026 hin. Wiederholen Sie die Prüfung nach jedem Relaunch und jedes halbe Jahr.
• Die Wirkung. Steht Ihr Text im HTML, ist eine Hürde weg. Ob KI-Antworten Sie deshalb häufiger nennen, zeigt diese Prüfung nicht. Das messen Sie mit festen Fragen, wie es unser Ratgeber KI-Sichtbarkeit messen beschreibt.

Erledigt, wenn Ihr Prüfbericht nennt, was er nicht abdeckt.