Server-Log-Analyse fuer SEO: Der vollstaendige Leitfaden (2026)

In der Suchmaschinenoptimierung stehen Ranking-Faktoren, Inhaltsqualitaet und Backlink-Profile im Vordergrund, waehrend die Realitaet hinter den Kulissen — wie Suchmaschinen-Bots Ihre Website tatsaechlich crawlen — oft uebersehen wird. Der einzig zuverlaessige Weg zu verstehen, welche Seiten Googlebot besucht, welche er ueberspringt, welche HTTP-Statuscodes er erhaelt und wie lange Ihr Server fuer die Antwort braucht, fuehrt ueber Server-Log-Dateien. Die Crawl-Statistiken der Google Search Console bieten einen allgemeinen Ueberblick, aber Log-Dateien liefern Ihnen die rohe, ungefilterte Wahrheit.

Stand 2026 geht die Log-Analyse weit ueber traditionelle Suchmaschinen-Bots hinaus. KI-Crawler wie GPTBot, ClaudeBot und PerplexityBot senden regelmaessig Anfragen an Ihre Server. Zu wissen, auf welche Inhalte diese Bots zugreifen, wie haeufig sie vorbeikommen und wie viel Serverlast sie erzeugen, ist ein integraler Bestandteil moderner SEO-Strategie geworden.

In diesem Leitfaden fuehren wir Sie Schritt fuer Schritt durch die Grundlagen der Server-Log-Analyse — von Log-Formaten ueber die Interpretation des Googlebot-Crawl-Verhaltens bis hin zur Erkennung von Crawl-Budget-Problemen und der Ableitung konkreter SEO-Massnahmen aus Log-Daten.

Was ist eine Log-Datei und warum ist sie fuer SEO wichtig?

Eine Server-Log-Datei ist eine textbasierte Datei, die jede HTTP-Anfrage, die Ihr Webserver empfaengt, in chronologischer Reihenfolge aufzeichnet. Jede Zeile enthaelt die IP-Adresse der Anfrage, Datum und Uhrzeit, die angeforderte URL, den HTTP-Statuscode, die Antwortgroesse und User-Agent-Informationen.

Aus SEO-Perspektive beantworten Log-Dateien kritische Fragen:

• Welche Seiten crawlt Googlebot? Gibt es Seiten in Ihrer Sitemap, die nie gecrawlt werden?
• Wie hoch ist die Crawl-Frequenz? Wie oft werden Ihre wichtigen Seiten besucht?
• Sind die HTTP-Statuscodes gesund? Gibt es 404-Fehler, 5xx-Fehler oder unnoetige Weiterleitungen?
• Wie schnell ist die Server-Antwort? Erhaelt Googlebot langsame Antworten?
• Wird das Crawl-Budget effizient genutzt? Verbringt der Bot Zeit auf wertarmen Seiten?
• Welche KI-Bots greifen auf Ihre Inhalte zu? Was machen GPTBot, ClaudeBot und aehnliche Crawler?

Der Crawl-Statistik-Bericht der Google Search Console beantwortet einige dieser Fragen, aber die Daten sind stichprobenartig und verzoegert. Log-Dateien liefern Echtzeit-Daten, ungefiltert und vollstaendig. Die Kombination eines umfassenden Google Search Console Leitfadens mit Log-Analyse ist der genaueste Ansatz.

Arten von Log-Dateien

Webserver erzeugen typischerweise zwei Haupttypen von Logs:

Zugriffsprotokolle (Access Logs)

Zugriffsprotokolle zeichnen jede erfolgreiche oder fehlgeschlagene Anfrage an den Server auf. Sie sind die primaere Datenquelle fuer die SEO-Log-Analyse. Eine typische Zeile im Apache Combined Log Format sieht so aus:

```

66.249.79.58 - - [15/Feb/2026:10:23:45 +0300] "GET /produkte/rotes-kleid HTTP/2" 200 34521 "-" "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"

```

Aufschluesselung dieser Zeile:

Fehlerprotokolle (Error Logs)

Fehlerprotokolle zeichnen serverseitige Fehler auf. Sie werden verwendet, um Probleme wie 500 Internal Server Error, Timeouts und Speicherueberlauefe zu erkennen:

