HTTP/1 to HTTP/3: Persistent Connections, Multiplexing, and QUIC
How HTTP moved from sequential HTTP/1 exchanges to HTTP/2 streams and HTTP/3 over QUIC, including the transport limits each version keeps.
On this page
The story of HTTP is not a simple progression from “slow” to “fast.” Each version changed how requests share a connection and how transport loss affects concurrent work. HTTP/1.0 commonly closed connections after responses, HTTP/1.1 made persistence the default, HTTP/2 added multiplexed streams on TCP, and HTTP/3 mapped HTTP semantics onto QUIC. Understanding those boundaries helps engineers explain why a protocol upgrade can improve one workload and leave another bottleneck untouched. [1] [3] [4]

HTTP/1.0: connection close was the common default
HTTP/1.0 was built around request and response messages over a connection. Its ordinary behavior was for the client to establish a connection, send a request, receive a response and close the connection. Some implementations later used a negotiated Keep-Alive extension, but that mechanism was not the default standardized behavior and could be problematic through proxies. [1]
That connection churn had a cost: another connection setup and slow start for each independent exchange. But it is misleading to say that every browser always used exactly one fresh connection for every resource. Browsers could open several connections in parallel, and persistent-connection extensions existed. The exact behavior depended on the implementation and intermediaries.
HTTP/1.1 changed the baseline by making persistent connections the default. Multiple requests and responses can use one TCP connection when messages have self-defined lengths and the parties do not signal close. Pipelining allowed clients to send multiple requests before receiving every response, but the server still had to send responses in order. A slow or large response could therefore delay later responses on that connection. [1]
HTTP/2: multiplex the HTTP exchanges
HTTP/2 kept HTTP semantics while changing the framing. It represents exchanges as streams and interleaves frames from multiple streams over a TCP connection. This reduces the need for many parallel TCP connections and can prevent one application-level response from blocking every other stream. Header compression and binary framing also make message transfer more efficient. [3]
The limit is the transport below HTTP/2. TCP delivers an ordered byte stream. If an IP packet is lost, later bytes on that connection cannot be delivered to the HTTP/2 layer until TCP repairs the gap. The HTTP streams may be logically separate, but they share that ordered transport. RFC 9113 explicitly notes that HTTP/2 does not address TCP head-of-line blocking. [3]
This distinction explains why “multiplexing” is not the same as “independent delivery.” HTTP/2 can interleave requests and responses so a slow application response does not necessarily block another stream, but loss on the shared TCP connection still delays delivery to all streams whose bytes follow the missing segment. Engineers should separate application queueing, server scheduling and transport loss when diagnosing a latency issue.
HTTP/3: map the same semantics onto QUIC
HTTP/3 carries HTTP over QUIC instead of mapping it directly to TCP. QUIC provides multiple streams with independent ordering, flow control and cancellation. It still provides reliable delivery for bytes within each stream; UDP is the underlying datagram substrate, not an instruction to accept missing application data. RFC 9114 defines how HTTP requests, headers and frames map onto QUIC streams. [4]
QUIC can reduce cross-stream blocking after packet loss because a receiver does not need to wait for missing bytes from one stream before delivering already received bytes from another. But streams can share packets: if one lost packet carried data for several streams, each of those streams may be delayed until retransmission. QUIC also applies flow control and congestion control, so an overloaded path or receiver can still limit progress. [5]
The difference can matter on lossy or mobile paths, but HTTP/3 is not an unconditional speed switch. Connection establishment, server support, network middleboxes, congestion, content dependencies and application behavior all affect results. A service can support HTTP/3 while clients still use HTTP/2 or HTTP/1.1, so deployments need a compatibility path and telemetry for the negotiated protocol.
The semantics did not become a new application API
HTTP/3 does not redefine the familiar request methods, status codes or content semantics. The HTTP semantics specification is separate from the version-specific message framing and connection mapping. That separation is why an application can preserve its request contract while its transport changes. [6]
There are still important protocol-specific rules. HTTP/1.1 uses connection management and ordered message parsing. HTTP/2 has its frame and stream model on TCP. HTTP/3 has QUIC streams and its own frame mapping. A proxy or observability layer that assumes every version has identical connection structure can misreport requests or mishandle upgrades.
The current HTTP/1.1 standard also has a 2026 update: RFC 9931 adds security requirements for optimistic protocol transitions, such as sending data before an upgrade has been confirmed. That is a reminder that protocol evolution includes security and interoperability refinements, not only throughput features. [2]
How to choose what to measure
Start with the user-visible bottleneck. If the page loads many small resources, connection reuse and multiplexing may help reduce setup and scheduling costs. If a single large transfer dominates, compression, congestion conditions, server capacity or content size may matter more. If an interactive request waits behind application work, changing the wire protocol may not help until queueing and service dependencies are fixed.
Compare protocol versions under realistic client networks and workload mixes. Track connection establishment, time to first byte, tail latency, retransmissions, fallback rates and errors. Do not infer a faster user experience solely from a higher negotiated protocol number. The load-balancing guide explains why connection behavior and routing decisions also shape what a client sees; the network protocols overview separates transport responsibilities from application semantics.
HTTP/1, HTTP/2 and HTTP/3 are best understood as different transport mappings for the same broad web request model. HTTP/1.1 made connection reuse routine, HTTP/2 introduced multiplexing over a shared TCP stream, and HTTP/3 moved that multiplexing into QUIC’s independently ordered streams. The remaining work belongs to the application, network and operations teams: measure the actual path, preserve the protocol contract and avoid treating a standards upgrade as a substitute for system diagnosis.
Frequently asked questions
Did HTTP/1.0 always open a new TCP connection for every resource?
HTTP/1.0 commonly closed the connection after a response, but some implementations added an explicitly negotiated Keep-Alive extension. HTTP/1.1 made persistent connections the default, so the simplified claim that all HTTP/1 traffic always used one connection per file is inaccurate.
Does HTTP/2 eliminate every form of head-of-line blocking?
No. HTTP/2 multiplexes independent HTTP streams, reducing application-level blocking, but it runs over TCP, whose ordered byte stream can delay later bytes after packet loss.
Does HTTP/3 make packet loss irrelevant?
No. QUIC orders data within each stream and can let unaffected streams progress, but a lost packet can delay every stream whose data was carried in that packet. HTTP/3 changes transport behavior; it does not remove congestion, loss or application dependencies.



/* Comments */
Comments are offline right now — we reconnect automatically, nothing is lost.