Der ultimative Guide für HTTP-Header-Manipulation (mit Praxisbeispielen)

HTTP-Header steuern die Kommunikation zwischen Browser und Server – oft unsichtbar, aber für jede Webanwendung unverzichtbar. Sie geben Anweisungen zur Darstellung, Weiterleitung, Caching und Sicherheit.

Mit der PHP-Funktion header() kannst du diese Header flexibel beeinflussen. Richtig eingesetzt, macht das den Unterschied zwischen einer professionellen, robusten Anwendung und fehleranfälligem Spaghetti-Code.

In diesem Guide lernst du praxisnah, wie du mit header() arbeitest, Fehler vermeidest, Sicherheit berücksichtigst und typische Use-Cases sauber umsetzt.

Teil 1: Die Grundlagen der PHP header() Funktion

Die Funktion header() ermöglicht es dir, direkt aus PHP heraus HTTP-Header an den Browser zu senden – so steuerst du das Verhalten von Clients, gibst Statuscodes aus oder löst Weiterleitungen und Datei-Downloads aus.

Was macht PHP header() genau?

Mit header() sendest du einen oder mehrere rohe HTTP-Header an den Browser, bevor der eigentliche Seiteninhalt (Body) kommt. Das ist entscheidend, denn HTTP sieht erst die Header, dann den Body vor.
Typische Anwendungsfälle sind Weiterleitungen, Dateidownloads, das Setzen des Content-Type oder Steuerung des Cachings.

Der entscheidende Grundsatz: Keine Ausgabe vor header()

Du musst header() immer aufrufen, bevor irgendetwas ausgegeben wird – kein HTML, keine Leerzeichen, kein Echo, kein UTF-8 BOM.
Sonst kommt es zum berühmten Fehler:
Warning: Cannot modify header information – headers already sent by...

Syntax und Parameter

header(string $sHeader, bool $bErsetzen = true, int $iStatuscode = 0); 

• $sHeader: Der eigentliche Header-String, z.B. "Location: /startseite".
• $bErsetzen: Standard ist true, d.h. vorhandene gleichnamige Header werden überschrieben. Setze auf false, um mehrere gleiche Header zu senden (z.B. bei Set-Cookie).
• $iStatuscode: Optional. Damit setzt du den HTTP-Status explizit.

Spezialfälle

• Status-Code setzen:

  header("HTTP/1.1 404 Not Found"); 
  

• Location-Header (Weiterleitung):

  header("Location: https://neue-seite.de"); 
  

Rückgabewert:
Die Funktion gibt keinen Wert zurück (void).

Wichtige Versionen:
Seit PHP 5.1.2 werden Header Injection Versuche verhindert (doppelte Header-Zeilen im String führen zu Fehlern).

Teil 2: Die häufigsten Anwendungsfälle von PHP header() (mit Code-Beispielen)

Mit gezielten HTTP-Headern kannst du Benutzer oder Suchmaschinen an eine andere URL weiterleiten – ideal für Umzüge, Login-Weiterleitungen oder das Vermeiden doppelter Inhalte.

1. URL-Weiterleitungen (Redirects)

Einfache Weiterleitung

header("Location: https://neue-seite.de"); 


/** Nach Location immer Skript beenden! */ 


exit; 

301 Moved Permanently (dauerhafte Weiterleitung, SEO-freundlich)

header("HTTP/1.1 301 Moved Permanently"); 


header("Location: /neuer-pfad"); 


exit; 

307 Temporary Redirect (temporär, Formulardaten bleiben erhalten)

header("HTTP/1.1 307 Temporary Redirect"); 


header("Location: /wartung"); 


exit; 

Weiterleitung mit Verzögerung (Refresh) – meist nicht empfohlen

header("Refresh: 5; URL=https://neue-seite.de"); 


/** Besser Location-Header verwenden, da Refresh für SEO und Usability problematisch ist. */ 

2. Content-Type deklarieren

Mit dem passenden Content-Type Header teilst du dem Browser mit, um welche Art von Inhalt es sich handelt – das stellt sicher, dass Texte, Bilder oder Dateien korrekt interpretiert und dargestellt werden.

Warum wichtig?
Der Content-Type sagt dem Browser, wie der Inhalt zu behandeln ist.

Beispiele:

header("Content-Type: text/html; charset=utf-8"); /** Für HTML */ 


header("Content-Type: application/json"); /** Für API-Ausgaben */ 


header("Content-Type: application/pdf"); /** Für PDF-Downloads */ 


header("Content-Type: text/css"); /** Für CSS-Dateien */ 


header("Content-Type: application/javascript"); /** Für JS-Dateien */ 

3. Caching-Verhalten steuern

Du kannst das Caching gezielt steuern oder komplett unterbinden, indem du entsprechende Header setzt – so bestimmst du, ob und wie lange Inhalte im Browser oder Proxy gespeichert werden dürfen.

Caching verhindern:

header("Cache-Control: no-store, no-cache, must-revalidate, max-age=0"); 


header("Cache-Control: post-check=0, pre-check=0", false); /** Für ältere IE-Versionen */ 