```

[Wed Feb 15 10:24:01 2026] [error] [client 66.249.79.58] PHP Fatal error: Allowed memory size of 134217728 bytes exhausted in /var/www/html/product.php on line 245

```

Fehlerprotokolle helfen Ihnen, Seiten zu identifizieren, auf denen Googlebot 5xx-Fehler erhaelt. Seiten, die dauerhaft 5xx-Fehler zurueckgeben, koennen schliesslich aus dem Google-Index fallen.

Zugriff auf Log-Dateien nach Servertyp

Apache

Apache schreibt Logs standardmaessig nach /var/log/apache2/ (Debian/Ubuntu) oder /var/log/httpd/ (CentOS/RHEL).

```bash

Zugriffsprotokolle anzeigen

tail -f /var/log/apache2/access.log

Fehlerprotokolle anzeigen

tail -f /var/log/apache2/error.log

Log-Format pruefen (httpd.conf oder apache2.conf)

LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined

```

Nginx

Nginx-Logs befinden sich standardmaessig in /var/log/nginx/.

```bash

Zugriffsprotokolle

tail -f /var/log/nginx/access.log

Fehlerprotokolle

tail -f /var/log/nginx/error.log

Log-Format-Definition in nginx.conf

log_format main ''$remote_addr - $remote_user [$time_local] "$request" ''

''$status $body_bytes_sent "$http_referer" ''

''"$http_user_agent" $request_time'';

```

Das Feld $request_time in Nginx zeichnet die Server-Antwortzeit in Sekunden auf. Dieses Feld ist fuer die SEO-Log-Analyse aeusserst wertvoll, da es Ihnen ermoeglicht, Seiten direkt zu identifizieren, bei denen Googlebot langsame Antworten erhaelt.

IIS (Windows Server)

IIS-Logs werden standardmaessig unter C:\inetpub\logs\LogFiles\ im W3C Extended Log Format gespeichert.

```

#Fields: date time s-ip cs-method cs-uri-stem cs-uri-query s-port cs-username c-ip cs(User-Agent) sc-status sc-bytes time-taken

2026-02-15 10:23:45 192.168.1.1 GET /produkte/rotes-kleid - 443 - 66.249.79.58 Mozilla/5.0+(compatible;+Googlebot/2.1) 200 34521 156

```

Beachten Sie, dass IIS time-taken in Millisekunden angibt (im Gegensatz zum Sekunden-Format von Nginx).

Cloud-Plattformen

• AWS: CloudFront-Logs schreiben nach S3, ALB-Logs ebenfalls nach S3. CloudWatch Logs ermoeglicht Echtzeit-Monitoring.
• Google Cloud: Zugriff ueber Cloud Logging (frueher Stackdriver). Export nach BigQuery fuer SQL-basierte Analyse.
• Cloudflare: Verfuegbar ueber das Dashboard oder Logpush nach S3, GCS oder R2.
• Vercel: Die integrierte Logging-Infrastruktur ist begrenzt; Drittanbieter-Integrationen (Datadog, Axiom) koennen erforderlich sein.

Analyse des Googlebot-Crawl-Verhaltens

Einer der wertvollsten Ergebnisse der Log-Analyse ist das Verstaendnis des Googlebot-Crawl-Verhaltens. Hier ist ein schrittweiser Ansatz:

1. Googlebot-Anfragen filtern

Der erste Schritt besteht darin, nur Googlebot-Anfragen aus der Log-Datei zu extrahieren:

```bash

Googlebot-Anfragen filtern

grep "Googlebot" /var/log/nginx/access.log > googlebot_requests.log

Googlebot-Anfragen zaehlen

grep -c "Googlebot" /var/log/nginx/access.log

Taegliche Googlebot-Anfragezahl

grep "Googlebot" /var/log/nginx/access.log | awk ''{print $4}'' | cut -d: -f1 | sort | uniq -c | sort -rn

```

2. Echten Googlebot verifizieren

Den User-Agent auf "Googlebot" zu setzen ist trivial. Verwenden Sie Reverse-DNS-Verifizierung, um gefaelschte Bots zu unterscheiden:

