---
title: "HTTP/1.1, HTTP/2 und HTTP/3: Was hat sich geändert?"
description: "HTTP/1.1, HTTP/2 und HTTP/3 übertragen dieselben Anfragen auf verschiedene Weise: nacheinander, gebündelt über TCP oder per QUIC auf UDP. Was sich änderte."
url: https://proxynet.io/de/blog/http-1-vs-http-2-vs-http-3
date: 2026-11-19
author: "Acar Diveroli"
category: "Vergleich, Netzwerk"
lang: de
---

# HTTP/1.1, HTTP/2 und HTTP/3: Was hat sich geändert?

Sie öffnen auf einer langsamen Produktseite die Entwicklertools Ihres Browsers, blenden die Spalte `Protocol` ein und laden neu. Die Liste ist sich nicht einig: Die Seite und ihre Bilder zeigen `h3`, eine Schrift von einem anderen Host `h2` und ein altes Tracking-Skript `http/1.1`. Eine Seite, drei HTTP-Versionen, alle laden nebeneinander.

Diese Mischung ist normal, und sie sagt viel darüber aus, wie das Web heute funktioniert. Dieser Beitrag erklärt, was HTTP/1.1, HTTP/2 und HTTP/3 jeweils geändert haben, was HOL-Blocking (Head-of-Line-Blocking) ist und warum es zwei neue Versionen angestoßen hat, wie ein Browser eine Version auswählt, wie Sie prüfen, welche Version eine Website nutzt, und was mit der Version passiert, wenn Ihr Datenverkehr über einen Proxy läuft.

> **Hinweis: Kurzantwort**
>
> Alle drei Versionen transportieren dieselben Anfragen, Methoden, Statuscodes und Header; sie unterscheiden sich darin, wie diese Nachrichten unterwegs sind. HTTP/1.1 sendet pro TCP-Verbindung eine Anfrage nach der anderen, deshalb öffnen Browser mehrere Verbindungen. HTTP/2 zerlegt jede Anfrage in Frames und überträgt viele davon verschränkt (Multiplexing) über eine einzige TCP-Verbindung mit komprimierten Headern, doch ein einziges verlorenes TCP-Paket hält trotzdem alle auf. HTTP/3 läuft über QUIC auf UDP, wo jede Anfrage ihren eigenen Stream hat; ein verlorenes Paket hält deshalb nur diesen Stream auf. QUIC bringt außerdem TLS 1.3 fest mit und hält eine Verbindung am Leben, wenn sich Ihr Netz ändert. Browser beginnen mit HTTP/2 oder HTTP/1.1 und wechseln zu HTTP/3, wenn die Website es ankündigt.

## Was haben die HTTP-Versionen gemeinsam?

Jede HTTP-Version spricht dieselbe Sprache; nur die Art, wie die Wörter verpackt und versendet werden, ändert sich. Eine `GET`-Anfrage, ein Status `404` oder ein `Cache-Control`-Header bedeutet in allen dreien genau dasselbe. Die Standards trennen das sauber: RFC 9110 legt die gemeinsame Bedeutung fest, und ein eigenes Dokument je Version beschreibt, wie sie über die Leitung geht. Deshalb muss eine Webanwendung nicht wissen, welche Version eine Anfrage transportiert hat, und deshalb kann ein Server alle drei gleichzeitig sprechen.

## Was hat HTTP/1.1 geändert?

