Preface
In this “A Plain-Language Guide to Network Protocols” series, we previously introduced the OSI seven-layer model and the TCP/IP four-layer model【】, and also covered the HTTPS protocol and the basic principles behind its encrypted communication 【】. The operation of today’s Internet cannot do without the cornerstone that is the HTTP protocol; yet we can now see multiple different versions of HTTP, such as HTTP/1.1, HTTP/2, and HTTP/3. So what are the differences among these versions, and what are their specific application scenarios? In this article, we will focus on the similarities and differences among these different versions of the HTTP protocol.
Introduction to the HTTP Protocol
Overview
HTTP (Hypertext Transfer Protocol) sits at the application layer of the OSI seven-layer network model, and its core mission is to transfer resources between distributed systems. Its relationship with transport-layer protocols such as TCP/UDP is more one of collaboration.

From its very inception, the HTTP protocol has included the following core characteristics:
- Stateless design: The server does not store client context information
- Request/response model: Based on standard request methods and status codes
- Extensible headers: Metadata transfer via Header fields
- Cross-platform compatibility: The text-based protocol design ensures interoperability across systems
The HTTP protocol is responsible for transferring hypertext resources between clients and servers. As a stateless protocol, HTTP does not retain records of client interactions, and each request is handled independently. This protocol specification unified the way Web resources are accessed, made it compatible with all kinds of operating systems and devices, and allows functional extension through header fields. It is the foundational protocol of today’s Internet world.
Protocol Composition
HTTP communication is based on the request/response model and is transmitted over the TCP/IP protocol stack:
Request message structure:
For example:
| |
Response message structure:
For example:
| |
HTTP Methods
HTTP methods define the operational semantics for network resources. The table below summarizes the application scenarios of the different HTTP methods
| Method | Idempotency | Safety | Application Scenario | RESTful Practice Example |
|---|---|---|---|---|
| GET | Yes | Yes | Retrieve a resource | Query user information |
| POST | No | No | Create a resource / perform an action | Create a new order |
| PUT | Yes | No | Full update of a resource | Update user profile |
| DELETE | Yes | No | Delete a resource | Cancel an order |
| PATCH | No | No | Partial update of a resource | Modify the order address |
| HEAD | Yes | Yes | Retrieve header metadata | Check whether a resource exists |
| OPTIONS | Yes | Yes | Retrieve methods supported by the server | CORS preflight request |
HTTP Status Codes
A status code is the result of request processing, represented by a three-digit number in the response message.
| Category | Common Status Codes | Technical Meaning | Application Scenario |
|---|---|---|---|
| 1xx | 101 | Protocol switch | WebSocket upgrade |
| 2xx | 200/201/204 | Successful processing | Resource created successfully |
| 3xx | 301/302/304 | Redirect / cache valid | Permanent move / temporary redirect |
| 4xx | 400/401/404 | Client error | Parameter error / unauthorized / resource not found |
| 5xx | 500/502/503 | Server error | Service crash / gateway error / overload |
The Different Versions and Evolution of HTTP
Evolution roadmap:
| |
HTTP/0.9 (1991)
The original version of the HTTP protocol had no version number; it was only later, to distinguish it from subsequent versions, that it was defined as version 0.9. It was based on the initial protocol designed by Dr. Tim Berners-Lee for transferring internal documents at CERN, and is also known as the one-line protocol (one-line).
This protocol was extremely simple:
Request:
| |
The response contained only the page document itself, and there were no message headers either:
| |
Its limitations were equally obvious:
This protocol could not support complex Web applications; it could only transfer plain HTML documents, and it had no status codes to reflect the state of communication.
HTTP/1.0 (1996)
As networks developed and the use of browsers and servers grew rapidly, the HTTP protocol also found wider application. Many features were added on top of the original protocol, and in 1996 these were consolidated and standardized in the specification document RFC 1945, which defined HTTP/1.0. However, this protocol was not an official standard; it was a narrowly standardized version.
Core improvements of HTTP/1.0:
- Introduced a version identifier (HTTP/1.0)
- Added status codes (200/404, etc.)
- Supported header fields (Content-Type/Cache-Control)
- Extended methods (POST/HEAD)
The communication process was as follows:
| |
However, this standard had a crucial performance-overhead problem:
- Short-lived connections, with each resource using a separate connection, incur heavy TCP handshake overhead
- No compression / caching mechanism
HTTP/1.1 (1997)
To address the inefficiency of loading Web page resources, work on the official standardization of the HTTP protocol had actually begun even before the release of HTTP/1.0. RFC 2068 was published in 1997 (some also regard the 1999 revision RFC 2616 as the HTTP/1.1 standard), and a further revision, RFC 7235, was published in 2014.
The HTTP/1.1 version was extremely successful and remains widely used to this day. It introduced the following major features:
| Feature | Implementation Mechanism | Performance Improvement |
|---|---|---|
| Persistent connections | Connection: keep-alive | Reduces TCP handshakes by 60% |
| Pipelining | Sending requests in batches | Theoretical throughput increase of 30% |
| Chunked transfer | Transfer-Encoding | Supports streaming of large files |
| Content negotiation | Accept header family | Support for multi-format resources |
To improve efficiency, the HTTP/1.1 protocol provided a pipelining mechanism, which allows the client to send multiple requests to the server at the same time to boost efficiency. The problem here, however, is that although client-side efficiency is improved, the server can still only return responses one at a time. This is the Head-of-Line Blocking (Head-of-Line Blocking) problem.
| |
Other limitations:
In addition, although this version introduced a compression mechanism, it did not provide compression support for message headers, so considerable performance waste remained.
Moreover, because of the stateless nature of HTTP/1.1, the server can still only passively wait for the client to submit state information.
HTTP/2 (2015)
As Web applications on the Internet grew richer and network bandwidth increased, the demands on transferred content became ever higher. To further improve the transfer efficiency of the HTTP protocol and address its lingering issues, RFC 7540 was published in 2015 as an improvement built on Google’s SPDY protocol.
In HTTP/2, the following major improvements were made:
- Binary frames: It uses binary instead of a text protocol, so it is no longer human-readable and cannot be created manually without assistance.
- Multiplexing: Concurrent transfer over a single connection
- Header compression: Message headers are compressed using the HPACK algorithm, reducing overhead by 70-85%
- Server push: Proactively sending associated resources, allowing the server to populate data in the client’s cache
Limitations:
Although HTTP/2.0 proposed the use of multiplexing to solve Head-of-Line Blocking, the actual results were not ideal. The root cause is that the HTTP protocol is an application-layer protocol built on top of TCP; that is, even though multiplexing is possible at the application layer, at the transport layer, because of TCP’s retransmission mechanism, one still has to wait for transport-layer messages to return one by one; in other words, Head-of-Line Blocking still exists at the TCP layer.
HTTP/3 (2020)
To completely solve the Head-of-Line Blocking problem, HTTP/3 was introduced in 2020. The biggest change in this protocol is a thorough restructuring of the protocol stack: the transport layer is no longer based on TCP, but on the QUIC protocol over UDP.
Because UDP is designed without TCP’s packet-loss retransmission mechanism, its communication efficiency is greatly improved over TCP; and QUIC’s redesigned communication method, while offering reliability nearly equivalent to a TCP connection, greatly reduces latency.
Currently, more than 95% of browsers already support the HTTP/3 protocol, and more than 30% of websites have also begun to support HTTP/3.
Summary
The main differences among the different HTTP versions described above can be summarized as follows:
| Version | Core Contribution | Main Limitation | Adoption Rate(2024 ) |
|---|---|---|---|
| 0.9 | Established the request/response model | Only supports GET | 0% |
| 1.0 | Introduced headers / status codes | Inefficient short-lived connections | <1% |
| 1.1 | Persistent connections / pipelining | Head-of-Line Blocking | 52% |
| 2 | Binary framing / header compression | Blocking at the TCP layer | 96% |
| 3 | QUIC protocol / connection migration | Infrastructure support still maturing | 39% |
According to the Cloudflare 2024 report: HTTP/3 already accounts for 35% of global HTTP traffic and is expected to become the dominant protocol by 2026. The continuous evolution of the HTTP protocol reflects the technical response of Internet infrastructure to the demands for performance, security, and mobility. Developers need to deeply understand the characteristics of each version in order to build high-performance applications adapted to future network environments.