```bash

Pruefen, ob die IP zum echten Googlebot gehoert

host 66.249.79.58

Erwartet: 58.79.249.66.in-addr.arpa domain name pointer crawl-66-249-79-58.googlebot.com

Bestaetigung: Hostname zurueck zur IP aufloesen

host crawl-66-249-79-58.googlebot.com

Erwartet: crawl-66-249-79-58.googlebot.com has address 66.249.79.58

```

Sie koennen auch eine Massenverifizierung mit Googles offizieller IP-Bereiche-JSON-Datei durchfuehren: https://developers.google.com/search/apis/ipranges/googlebot.json

3. Am haeufigsten gecrawlte Seiten identifizieren

```bash

Von Googlebot am haeufigsten besuchte Seiten

grep "Googlebot" access.log | awk ''{print $7}'' | sort | uniq -c | sort -rn | head -20

```

Diese Ausgabe zeigt, wo Googlebot sein Crawl-Budget verbringt. Wenn wertarme Seiten (Filterparameter, Session-URLs, alte Archivseiten) die Liste dominieren, haben Sie ein ernsthaftes Crawl-Budget-Problem.

4. HTTP-Statuscode-Verteilung

```bash

Verteilung der von Googlebot erhaltenen Statuscodes

grep "Googlebot" access.log | awk ''{print $9}'' | sort | uniq -c | sort -rn

```

Eine gesunde Website sollte ungefaehr diese Verteilung aufweisen:

Wenn die 5xx-Rate 1% uebersteigt, sollte die Server-Stabilitaet sofort untersucht werden. Bei hoher 404-Rate erstellen Sie einen Weiterleitungsplan fuer defekte Links oder geloeschte Seiten.

Crawl-Budget und Log-Analyse

Das Crawl-Budget ist das Limit, das bestimmt, wie viele Seiten Google innerhalb eines bestimmten Zeitraums auf Ihrer Website crawlt. Bei grossen Websites (10.000+ Seiten) wirkt sich das Crawl-Budget-Management direkt auf die Indexierungsleistung aus. Unser Crawl-Budget-Optimierung Leitfaden behandelt das Thema ausfuehrlich, aber hier betrachten wir es aus der Perspektive der Log-Analyse.

Crawl-Budget-Verschwendung erkennen

Suchen Sie in Log-Dateien nach diesen Mustern:

Parameter-Verschmutzung: Dieselbe Seite wird wiederholt mit verschiedenen Parameterkombinationen gecrawlt.

```bash

Crawl-Anzahl fuer URLs mit Parametern

grep "Googlebot" access.log | awk ''{print $7}'' | grep "?" | cut -d"?" -f1 | sort | uniq -c | sort -rn | head -10

```

Wenn /produkte/kleid?farbe=rot&groesse=m und /produkte/kleid?groesse=m&farbe=rot auf denselben Inhalt mit unterschiedlichen Parametern zugreifen, ueberpruefen Sie Ihre Canonical-Tags und URL-Parameter-Konfiguration.

Crawlen wertarmer Seiten: Unverhaeltnismaessiges Crawlen von Suchergebnisseiten, Tag-Seiten und internen Suchergebnissen.

```bash

Crawl-Rate interner Suchergebnisse

grep "Googlebot" access.log | grep "/search?" | wc -l

```

Weiterleitungsketten: Die Weiterleitung von einer URL zu einer anderen und dann zu einer dritten URL verdreifacht die Crawl-Budget-Kosten.

```bash

301/302-Weiterleitungen auflisten

grep "Googlebot" access.log | awk ''$9 == 301 || $9 == 302 {print $7}'' | sort | uniq -c | sort -rn | head -20

```

Crawl-Rate und Server-Antwortzeit

Googlebot reduziert seine Crawl-Rate automatisch, wenn die Server-Antwortzeit steigt. Um die Antwortzeit aus Nginx-Logs zu analysieren:

```bash

Durchschnittliche Antwortzeit fuer Googlebot-Anfragen (Nginx $request_time)

grep "Googlebot" access.log | awk ''{print $NF}'' | awk ''{sum+=$1; count++} END {print "Durchschnitt:", sum/count, "Sekunden"}'';

Seiten mit Antwortzeit ueber 2 Sekunden

grep "Googlebot" access.log | awk ''{if ($NF > 2.0) print $7, $NF}'' | sort -k2 -rn | head -20

```

