Redirect-Ketten und Redirect-Schleifen

Was ist eine Redirect-Kette?

Eine Redirect-Kette (englisch redirect chain) besteht aus zwei oder mehr Weiterleitungen zwischen der aufgerufenen URL und der eigentlichen Seite. Statt direkt von A zum Ziel geht es von A nach B, von B nach C – und erst dann gibt es Inhalt:

http://example.com/shop
  301 → https://example.com/shop
  301 → https://www.example.com/shop
  301 → https://www.example.com/shop/
  200 OK

Für sich genommen ist jeder dieser Redirects korrekt. Zusammen zwingen sie jeden Besucher und jeden Crawler zu drei zusätzlichen Roundtrips.

Eine Redirect-Schleife (redirect loop) ist eine Kette ohne Ende: Eine URL leitet direkt oder über Umwege wieder auf sich selbst um.

https://example.com/
  301 → https://www.example.com/
  301 → https://example.com/
  301 → https://www.example.com/
  ...

Browser brechen nach einer festen Zahl von Weiterleitungen ab (20 in Chrome und Firefox) und zeigen eine Fehlermeldung – in Chrome ERR_TOO_MANY_REDIRECTS, in Firefox „Die Seite leitet nicht richtig weiter“. Die Seite ist dann für niemanden mehr erreichbar.

Warum Ketten schaden

• Ladezeit: Jeder Hop ist ein vollständiger HTTP-Request samt Antwort. Wechselt dabei der Hostname, braucht der Browser unter Umständen zusätzlich einen DNS-Lookup, eine neue TCP-Verbindung und einen TLS-Handshake. Im Mobilfunknetz summiert sich das schnell zu einer spürbaren Verzögerung, bevor das erste Byte der echten Seite ankommt.
• Crawl-Budget: Der Googlebot muss jede Zwischen-URL abrufen. Auf großen Websites fehlt die Crawl-Kapazität, die für Redirect-Hops draufgeht, bei neuen oder aktualisierten Inhalten.
• Harte Grenzen: Google folgt bis zu 10 Hops. Kommt es innerhalb dieser Grenze nicht beim Inhalt an, meldet die Search Console einen Weiterleitungsfehler, und die URL wird nicht indexiert. Andere Crawler, Link-Vorschau-Bots und HTTP-Clients geben oft deutlich früher auf.
• Fehleranfälligkeit: Je länger die Kette, desto mehr Stellen können kaputtgehen. Ein abgelaufenes Zertifikat oder eine gelöschte Regel mittendrin – und die ganze Kette ist tot.

Was Ketten nicht tun: Laut Google vererben permanente und temporäre Redirects PageRank, eine kurze Kette „verliert“ also nicht pro Hop Linkkraft. Das Problem sind Tempo, Crawling und Zuverlässigkeit. Ziel bleibt trotzdem: jeder Redirect in einem einzigen Hop.

Wie Ketten entstehen

Kaum jemand baut Ketten absichtlich. Sie wachsen mit der Zeit:

• Getrennte Normalisierungsregeln: eine Regel für HTTP auf HTTPS, eine für www, eine für den abschließenden Slash, die nacheinander greifen. Die Lösung steht in HTTP auf HTTPS und im Guide zum www-Redirect.
• Relaunch auf Relaunch: 2019 wurde /produkte.html auf /produkte/ umgeleitet, 2023 zog /produkte/ nach /shop/. Den ersten Redirect hat niemand angepasst.
• Domain-Umzüge: Die alte Domain leitet auf denselben Pfad der neuen Domain um, und dort wird dieser Pfad noch einmal weitergeleitet. Siehe die Checkliste zum Domain-Umzug.
• Mehrere Ebenen: CDN, Webserver, Anwendung und ein CMS-Plugin setzen jeweils eigene Redirects.
• Interne Links auf alte URLs: Navigation, Sitemap oder Canonical-Tags zeigen auf URLs, die weiterleiten – die Kette beginnt also schon auf deiner eigenen Website.
• Tracking- und Kurz-URLs vor einer Landingpage, die ohnehin schon weitergeleitet wird.

Typische Ursachen für Schleifen und ERR_TOO_MANY_REDIRECTS

Ein Klassiker für eine Regel, die ihr eigenes Ziel trifft, in Apache:

# Falsch: greift auch bei /neuer-shop/ und leitet erneut um
RewriteRule shop https://example.com/neuer-shop/ [L,R=301]

# Richtig: greift nur bei exakt /shop oder /shop/
RewriteRule ^shop/?$ https://example.com/neuer-shop/ [L,R=301]

Plattformspezifische Schleifen und ihre Lösungen findest du in den Guides zu Cloudflare, WordPress und .htaccess.

So findest du Ketten und Schleifen

1. Einzelne URLs: Gib die URL in den Redirect Checker ein. Er listet jeden Hop mit Statuscode, Ziel und Antwortzeit auf und erkennt Schleifen. Teste alle Varianten: http://, https://, mit und ohne www, mit und ohne abschließenden Slash.
2. URL-Listen: Kopier alte URLs, Backlink-Ziele oder deine Redirect-Map in den Bulk-Checker und sortier nach der Anzahl der Hops.
3. Ganze Websites: Ein Desktop-Crawler wie Screaming Frog oder ein Site-Audit-Tool findet interne Links, die auf Redirects zeigen, und meldet Ketten auf der gesamten Website.
4. Search Console: Im Seitenindexierungsbericht tauchen URLs mit „Weiterleitungsfehler“ auf. Dahinter stecken meist Schleifen, zu lange Ketten oder Redirects auf ungültige URLs.
5. Kommandozeile: Für einen schnellen Check zeigt dir curl jeden Hop:

   curl -sIL http://example.com/shop | grep -iE '^(HTTP|location)'

So löst du Redirect-Ketten auf

1. Jede Quelle direkt aufs finale Ziel zeigen lassen. Geh deine Redirect-Regeln durch und ersetz jedes Ziel, das selbst weiterleitet, durch die endgültige URL. In der Redirect-Map heißt das: Gibt es B → C, wird aus A → B einfach A → C.
2. Normalisierungsregeln zusammenfassen. Protokoll, Host und Slash gehören in einen einzigen Redirect. Zum Beispiel in nginx:

   server {
       listen 80;
       listen [::]:80;
       server_name example.com www.example.com;
       return 301 https://www.example.com$request_uri;
   }

3. Jede Regel nur an einer Stelle durchsetzen. Entweder im CDN, auf dem Server oder in der Anwendung – nicht überall gleichzeitig.
4. Interne Links, Canonical-Tags und Sitemaps anpassen, sodass sie auf finale URLs zeigen. Deine eigene Website sollte nie einen Redirect auslösen.
5. Alte Redirects behalten. Lösch keine Zwischen-Redirects, sondern ändere nur ihr Ziel. Externe Links können auf jede URL der Kette zeigen.
6. Erneut testen mit dem Redirect Checker: Jede Variante sollte mit genau einem Hop bei einem 200 landen.

Ein einziger Hop ist das Ziel. Welcher Statuscode für diesen Hop der richtige ist, erfährst du in 301 vs. 302.