HTTP (Hypertext Transfer Protocol) and HTTP/2 are both protocols used for transferring data over the internet. However, there are several key differences between the two versions.


Key differences.

Binary Protocol vs. Text Protocol

HTTP/1.1, the previous version, used a text-based protocol, meaning that messages exchanged between the client and server were primarily in plain text format. On the other hand, HTTP/2 is a binary protocol, which means that the messages are encoded in binary format for more efficient transmission.

Multiplexing and Concurrency

One of the significant improvements in HTTP/2 is the introduction of multiplexing. In HTTP/1.1, only one request can be sent at a time on a single TCP connection. With HTTP/2, multiple requests and responses can be sent simultaneously over the same connection, which allows for better utilization of network resources and faster page loading times.

Header Compression

HTTP/2 incorporates a new feature called header compression. In HTTP/1.1, HTTP headers are sent with each request and response, which can consume a significant amount of bandwidth. HTTP/2 uses a technique called header compression, where header fields are efficiently encoded and transmitted in a compressed format. This helps reduce overhead and improves performance.

Server Push

Another notable feature introduced in HTTP/2 is server push. In HTTP/1.1, the client has to explicitly request each resource required to render a web page. With server push, the server can proactively send additional resources to the client before they are requested, based on the server's understanding of the client's needs. This can significantly improve page load times by eliminating the round trips required to request each resource individually.

Stream Prioritization

HTTP/2 introduces the concept of stream prioritization. It allows the client to assign priorities to different resources, indicating their relative importance. The server can then use this information to prioritize the delivery of resources accordingly. This feature enables more efficient resource allocation and can enhance the user experience by ensuring that critical resources are loaded first.

Backward Compatibility

While HTTP/2 is a new protocol, it maintains a high degree of backward compatibility with HTTP/1.1. This means that existing HTTP/1.1 applications can still work over an HTTP/2 connection, although they may not be able to take full advantage of the new features. HTTP/2 achieves this compatibility by using a technique called protocol negotiation, where the client and server communicate their capabilities and agree on the appropriate protocol version to use.


To be able to work with HTTP/2 you should use HTTPS (Hypertext Transfer Protocol Secure) that is a secure version of the HTTP protocol used for secure communication over the internet. It provides encryption and authentication mechanisms to ensure the confidentiality, integrity, and authenticity of data transmitted between a client (e.g., a web browser) and a server.

HTTPS works this way


The HTTPS handshake is the initial process where the client and server establish a secure connection. The client sends a request to the server to initiate a secure connection.
Server Authentication: The server responds to the client's request by sending its SSL/TLS certificate, which contains the server's public key, along with other information. The certificate is digitally signed by a trusted certificate authority (CA), providing a means for the client to verify the server's identity.

Certificate Verification

The client verifies the authenticity of the server's certificate. It checks if the certificate is issued by a trusted CA, hasn't expired, and matches the domain being accessed. If the verification fails, the client displays a warning to the user.
Key Exchange: To establish a secure connection, the client generates a symmetric encryption key called the "session key." It encrypts this session key using the server's public key from the certificate and sends it back to the server.

Symmetric Encryption

Both the client and server now have the session key, which they use to encrypt and decrypt the data transmitted during the session. Symmetric encryption is faster and more efficient than asymmetric encryption (used during the handshake).

Secure Data Transfer

With the secure connection established, the client and server can exchange data over the encrypted channel. The data is encrypted by the client using the session key and decrypted by the server using the same key, ensuring confidentiality.

Integrity Check

To ensure data integrity, a hash function (usually HMAC) is applied to the data being transmitted. This produces a hash value that is attached to the data. Upon receiving the data, the recipient performs the same hash function and compares the calculated hash with the received hash. If they match, it verifies that the data hasn't been tampered with during transmission.

Session Persistence

To maintain the secure connection, both client and server retain the session key for the duration of the session. This eliminates the need to perform the handshake for every subsequent request, reducing overhead and improving performance.


By combining encryption, server authentication, and data integrity checks, HTTPS ensures that sensitive information, such as login credentials or financial transactions, is securely transmitted over the internet, protecting it from eavesdropping, tampering, and impersonation.
In summary, HTTP/2 provides significant performance improvements over its predecessor, primarily through features such as multiplexing, header compression, server push, and stream prioritization. These enhancements allow for faster and more efficient data transfer, resulting in reduced latency and improved website performance.