HTTP/1.1 machte Verbindungen wiederverwendbar. Wie [MDN in der Geschichte von HTTP](https://developer.mozilla.org/de/docs/Web/HTTP/Guides/Evolution_of_HTTP) schildert, erschien es erstmals im Januar 1997, und seine größte Neuerung war die **persistente Verbindung**: Nach einer Antwort bleibt dieselbe TCP-Verbindung für die nächste Anfrage offen, statt geschlossen und neu aufgebaut zu werden. Außerdem wurde der `Host`-Header Pflicht, wodurch eine IP-Adresse viele Websites bedienen kann.

HTTP/1.1 ist ein Textprotokoll: Eine Anfrage besteht aus lesbaren Zeilen wie `GET /index.html HTTP/1.1`, gefolgt von Headern. Seine Grenze: Eine Verbindung bearbeitet eine Anfrage nach der anderen, und die nächste Anfrage wartet, bis die vorherige Antwort vollständig angekommen ist.

**Pipelining**, also mehrere Anfragen zu senden, ohne auf Antworten zu warten, löste das nicht, weil der Server die Antworten in der Reihenfolge zurückgeben muss, in der die Anfragen eingingen. Browser behalfen sich mit mehreren parallelen Verbindungen pro Website, und Websitebetreiber fassten Dateien zu Bundles und Bild-Sprites zusammen.

## Was hat HTTP/2 geändert?

Mit HTTP/2 teilen sich viele Anfragen gleichzeitig eine Verbindung. Das im Mai 2015 standardisierte und aus Googles experimentellem Protokoll SPDY hervorgegangene HTTP/2 behält die Bedeutung von HTTP bei, ersetzt aber das Textformat durch ein binäres. Die aktuelle Fassung des Standards ist [RFC 9113](https://www.rfc-editor.org/rfc/rfc9113.html) vom Juni 2022.

Vier Änderungen prägen es:

1. **Binäres Framing.** Jede Anfrage und Antwort wird in kleine Frames mit festem Aufbau zerlegt, die Maschinen schneller und zuverlässiger auswerten als Textzeilen.
1. **Streams und Multiplexing.** Jede Anfrage erhält einen eigenen nummerierten Stream, und Frames verschiedener Streams werden verschränkt über eine TCP-Verbindung übertragen. Eine langsame Antwort blockiert auf HTTP-Ebene keine schnelle mehr.
1. **Header-Komprimierung (HPACK).** Browser senden mit jeder Anfrage fast identische Header, etwa Cookies und den User-Agent. HPACK führt eine Tabelle der auf der Verbindung bereits gesendeten Header und ersetzt Wiederholungen durch kurze Verweise.
1. **Server Push.** Der Server konnte Dateien senden, die der Browser noch nicht angefordert hatte. In der Praxis half das selten, und [Chromes Ankündigung](https://developer.chrome.com/blog/removing-push) erklärt, warum Push in Chrome 106 standardmäßig deaktiviert wurde; als Ersatz werden 103 Early Hints und Preload empfohlen.

Bei HTTPS einigen sich Browser und Server während des TLS-Handshakes auf HTTP/2, und zwar über eine Erweiterung namens ALPN (Application-Layer Protocol Negotiation) mit der Kennung `h2`. Der Standard erlaubt HTTP/2 weiterhin ohne Verschlüsselung, wenn beide Seiten vorab wissen, dass die Gegenseite es spricht. Die alte Methode, eine unverschlüsselte HTTP/1.1-Verbindung auf HTTP/2 hochzustufen, gilt jedoch inzwischen als veraltet.

## Was ist HOL-Blocking?

HOL-Blocking bedeutet, dass ein verzögertes Element alles aufhält, was dahinter wartet, wie ein liegengebliebenes Auto an der Spitze einer einspurigen Straße. Es tritt auf zwei verschiedenen Ebenen auf, und jede neue HTTP-Version hat eine davon beseitigt.

1. **Auf HTTP-Ebene (HTTP/1.1).** Eine Verbindung trägt jeweils nur einen Austausch. Ist die erste Antwort langsam, wartet die zweite, auch wenn sie fertig ist; deshalb öffneten Browser zusätzliche Verbindungen.
1. **Auf TCP-Ebene (HTTP/2).** HTTP/2 beseitigt das erste Problem, aber alle seine Streams teilen sich eine TCP-Verbindung. TCP liefert Bytes streng der Reihe nach aus: Geht ein Paket verloren, wartet alles danach auf die erneute Übertragung, auch Daten aus Streams, die mit dem verlorenen Paket nichts zu tun hatten. RFC 9113 sagt klar, dass HTTP/2 das HOL-Blocking von TCP nicht löst.
1. **Keine gemeinsame Warteschlange (HTTP/3).** QUIC hält die Reihenfolge innerhalb jedes Streams ein, aber nicht über Streams hinweg; ein verlorenes Paket verzögert daher nur den Stream, zu dem es gehörte.

Auf unserem Testrechner haben wir zwei Anfragen gleichzeitig über eine Verbindung an einen kleinen lokalen Node.js-Server geschickt: Eine Antwort brauchte 2 Sekunden, die andere kam sofort. Über HTTP/1.1 traf die schnelle Antwort nach 2.015 ms ein, hinter der langsamen festgehalten; über HTTP/2 nach 4 ms. Der Stau auf TCP-Ebene setzt Paketverlust voraus, er zeigt sich deshalb in schwachem WLAN und in Mobilfunknetzen, nicht in einem lokalen Test.

## Was hat HTTP/3 geändert?

HTTP/3 verlegt HTTP von TCP auf QUIC, ein Transportprotokoll, das über UDP läuft. UDP sendet Pakete ohne Zustellgarantie, deshalb ergänzt QUIC eigene Zuverlässigkeit und Reihenfolge, und zwar pro Stream statt für die ganze Verbindung; unser [Vergleich von TCP und UDP](/de/blog/tcp-vs-udp) erklärt den Unterschied zwischen den beiden Transportprotokollen.

QUIC erschien im Mai 2021 als RFC 9000, HTTP/3 im Juni 2022 als [RFC 9114](https://www.rfc-editor.org/rfc/rfc9114.html). Der Wechsel zu QUIC bringt vier praktische Änderungen:

- **Unabhängige Streams.** Jede Anfrage läuft auf ihrem eigenen QUIC-Stream. Ein verlorenes Paket hält nur seinen eigenen Stream auf; die anderen liefern weiter.
- **Eingebaute Verschlüsselung.** QUIC nutzt immer TLS 1.3 und fasst den Transport- und den Verschlüsselungs-Handshake zu einem zusammen. Eine neue Verbindung kann ihre erste Anfrage nach einem Roundtrip senden. Ein wiederkehrender Client kann sogar schon im ersten Paket Daten mitschicken (0-RTT); diese sollten nur Anfragen enthalten, die gefahrlos wiederholt werden können, weil ein Angreifer sie erneut einspielen könnte.
- **Verbindungsmigration.** Eine QUIC-Verbindung wird über Verbindungs-IDs erkannt, nicht über Ihre IP-Adresse und Ihren Port. Wechselt Ihr Smartphone vom WLAN zu mobilen Daten, kann die Verbindung auf dem neuen Weg weiterlaufen, statt neu zu beginnen.
- **QPACK statt HPACK.** HPACK setzt voraus, dass Header in Reihenfolge ankommen, was QUIC über Streams hinweg nicht mehr garantiert; HTTP/3 nutzt deshalb eine Variante namens QPACK.

QUIC-Verkehr läuft meist über UDP-Port 443. Manche Firewalls, Webfilter von Antivirenprogrammen und ältere Router blockieren UDP dort oder behandeln es fehlerhaft; Browser fallen dann auf HTTP/2 über TCP zurück. Scheitert dieser Rückfall auf halbem Weg, zeigt Chrome einen Fehler, den unser Beitrag zu [err_quic_protocol_error](/de/blog/err-quic-protocol-error) erklärt.

## HTTP/1.1, HTTP/2 und HTTP/3 im Überblick

| | HTTP/1.1 | HTTP/2 | HTTP/3 |
|---|---|---|---|
| Transport | TCP | TCP | QUIC über UDP |
| Nachrichtenformat | Text | Binäre Frames | Binäre Frames |
| Anfragen pro Verbindung | Eine nach der anderen | Viele, per Multiplexing | Viele, unabhängige Streams |
| HOL-Blocking | HTTP- und TCP-Ebene | TCP-Ebene | Nur innerhalb eines Streams |
| Header-Komprimierung | Keine | HPACK | QPACK |
| Verschlüsselung | Optional (HTTPS) | In der Praxis TLS | Immer TLS 1.3 |
| Netzwechsel | Neue Verbindung | Neue Verbindung | Verbindung zieht mit um |
| Spezifikation | RFC 9112 | RFC 9113 | RFC 9114 |

## Wie wählt ein Browser die HTTP-Version?

Der Browser handelt HTTP/1.1 oder HTTP/2 im TLS-Handshake aus und erfährt von HTTP/3 durch die Website selbst. In seiner ersten Handshake-Nachricht listet er die Protokolle auf, die er spricht, etwa `h2` und `http/1.1`, und der Server wählt eines aus.

HTTP/3 lässt sich so nicht aushandeln, denn der Browser müsste davon wissen, bevor er überhaupt eine TCP-Verbindung öffnet. Es gibt zwei Wege, es ihm mitzuteilen:

- **Der Alt-Svc-Header.** Der Server fügt einer gewöhnlichen Antwort einen Header wie `alt-svc: h3=":443"; ma=86400` hinzu. Das bedeutet so viel wie: „HTTP/3 ist auf UDP-Port 443 verfügbar, merke dir das für einen Tag.“ Der Browser versucht QUIC bei späteren Anfragen.
- **Der HTTPS-DNS-Eintrag.** Ein neuerer DNS-Eintragstyp (RFC 9460) kann `alpn=h3` enthalten. So erfährt der Browser schon bei der Adressauflösung von HTTP/3 und kann es ab der allerersten Anfrage nutzen.

Deshalb zeigt die erste Anfrage an eine Website oft `h2` und die folgenden `h3`. Die Seite aus unserem Einstiegsbeispiel verhält sich also nicht falsch: Jeder Host hat seine eigene Wahl getroffen.

## Wie prüfen Sie, welche HTTP-Version eine Website nutzt?

Die Entwicklertools Ihres Browsers zeigen die Version jeder Anfrage. In Chrome oder Edge:

1. Öffnen Sie die Seite, drücken Sie F12 (auf dem Mac Cmd+Option+I) und wählen Sie das Panel `Network`.
1. Klicken Sie mit der rechten Maustaste auf den Kopf der Anfragetabelle und setzen Sie den Haken bei `Protocol`.
1. Laden Sie die Seite neu. `http/1.1`, `h2` und `h3` stehen für die drei Versionen.

Im Terminal kann `curl` die Version einer einzelnen Anfrage anzeigen:

```bash
curl -s -o /dev/null -w "%{http_version}\n" https://example.com
curl -sI https://example.com
```

Der erste Befehl gibt `1.1`, `2` oder `3` aus. Beim zweiten bedeutet eine `alt-svc`-Zeile mit `h3`, dass die Website HTTP/3 anbietet. Welche Versionen curl nutzen kann, hängt davon ab, wie es gebaut wurde: `curl -V` listet sie in der Zeile **Features** als `HTTP2` und `HTTP3`.

Auf unserem Testrechner mit Windows 11 spielte das eine Rolle. Das mit Windows ausgelieferte curl (8.22.0) hat keine der beiden Funktionen, daher brach `--http2` mit `the installed libcurl version does not support this` ab, und der erste Befehl gab `1.1` aus. Dabei enthielten die Header von `example.com` die Zeile `alt-svc: h3=":443"; ma=86400`, und eine TLS-Verbindung aus Node.js, die `h2` anbot, wurde mit `h2` beantwortet. Die Website bietet alle drei an; was Sie sehen, entscheidet das Werkzeug.

## Ist HTTP/3 immer schneller als HTTP/2?

Nein, HTTP/3 hilft vor allem dort, wo das Netz schlecht ist. Seine Vorteile kommen von weniger Roundtrips beim Verbindungsaufbau, keinem Stau auf TCP-Ebene bei Paketverlust und Verbindungen, die einen Netzwechsel überstehen. Sie zeigen sich daher auf Smartphones, die zwischen Funkzellen wechseln, in überfülltem WLAN und auf verlustreichen Fernverbindungen.

Auf einer stabilen Kabelverbindung mit kaum Verlust fühlen sich beide meist gleich an. Wo UDP blockiert oder gedrosselt wird, versucht der Browser QUIC, gibt auf und fällt zurück, und das kostet Zeit. Messen Sie Ihre Seiten in den Netzen, die Ihre Besucher tatsächlich nutzen.

## Welche HTTP-Version erhalten Sie über einen Proxy?

Über die meisten Proxys erreichen Sie die Website mit HTTP/2 oder HTTP/1.1, denn der übliche Proxy-Tunnel läuft über TCP. Bei einer `https://`-Adresse sendet der Client dem Proxy eine `CONNECT`-Anfrage; der Proxy öffnet eine TCP-Verbindung zur Website und leitet Bytes weiter, ohne sie zu lesen. TLS und die HTTP-Version darin werden direkt zwischen Ihrem Client und der Website ausgehandelt. Unser [HTTPS-Proxy](https://proxynet.io/de/https-proxy) arbeitet so, über HTTP-CONNECT-Tunnel.

HTTP/3 braucht UDP, um die Website zu erreichen, und ein TCP-Tunnel kann es nicht transportieren. RFC 9298 (2022) definiert CONNECT-UDP, eine Möglichkeit, UDP durch einen HTTP-Proxy zu tunneln. Auch SOCKS5 kann UDP weiterleiten, wie es unser [SOCKS5-Proxy](https://proxynet.io/de/socks5-proxy) für Apps tut, die selbst UDP senden.

Browser nutzen heute keinen dieser Wege für Webseiten: [Chromiums Proxy-Dokumentation](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md) hält fest, dass eine Verbindung zu einem HTTPS-Proxy HTTP/2 aushandeln kann, QUIC aber nicht, und dass die SOCKS5-Unterstützung von Chrome kein UDP weiterleitet.

Wenn Sie also über einen Proxy `h2` sehen, wo ein direkter Aufruf `h3` zeigt, ist das erwartbar und kein Fehler. Wenn Sie aus anderen Gründen zwischen Proxy-Protokollen wählen, vergleicht unser [Leitfaden zu SOCKS- und HTTP-Proxys](/de/blog/socks-vs-http-proxy) die beiden.

## Wo Ihnen die verschiedenen HTTP-Versionen begegnen

- **Surfen.** Viele große Websites und CDNs liefern aktuellen Versionen von Chrome, Edge und Firefox HTTP/3 aus; andere bleiben bei HTTP/2.
- **APIs und Kommandozeilenwerkzeuge.** Viele HTTP-Client-Bibliotheken und Skripte nutzen standardmäßig noch HTTP/1.1.
- **Mobile Apps.** Apps in instabilen Netzen profitieren am meisten von der Verbindungsmigration in QUIC.
- **Proxys und Firmennetze.** Tunnel und Firewalls, die nur TCP durchlassen, halten den Verkehr bei HTTP/2 oder HTTP/1.1.

## Häufige Fehler

- **Glauben, eine neue Version ändere die Bedeutung einer Seite.** Ein `403` über HTTP/3 ist derselbe `403` wie über HTTP/1.1.
- **Für HTTP/2 alles bündeln.** Riesige Bundles und Sprites waren Notlösungen für HTTP/1.1; mit Multiplexing lassen sich kleinere Dateien besser cachen.
- **HTTP/3 aktivieren, ohne UDP 443 zu öffnen.** `Alt-Svc` kündigt dann eine Tür an, die die Firewall geschlossen hält, und jeder Browser muss es versuchen und zurückfallen.
- **QUIC wegen eines einzigen Fehlers dauerhaft abschalten.** Das ist ein nützlicher Test, keine Dauereinstellung.
- **Mit einem curl-Build testen, das kein HTTP/2 spricht.** Das Ergebnis lautet `1.1` wegen des Werkzeugs, nicht wegen des Servers.

## Entscheidungshilfe

| Ihre Situation | Was tun? |
|---|---|
| Sie betreiben eine Website | HTTP/2 über TCP ausliefern, HTTP/3 ergänzen, wenn Ihr Server oder CDN es unterstützt |
| Besucher sind überwiegend mobil unterwegs | HTTP/3 aktivieren und UDP 443 offen halten |
| Ein HTTP/3-Fehler in einem bestimmten Netz | Mit abgeschaltetem QUIC testen, dann Firewall oder Filter korrigieren |
| Ein API-Client für Skripte | HTTP/1.1 oder HTTP/2 reicht für die meisten Anfragemengen |
| Sie wollen sehen, welche Version Sie erhalten haben | DevTools-Spalte `Protocol` oder `curl -w "%{http_version}"` |
| Der Verkehr läuft über einen Proxy | HTTP/2 oder HTTP/1.1 in einem CONNECT-Tunnel erwarten |

## Häufige Fragen

### Ist HTTP/3 schneller als HTTP/2?

In mobilen und verlustreichen Netzen oft, auf einer sauberen Kabelverbindung selten nennenswert. Wo wenig verloren geht, leisten beide etwa dasselbe, und blockiertes UDP kann HTTP/3 wegen des Rückfalls langsamer machen.

### Setzt HTTP/2 HTTPS voraus?

Der Standard verlangt es nicht, aber Browser handeln HTTP/2 im TLS-Handshake aus; im Web kommt es deshalb über HTTPS. Unverschlüsseltes HTTP/2 gibt es für Fälle, in denen beide Seiten bereits wissen, dass die andere es unterstützt, etwa Dienste, die innerhalb eines Netzes miteinander sprechen. HTTP/3 hat überhaupt keine unverschlüsselte Form, weil QUIC immer TLS 1.3 nutzt.

### Wird HTTP/1.1 noch genutzt?

Ja, und zwar breit. Viele Kommandozeilenwerkzeuge, Skripte, eingebettete Geräte und ältere Server nutzen es, und Proxy-Tunnel werden oft mit einer `CONNECT`-Anfrage in HTTP/1.1 aufgebaut. Webserver, die HTTP/2 oder HTTP/3 anbieten, akzeptieren normalerweise weiterhin HTTP/1.1 für Clients, die nichts Neueres nutzen können.

### Was ist der Unterschied zwischen Multiplexing und Pipelining?

Pipelining (HTTP/1.1) sendet mehrere Anfragen, ohne zu warten, aber die Antworten müssen in Reihenfolge zurückkommen; eine langsame Antwort blockiert also den Rest. Multiplexing (HTTP/2 und HTTP/3) zerlegt Anfragen und Antworten in Frames, die mit einer Stream-Nummer markiert sind, und verschränkt sie. Die Antworten kommen so in der Reihenfolge zurück, in der sie fertig werden.

### Sollte ich QUIC oder HTTP/3 im Browser deaktivieren?

Nur, um ein Problem einzugrenzen. Scheitert eine Website in einem Netz mit einem QUIC-Fehler, zeigt ein Test mit abgeschaltetem QUIC, ob UDP die Ursache ist; danach beheben Sie die Ursache und schalten QUIC wieder ein. Ohne QUIC lädt Ihr Browser weiterhin jede Website über HTTP/2 oder HTTP/1.1.

### Kann ein Server HTTP/1.1, HTTP/2 und HTTP/3 gleichzeitig unterstützen?

Ja, das ist die übliche Einrichtung für eine Website, die HTTP/3 anbietet. Der Server lauscht auf TCP-Port 443 für HTTP/1.1 und HTTP/2 und auf UDP-Port 443 für HTTP/3 und kündigt HTTP/3 mit einem `Alt-Svc`-Header an. In nginx etwa stammt HTTP/3 aus einem Modul, das es seit Version 1.25.0 gibt, das noch als experimentell gekennzeichnet ist und standardmäßig nicht mitgebaut wird.

## Fazit

HTTP/1.1, HTTP/2 und HTTP/3 transportieren dieselben Anfragen mit derselben Bedeutung; geändert hat sich die Zustellung. HTTP/1.1 bearbeitet pro Verbindung eine Anfrage nach der anderen, HTTP/2 überträgt viele per Multiplexing über eine TCP-Verbindung, und HTTP/3 wechselt zu QUIC auf UDP, sodass ein verlorenes Paket nur seinen eigenen Stream aufhält. Browser wählen die Version pro Host, deshalb kann eine Seite alle drei zeigen. Läuft Ihr Verkehr über einen Proxy, erwarten Sie HTTP/2 oder HTTP/1.1 im Tunnel, und wählen Sie das Protokoll, das Ihre Werkzeuge brauchen, aus unseren [Proxy-Produkten](/de/proxy).
