.htaccess-Weiterleitung auf Apache

Zwei Module, zwei Schreibweisen

Apache bietet dir in der .htaccess zwei Wege für Weiterleitungen. Beide funktionieren, verhalten sich aber unterschiedlich – deshalb solltest du wissen, mit welchem du gerade arbeitest:

Modul	Direktiven	Geeignet für
mod_alias	Redirect, RedirectMatch, RedirectPermanent	Einfache Weiterleitungen von Pfad zu URL, gut lesbare Einzeiler
mod_rewrite	RewriteEngine, RewriteCond, RewriteRule	Bedingungen auf Host, Protokoll, Query-String oder Dateien; HTTPS- und www-Weiterleitungen

Zwei Dinge vorab: Die .htaccess wirkt nur, wenn der Server es erlaubt. Für Redirect- und Rewrite-Direktiven braucht das Verzeichnis AllowOverride FileInfo (oder All), mod_rewrite zusätzlich Options FollowSymLinks oder SymLinksIfOwnerMatch. Beim Shared Hosting ist das in aller Regel schon eingerichtet. Und falls du Zugriff auf die Konfiguration des VirtualHosts hast: Laut Apache-Dokumentation gehören die Regeln besser dorthin, weil Apache die .htaccess bei jedem Request neu einliest.

Einzelne Seite weiterleiten

Mit mod_alias reicht eine Zeile. Links steht der Pfad mit führendem Slash, rechts am besten die vollständige Ziel-URL:

Redirect 301 /alte-seite.html https://example.com/neue-seite/

Lässt du den Statuscode weg, schickt Redirect einen 302, also eine temporäre Weiterleitung. Bei dauerhaft umgezogenen Inhalten willst du fast immer 301 (oder permanent). Welcher Code wann passt, erklärt der Artikel 301 vs. 302.

Achtung: Redirect vergleicht nur den Anfang des Pfads. Redirect 301 /shop https://example.com/store leitet also auch /shop/schuhe nach /store/schuhe weiter – und sogar /shopping nach /storeping. Für ganze Ordner ist das praktisch, für einzelne Seiten eher eine Falle. Brauchst du einen exakten Treffer, nimm RedirectMatch mit Ankern:

RedirectMatch 301 ^/shop$ https://example.com/store/

Dasselbe mit mod_rewrite. In der .htaccess wird das Muster gegen den Pfad ohne führenden Slash geprüft:

RewriteEngine On
RewriteRule ^alte-seite\.html$ https://example.com/neue-seite/ [R=301,L]

Ordner oder Muster weiterleiten

RedirectMatch arbeitet mit regulären Ausdrücken. Was du in Klammern fängst, setzt du mit $1, $2 usw. im Ziel wieder ein:

RedirectMatch 301 ^/blog/(\d{4})/(.*)$ https://example.com/artikel/$2

Die Variante mit mod_rewrite:

RewriteEngine On
RewriteRule ^blog/\d{4}/(.*)$ https://example.com/artikel/$1 [R=301,L]

Setz immer ^ und $. Ein RedirectMatch 301 /alt https://example.com/ ohne Anker greift bei jeder URL, in der irgendwo /alt vorkommt.

Ganze Domain weiterleiten

Beim Domainwechsel soll jede alte URL auf denselben Pfad der neuen Domain zeigen. Hat die alte Domain ein eigenes Document Root, genügt diese Zeile – Redirect hängt den restlichen Pfad automatisch an:

Redirect 301 / https://example.com/

Teilen sich alte und neue Domain dasselbe Verzeichnis, würde das in einer Schleife enden. Dann brauchst du eine Bedingung auf den Hostnamen:

RewriteEngine On
RewriteCond %{HTTP_HOST} ^(www\.)?alte-domain\.de$ [NC]
RewriteRule ^ https://example.com%{REQUEST_URI} [R=301,L,NE]

Das Flag NE (no escape) verhindert, dass bereits kodierte Zeichen im Pfad doppelt kodiert werden. Worauf du beim Umzug sonst noch achten musst, steht in der Checkliste zum Domain-Umzug.

HTTP auf HTTPS

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L,NE]

Sitzt vor Apache ein Load Balancer, CDN oder Reverse Proxy, der TLS terminiert, kommt bei Apache jeder Request als HTTP an – und die Regel dreht sich im Kreis. Prüf dann stattdessen den Header, den der Proxy mitschickt:

RewriteEngine On
RewriteCond %{HTTP:X-Forwarded-Proto} !https
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L,NE]

Mehr dazu, inklusive HSTS, findest du im Ratgeber HTTP auf HTTPS weiterleiten.

www und ohne www in einem Schritt