Eine Server-Antwortzeit unter 200 ms ist ideal. Ueber 500 ms ist bedenklich, und ueber 1 Sekunde ist kritisch. Detaillierte Informationen zur Seitengeschwindigkeits-Optimierung finden Sie in unserem Seitengeschwindigkeits-Optimierung Leitfaden.

Bot-Identifizierung: Googlebot, Bingbot und KI-Bots

Hier sind die wichtigsten Bots, die Sie 2026 in Ihren Server-Logs finden werden:

Suchmaschinen-Bots

KI-Crawler (2025-2026)

KI-Bot-Traffic analysieren:

```bash

Gesamtzahl der KI-Bot-Anfragen

grep -E "GPTBot|ChatGPT-User|ClaudeBot|PerplexityBot|Google-Extended|Bytespider|Applebot-Extended" access.log | wc -l

Aufschluesselung nach Bot

grep -E "GPTBot|ChatGPT-User|ClaudeBot|PerplexityBot|Google-Extended|Bytespider" access.log | grep -oP "(GPTBot|ChatGPT-User|ClaudeBot|PerplexityBot|Google-Extended|Bytespider)" | sort | uniq -c | sort -rn

```

Um KI-Bots zu blockieren, koennen Sie robots.txt verwenden:

```

robots.txt — KI-Bots blockieren, Suchmaschinen erlauben

User-agent: GPTBot

Disallow: /

User-agent: ClaudeBot

Disallow: /

User-agent: Bytespider

Disallow: /

Google-Suchcrawler erlauben

User-agent: Googlebot

Allow: /

```

Log-Analyse-Tools

Screaming Frog Log Analyzer

Screaming Frogs dediziertes Log-Analyse-Tool ist die beliebteste Desktop-Loesung fuer SEO-fokussierte Log-Analyse. Funktionen umfassen:

• Automatische Klassifizierung von Googlebot-, Bingbot- und anderen Bot-Anfragen
• Crawl-Budget-Berichte und Crawl-Frequenz-Analysen
• Statuscode-Verteilung und Weiterleitungsketten-Erkennung
• Sitemap-Vergleich (welche Seiten sind in der Sitemap, werden aber nie gecrawlt?)
• Erkennung verwaister Seiten (Orphan Pages)

ELK Stack (Elasticsearch, Logstash, Kibana)

Der Industriestandard fuer grosse Websites. Logstash sammelt Logs, Elasticsearch speichert sie und Kibana visualisiert sie. Sie koennen anpassbare Dashboards erstellen, um das Googlebot-Verhalten in Echtzeit zu ueberwachen.

```

Logstash-Filter-Beispiel — Apache Combined Log Format

filter {

grok {

match => { "message" => "%{COMBINEDAPACHELOG}" }

}

if [agent] =~ "Googlebot" {

mutate { add_tag => ["googlebot"] }

}

if [agent] =~ "GPTBot|ClaudeBot|PerplexityBot" {

mutate { add_tag => ["ai_crawler"] }

}

}

```

GoAccess

Ein leichtgewichtiges, terminalbasiertes Echtzeit-Log-Analyse-Tool. Ideal fuer schnelle Ueberblicke:

```bash

Echtzeit-Analyse

goaccess /var/log/nginx/access.log --log-format=COMBINED -o report.html

Nur Googlebot-Traffic analysieren

grep "Googlebot" /var/log/nginx/access.log | goaccess --log-format=COMBINED -o googlebot-report.html

```

Benutzerdefinierte Log-Analyse mit Python

Fuer spezifische Anforderungen koennen Sie Python-Skripte zur Analyse von Log-Dateien schreiben:

```python

import re

from collections import Counter

from datetime import datetime

def parse_log_line(line):

pattern = r''(\S+) \S+ \S+ \[(.+?)\] "(\S+) (\S+) \S+" (\d{3}) (\d+|-) ".?" "(.?)"''

match = re.match(pattern, line)

if match:

return {

"ip": match.group(1),

"datetime": match.group(2),

"method": match.group(3),

"url": match.group(4),

"status": int(match.group(5)),

"size": match.group(6),

"user_agent": match.group(7),

}

return None

def analyze_googlebot(log_file):

urls = Counter()

status_codes = Counter()

daily_crawls = Counter()

with open(log_file, "r") as f:

for line in f:

parsed = parse_log_line(line)

if parsed and "Googlebot" in parsed["user_agent"]:

urls[parsed["url"]] += 1

status_codes[parsed["status"]] += 1

date_str = parsed["datetime"].split(":")[0]

daily_crawls[date_str] += 1

print("=== Top 20 Am Haeufigsten Gecrawlte Seiten ===")

for url, count in urls.most_common(20):

print(f" {count:>6} | {url}")

print("\n=== Statuscode-Verteilung ===")

total = sum(status_codes.values())

for code, count in status_codes.most_common():

print(f" {code}: {count} ({count/total*100:.1f}%)")

print("\n=== Taegliche Crawl-Anzahl ===")

for date, count in sorted(daily_crawls.items()):

print(f" {date}: {count}")

analyze_googlebot("/var/log/nginx/access.log")

```

SEOctopus Crawl-Budget-Ueberwachung

Das technische SEO-Modul von SEOctopus verfolgt automatisch Crawl-Budget-Metriken und meldet Crawling-Probleme. In Kombination mit Ihren Log-Daten koennen Sie umfassend sehen, welche Seiten nicht gecrawlt werden und welche Seiten unnoetigerweise gecrawlt werden. Die Kombination einer gruendlichen technischen SEO-Checkliste mit Log-Analyse ist der effektivste Ansatz.

Haeufige SEO-Probleme in Log-Dateien

1. Verwaiste Seiten (Orphan Pages)

Seiten, die Googlebot crawlt, die aber nicht in der internen Linkstruktur der Website vorhanden sind, werden als "verwaiste Seiten" bezeichnet. Diese sind typischerweise:

• Alte Kampagnenseiten
• Produktseiten aus geloeschten Kategorien
• Alte Seiten mit geaenderter URL-Struktur

Erkennungsmethode: Vergleichen Sie die URLs in der Log-Datei mit Ihrer Sitemap und Ihren Crawl-Daten. Seiten, die in Logs erscheinen, aber in der Sitemap fehlen und keine internen Links erhalten, sind verwaiste Seiten.

2. Weiterleitungsketten und -schleifen

```bash

Mehrfache 301-Weiterleitungen von derselben URL

grep "Googlebot" access.log | awk ''$9 == 301 {print $7}'' | sort | uniq -c | sort -rn | head -10

```

Wenn Sie Kettenweiterleitungen wie A -> B -> C finden, korrigieren Sie diese zu A -> C direkt. Dies bewahrt sowohl das Crawl-Budget als auch reduziert den Link-Equity-Verlust.

3. Soft-404-Fehler

Der Server gibt einen 200-Statuscode zurueck, aber die Seite zeigt tatsaechlich "Nicht gefunden"-Inhalt an. Seiten in der Log-Datei mit 200-Statuscodes, aber sehr geringer Byte-Groesse, sind Soft-404-Kandidaten:

```bash

200-Antworten mit sehr geringer Groesse (potenzielle Soft-404)

grep "Googlebot" access.log | awk ''$9 == 200 && $10 < 1000 {print $7, $10}'' | sort -k2 -n | head -20

```

4. Grosse Antwortgroessen

Ueberdimensionierte HTML-Antworten verbrauchen Serverressourcen und erschweren es Googlebot, die Seite vollstaendig zu rendern:

```bash

Antworten ueber 1 MB

grep "Googlebot" access.log | awk ''$10 > 1048576 {print $7, $10/1048576, "MB"}'' | sort -k2 -rn

```

5. Langsame Server-Antworten

```bash

Die 20 langsamsten Seiten (Nginx request_time)

grep "Googlebot" access.log | awk ''{print $7, $NF}'' | sort -k2 -rn | head -20

```

Nachdem Sie langsam antwortende Seiten identifiziert haben, untersuchen Sie Ursachen wie Datenbankabfragen, externe API-Aufrufe oder Server-Konfiguration. Unser Core Web Vitals Leitfaden bietet detaillierte Techniken zur Optimierung der Server-Antwortzeit.

6. Kritische Ressourcen durch Robots.txt blockiert

In Log-Dateien werden Sie bemerken, dass Googlebot die robots.txt-Datei haeufig prueft. Wenn robots.txt CSS-, JS- oder Bilddateien blockiert, kann Google Ihre Seiten nicht korrekt rendern:

