Suggest an edit

Improve this article

Refine the answer for “What is HTTP/2?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## 1. What HTTP/2 is

**HTTP/2** is the second major version of the HTTP protocol,
developed by the IETF and released in **2015**.

It was created to:

- increase the speed at which web pages load,
- reduce latency,
- cut down the number of TCP connections,
- and make the protocol more efficient overall.

> Put simply: **HTTP/2 = the same HTTP, but "packaged" more cleverly.**
> The semantics (`GET`, `POST`, `headers`, `status codes`) stayed the same,
> but the data-transfer format and the connection's structure changed radically.

## 2. Why HTTP/1.1 started to slow down

HTTP/1.1 (1997) had a number of problems:

- **A limitation: 1 request = 1 response.**
To load 50 resources (images, scripts, CSS), the browser has to open dozens of connections.
- **Head-of-Line Blocking**, if one request in the queue stalls, the rest have to wait.
- **Huge headers** (cookies, user-agent, etc.) get sent again with every request.
- **No multiplexing**: each connection serves only one stream.
- To speed up a site, developers had to "hack" the protocol, minifying CSS, bundling JS, using CDN domains.

## 3. What changed in HTTP/2

### 1. Multiplexing

Now **several requests and responses can travel over a single TCP connection at the same time**.
There are no more "queues" or blocking.

In HTTP/1.1:

```javascript
Request 1 → response 1
Request 2 → response 2
```

In HTTP/2:

```javascript
Requests 1, 2, 3 → in parallel
Responses 1, 2, 3 → in any order
```

> This removes Head-of-Line Blocking at the HTTP level (though not at the TCP level).

### 2. Binary framing

HTTP/2 sends data **as binary frames**, rather than as text like HTTP/1.1.

- It parses faster and is more compact.
- It removes the ambiguities of a text format.
- It splits the stream into independent **frames** and **streams**.

### 3. Header compression (HPACK)

Headers (`User-Agent`, `Cookie`, `Accept-Language`, etc.) repeat often.
HTTP/2 encodes them using a **table and Huffman compression**,
shrinking the amount of metadata sent.

> For example, 1 KB of headers in HTTP/1.1 might take up only ~100 bytes in HTTP/2.

### 4. Server Push

The server can **send the client extra resources** before they're even requested.

For example:

```javascript
Client → GET /index.html
Server → /index.html + /style.css + /script.js
```

That way the browser gets everything it needs right away, with no extra requests.
(though in HTTP/3 this feature is gradually leaving the standard.)

### 5. HTTPS, effectively mandatory

Although HTTP/2 can *theoretically* be used without TLS,
every browser requires **HTTPS only** for HTTP/2 connections.
Encryption has become the standard.

## 4. What this looks like visually

```javascript
HTTP/1.1:          HTTP/2:
───────────        ────────────────
Req1 → Resp1       Stream1: Req1/Resp1
Req2 → Resp2       Stream2: Req2/Resp2
Req3 → Resp3       Stream3: Req3/Resp3
(one at a time)    (all over one connection)
```

## 5. A performance-difference example

**HTTP/1.1:** the browser opens up to 6 TCP connections per domain,
each with its own request queue.

**HTTP/2:** one connection serves dozens of parallel streams.
→ less overhead, less latency, fewer handshakes.

The result:

- pages load faster;
- less load on the server and the network;
- more benefit from HTTPS (TLS is used more efficiently).

## 6. Support

HTTP/2 is supported by:

- all modern browsers;
- most servers (Nginx, Apache, Node.js, Caddy, Cloudflare, etc.);
- Node.js since **v8.4** (`import http2 from 'node:http2'`).

## 7. An example in Node.js

```javascript
import http2 from 'node:http2';
import fs from 'node:fs';

const server = http2.createSecureServer({
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem'),
});

server.on('stream', (stream, headers) => {
  stream.respond({ 'content-type': 'text/plain', ':status': 200 });
  stream.end('Hello from HTTP/2');
});

server.listen(8443);
```

## 8. Key differences in a table

| Characteristic | **HTTP/1.1** | **HTTP/2** |
|---|---|---|
| Format | Text | Binary |
| Number of connections | 1 request = 1 connection | One connection, many streams |
| Multiplexing | No | Yes |
| Header compression | No | HPACK |
| Server Push | No | Yes |
| Stream prioritization | No | Yes |
| HTTPS required | No | Effectively yes |
| Speed | Slower | Faster (by 20-40%) |

## 9. In a nutshell

> **HTTP/2** is a "smarter" HTTP that transmits data as binary,
> multiplexes streams, and minimizes overhead,
> making sites noticeably faster with no change to application logic.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts717 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.