header("Pragma: no-cache"); /** HTTP/1.0-Kompatibilität */ 


header("Expires: 0"); /** Oder ein Datum in der Vergangenheit */ 

Caching erlauben (z. B. 1 Stunde):

header("Cache-Control: public, max-age=3600"); 


header("Expires: " . gmdate("D, d M Y H:i:s", time() + 3600) . " GMT"); 

4. Datei-Downloads erzwingen

Durch die richtigen HTTP-Header lässt sich ein Dateidownload im Browser auslösen, sodass beispielsweise PDFs nicht direkt angezeigt, sondern zum Herunterladen angeboten werden.

PDF-Download mit Download-Dialog:

header("Content-Type: application/pdf"); 


header("Content-Disposition: attachment; filename=\"mein-dokument.pdf\""); 


header("Content-Length: " . filesize("pfad/zur/datei.pdf")); 


readfile("pfad/zur/datei.pdf"); 


exit; 

5. HTTP-Statuscodes setzen

Das gezielte Setzen von HTTP-Statuscodes informiert Client und Suchmaschinen klar über den Zustand einer Anfrage – so kannst du Fehler, Weiterleitungen oder erfolgreiche Aufrufe eindeutig kennzeichnen.

Gängige Statuscodes:

• 200 OK
• 201 Created
• 204 No Content
• 400 Bad Request
• 401 Unauthorized
• 403 Forbidden
• 404 Not Found
• 500 Internal Server Error
• 503 Service Unavailable

Status setzen – zwei Wege:

header("HTTP/1.1 404 Not Found"); /** Über header() */ 


http_response_code(404); /** Bequeme Alternative seit PHP 5.4+ */ 

http_response_code() wirkt aber nicht, wenn schon ein expliziter Header gesetzt wurde.

Teil 3: Fehlerbehebung – Der “Headers already sent”-Albtraum

Der Fehler „Headers already sent“ tritt auf, wenn bereits eine Ausgabe erfolgt ist, bevor PHP versucht, HTTP-Header zu senden – selbst unsichtbare Leerzeichen oder Zeilenumbrüche außerhalb der PHP-Tags können diesen Fehler auslösen.

Warum tritt dieser Fehler auf?

Header müssen vor jeglicher Ausgabe (auch Whitespace) an den Client gesendet werden.
Typische Ursachen:

• Leerzeichen oder Zeilenumbrüche vor <?php oder nach ?>
• Ausgabe durch echo, print etc. vor dem header-Aufruf
• HTML vor header()
• UTF-8 BOM am Dateianfang
• Fehlerausgaben von PHP

Häufige Fehlerquellen:

• Ungewollte Leerzeilen, z. B. nach schließenden PHP-Tags
• Editor speichert Datei mit BOM
• Include/Require-Dateien enthalten Ausgabe
• Fehlermeldungen erscheinen vor header()

Debugging:
Mit headers_sent() kannst du prüfen, ob bereits Header gesendet wurden:

if (headers_sent($sDatei, $iZeile)) { 


 echo "Fehler: Header bereits gesendet in $sDatei, Zeile $iZeile"; 


} else { 


 header("Location: /startseite"); 


 exit; 


} 

Output Buffering als Notlösung:
Mit Output Buffering (ob_start()) lässt sich Ausgabe puffern und header() kann noch gesetzt werden.
Das ist aber nur ein Workaround, saubere Code-Struktur ist besser.

ob_start(); 


/** ...Code, der evtl. schon Ausgabe erzeugt... */ 


if ($bBedingung) { 


 header("Location: andere-seite.php"); 


 ob_end_flush(); 


 exit; 


} 


ob_end_flush(); 

Teil 4: Sicherheitsaspekte bei der Verwendung von PHP header()

Bei unsachgemäßer Behandlung von Benutzereingaben besteht die Gefahr sogenannter Header-Injection-Angriffe, die Manipulationen am HTTP-Header ermöglichen und erhebliche Sicherheitsrisiken mit sich bringen.

Header Injection Angriffe

Angreifer könnten versuchen, durch Steuerzeichen wie rn zusätzliche Header einzuschleusen.
Ab PHP 5.1.2 verhindert PHP solche Angriffe (mehrere Zeilen im Header werden blockiert).

Praxis:
Trotzdem niemals Benutzereingaben direkt in Header übernehmen – immer validieren!

/** Unsicher! */ 


header("Location: " . $_GET["sUrl"]); 


 
/** Sicherer Ansatz: Nur bekannte Ziele erlauben */ 


$aErlaubteZiele = ["/startseite", "/logout"]; 


if (in_array($_GET["sZiel"], $aErlaubteZiele, true)) { 


 header("Location: " . $_GET["sZiel"]); 


 exit; 


} 

Open Redirect Vulnerabilities

Bei dynamischen Weiterleitungen können Angreifer Nutzer auf externe Phishing-Seiten umleiten.

Absichern:

• Whitelisting
• Nur relative Pfade
• Indirekte Weiterleitungen über Schlüssel/IDs

Weitere Sicherheitsrelevante Header

• Content-Security-Policy (CSP):

  header("Content-Security-Policy: default-src 'self'; script-src 'self'"); 
  