```bash

Googlebot robots.txt-Anfragehaeufigkeit

grep "Googlebot" access.log | grep "robots.txt" | wc -l

```

Praktischer Log-Analyse-Workflow

Hier ist ein schrittweiser Workflow fuer eine umfassende SEO-Log-Analyse:

Schritt 1: Log-Dateien sammeln

Sammeln Sie mindestens 30 Tage Log-Daten. Ein Monat Daten ist die Mindestanforderung, um die Crawl-Muster des Googlebots zu verstehen.

Schritt 2: Daten bereinigen und filtern

• Statische Datei-Anfragen (CSS, JS, Bilder, Schriften) separieren
• Bot-Anfragen von Benutzer-Anfragen trennen
• Echte Bot-Verifizierung durchfuehren (Reverse DNS)

Schritt 3: Wichtige Metriken extrahieren

• Taegliche Gesamt-Crawl-Anzahl (Trendanalyse)
• Statuscode-Verteilung
• Am meisten und am wenigsten gecrawlte Seiten
• Durchschnittliche Antwortzeit
• Anzahl eindeutiger URLs

Schritt 4: Crawl-Budget-Effizienz bewerten

• Den organischen Traffic-Wert gecrawlter Seiten berechnen
• Den Crawl-Anteil fuer wertarme Seiten bestimmen
• Die Crawl-Rate der Sitemap-Seiten pruefen

Schritt 5: Probleme priorisieren und handeln

Schritt 6: Laufende Ueberwachung

Richten Sie die Log-Analyse als kontinuierlichen Ueberwachungsprozess ein, nicht als einmalige Aktion. Erstellen Sie woechentliche oder monatliche Berichte, um Trends zu verfolgen. Wiederholen Sie die Log-Analyse regelmaessig als integralen Bestandteil eines umfassenden SEO-Audit-Prozesses.

Log-Analyse-Checkliste

Verwenden Sie diese Checkliste bei jedem Log-Analyse-Zyklus:

• [ ] Mindestens 30 Tage Log-Daten gesammelt
• [ ] Gefaelschte Bot-Anfragen gefiltert (Reverse-DNS-Verifizierung)
• [ ] Googlebot-Crawl-Frequenz-Trend ueberprueft
• [ ] Statuscode-Verteilung analysiert (Ziel: 5xx < 0,5%)
• [ ] URL-Muster identifiziert, die Crawl-Budget verschwenden
• [ ] Weiterleitungsketten erkannt und Korrekturplan erstellt
• [ ] Verwaiste Seiten identifiziert
• [ ] Durchschnittliche Server-Antwortzeit geprueft (Ziel: < 200 ms)
• [ ] KI-Bot-Traffic analysiert und robots.txt-Richtlinie ueberprueft
• [ ] Sitemap- vs. Log-Vergleich durchgefuehrt
• [ ] Ergebnisse priorisiert und Massnahmenplan erstellt

Fazit

Die Server-Log-Datei-Analyse ist eines der maechtigsten, aber am wenigsten genutzten Werkzeuge im technischen SEO. Waehrend die Google Search Console und Crawling-Tools von Drittanbietern wertvolle Daten liefern, zeigen nur Log-Dateien, wie Googlebot Ihre Website tatsaechlich erlebt. Im Jahr 2026 ist die Log-Analyse durch den Aufstieg der KI-Crawler noch kritischer geworden — Sie muessen nicht nur das Verhalten von Suchmaschinen-Bots verstehen, sondern auch, wie KI-Plattformen Ihre Inhalte konsumieren.

Regelmaessige Log-Analyse ermoeglicht es Ihnen, Crawl-Budget-Probleme fruehzeitig zu erkennen, Serverfehler proaktiv zu beheben und Ihre Indexierungsleistung kontinuierlich zu verbessern. Die technischen SEO-Module von SEOctopus automatisieren diesen Prozess und sparen Ihnen wertvolle Zeit.

Verwandte Artikel

• Technisches SEO Leitfaden
• Crawl-Budget-Optimierung Leitfaden 2026
• SEO-Audit Leitfaden
• Seitengeschwindigkeits-Optimierung Leitfaden 2026
• Google Search Console Leitfaden 2026
• Core Web Vitals Leitfaden: LCP, INP und CLS 2026