Ein Klassiker: eine Regel für HTTPS, eine zweite für www. Dann durchläuft http://www.example.com/ zwei Weiterleitungen hintereinander. Dieser Block erledigt beides auf einmal und schickt Besucher immer direkt zu https://example.com:

RewriteEngine On
RewriteCond %{HTTPS} off [OR]
RewriteCond %{HTTP_HOST} ^www\. [NC]
RewriteCond %{HTTP_HOST} ^(?:www\.)?(.+)$ [NC]
RewriteRule ^ https://%1%{REQUEST_URI} [R=301,L,NE]

Die ersten beiden Bedingungen sind per OR verknüpft, die dritte gilt immer und speichert den Hostnamen ohne www. in %1. Willst du lieber auf die www-Variante, sieht es so aus:

RewriteEngine On
RewriteCond %{HTTPS} off [OR]
RewriteCond %{HTTP_HOST} !^www\. [NC]
RewriteCond %{HTTP_HOST} ^(?:www\.)?(.+)$ [NC]
RewriteRule ^ https://www.%1%{REQUEST_URI} [R=301,L,NE]

Welche Variante die bessere ist, liest du im Ratgeber zur www-Weiterleitung.

Trailing Slash

Slash am Ende ergänzen, sofern die URL keine echte Datei ist:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_URI} !/$
RewriteRule ^(.*)$ https://example.com/$1/ [R=301,L]

Oder den Slash entfernen – aber nicht bei echten Verzeichnissen. Dort hängt Apaches mod_dir den Slash selbst an, und du hättest eine Schleife:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.+)/$ https://example.com/$1 [R=301,L]

Query-Strings

Standardmäßig behalten beide Module den Query-String: Aus /alt?ref=mail wird /neu?ref=mail. Bei mod_rewrite steuerst du das über Flags:

• QSD verwirft den Query-String (ab Apache 2.4).
• QSA hängt den ursprünglichen Query-String an, wenn das Ziel selbst schon ein ? enthält.

Im Muster von RewriteRule taucht der Query-String nie auf. Willst du anhand eines Parameters weiterleiten, brauchst du eine RewriteCond:

RewriteEngine On
RewriteCond %{QUERY_STRING} (^|&)id=42(&|$)
RewriteRule ^produkt\.php$ https://example.com/produkte/blaues-widget/ [R=301,L,QSD]

Reihenfolge der Regeln und Schleifen vermeiden

• Spezielles vor Allgemeinem. Apache arbeitet die Regeln von oben nach unten ab. Einzelne Seiten-Redirects gehören über die Sammelregeln für Domain oder HTTPS – sonst greift zuerst die allgemeine Regel und du baust dir eine Kette.
• R immer mit L. Ohne L verarbeitet Apache die folgenden Regeln weiter und verändert womöglich das Ziel.
• mod_alias und mod_rewrite nicht mischen. Die beiden Module laufen unabhängig voneinander, die Reihenfolge in der Datei entscheidet also nicht, wer gewinnt. Bleib pro Datei bei einem Modul – sobald du Bedingungen brauchst, bei mod_rewrite.
• Das Ziel darf nicht wieder auf die Regel passen. RedirectMatch 301 ^/(.*)$ https://example.com/neu/$1 auf demselben Host leitet /neu/ endlos weiter. Schließ das Ziel per Bedingung oder genauerem Muster aus.
• Andere Ebenen im Blick behalten. CMS-Plugins, das Hosting-Panel oder ein CDN leiten womöglich ebenfalls weiter. Zwei Ebenen, die dieselbe URL umbiegen, sind die häufigste Ursache für Ketten und „Too many redirects“. Wie du sie aufspürst, zeigt der Artikel über Redirect-Ketten.

Regeln testen

Browser cachen 301-Weiterleitungen hartnäckig, teils unbegrenzt. Solange du noch experimentierst, nimm R=302 und stell erst auf R=301 um, wenn alles passt – oder teste im privaten Fenster. Noch besser ist ein Tool ganz ohne Cache: Gib die alte URL in den Redirect-Checker ein und prüf, ob du genau einen Hop, den richtigen Statuscode und das richtige Ziel bekommst. Denk auch an die Varianten: http://, www., mit und ohne Slash am Ende, mit Query-String.

Kommt nach dem Speichern ein 500 Internal Server Error, steckt ein Syntaxfehler in der Datei oder ein Modul ist nicht aktiv. Das Error-Log von Apache nennt dir die Zeile. Viele URLs auf einmal prüfst du am schnellsten mit dem Bulk-Redirect-Checker.

Keine Lust, Regeln von Hand zu schreiben? Der .htaccess-Redirect-Generator baut sie dir aus einer Liste alter und neuer URLs.