• X-Frame-Options:
  Schutz vor Clickjacking

  header("X-Frame-Options: SAMEORIGIN"); 
  

• Strict-Transport-Security (HSTS):

  header("Strict-Transport-Security: max-age=63072000; includeSubDomains; preload"); 
  

• X-Content-Type-Options:

  header("X-Content-Type-Options: nosniff"); 
  

Teil 5: Fortgeschrittene Techniken und verwandte Funktionen

In manchen Situationen ist es nötig, denselben Header-Typ mehrfach zu senden – etwa bei der Übergabe von mehreren Cookies oder bei Headern wie „Set-Cookie“ und „Cache-Control“.

Mehrere Header gleichen Typs

Mit $bErsetzen = false kannst du z. B. mehrere Set-Cookie-Header senden.

header("Set-Cookie: cookie1=test1", false); 


header("Set-Cookie: cookie2=test2", false); 

HTTP-Antwortcode gezielt setzen

Siehe Unterschied header(“HTTP/1.1 …”) vs. http_response_code().
Letzteres ist kompakter, aber etwas weniger flexibel.

Überprüfen, ob Header bereits gesendet wurden

Siehe oben:

if (headers_sent()) { /* ... */ } 

Liste der gesetzten Header abrufen

$aHeader = headers_list(); 


/** Ausgabe zu Debugzwecken */ 


foreach ($aHeader as $sHeader) { 


 echo $sHeader . "<br>"; 


} 

Header entfernen

header_remove("X-Powered-By"); 

Ohne Parameter entfernt alle Header, die durch PHP gesetzt wurden.

CORS-Header setzen (Cross-Origin Resource Sharing)

Wenn du APIs bereitstellst:

header("Access-Control-Allow-Origin: https://example.com"); 

CORS ist ein großes Thema – im Zweifel dedizierte Tutorials konsultieren.

Teil 6: Best Practices für die Arbeit mit PHP header()

Mit diesen Best Practices stellst du sicher, dass deine HTTP-Header nicht nur korrekt, sondern auch sicher, übersichtlich und zuverlässig verarbeitet werden – unabhängig von Anwendungsfall oder Umgebung.

• Header-Logik immer ganz am Anfang des Skripts, vor jeglicher Ausgabe.
• Nach jeder Weiterleitung immer exit; oder die(); aufrufen.
• Validiere und sanitiere alle Werte, die aus Benutzereingaben stammen, bevor sie in Header eingefügt werden.
• Setze klare, passende Statuscodes – das hilft Debugging und SEO.
• Nutze Output Buffering nur bewusst, nicht als Ausrede für unstrukturierten Code.
• Sende nur benötigte Header – alles andere erhöht die Angriffsfläche und sollte daher manuell angegeben werden.
• Teste Header-Verhalten in verschiedenen Browsern und mit Tools wie curl oder den Browser-Dev-Tools.

Interaktiver Bereich / Schnelle Referenz

Im folgenden Abschnitt findest du häufige Stolperfallen bei der Arbeit mit HTTP-Headern in PHP sowie praxisnahe Lösungswege – für schnellen Überblick und effektive Fehlersuche.

Typische Fehlerquellen und Lösungen

Problem: "Headers already sent"

• Stelle sicher, dass sich keine Leer- oder Steuerzeichen vor oder nach den PHP-Tags befinden.
• Gib keine Daten (auch kein Whitespace) vor dem Aufruf von header() aus.
• Achte darauf, dass dein Editor keine Byte Order Mark (BOM) speichert.
• Prüfe mit headers_sent(), ob schon Header verschickt wurden.

Problem: Weiterleitung schlägt fehl

• Kontrolliere, ob bereits eine Ausgabe stattgefunden hat.
• Vergiss nicht, nach dem Aufruf von header('Location: ...') ein exit; zu setzen.

Problem: Datei-Download startet nicht oder falscher Typ

• Überprüfe den korrekten Content-Type Header.
• Setze einen passenden Content-Disposition Header für Downloads.
• Gib die tatsächliche Content-Length an.

Problem: Caching greift nicht wie erwartet

• Setze sämtliche relevanten Header (Cache-Control, Pragma, Expires).
• Prüfe die Header mit den Entwicklertools deines Browsers.

Cheat Sheet

Fazit

PHP header() ist ein mächtiges Werkzeug, das dir volle Kontrolle über die HTTP-Kommunikation gibt – von einfachen Weiterleitungen über Dateidownloads bis hin zur Absicherung deiner Anwendung mit Security-Headern.

Der Schlüssel zum Erfolg liegt darin, die Basics zu beherrschen, Fehlerquellen zu kennen und defensiv zu programmieren. Arbeite sauber, teste regelmäßig, und baue Sicherheitsmaßnahmen von Anfang an ein.

So entwickelst du Anwendungen, die nicht nur funktionieren, sondern auch sicher, performant und wartbar sind.

Wer tiefer einsteigen will: Beschäftige dich mit Themen wie CORS, Content Security Policy und modernen Security-Headern. Damit setzt du professionelle Standards für deine Webprojekte.