HTTP Keep-Alive - In Light

HTTP Keep-Alive is a feature of web servers that allows clients to keep connections open. It's also called "persistent connections."

The idea behind HTTP Keep-Alive is to prevent the connection from timing out and closing, which would require the client to reconnect. This saves time for both users and the website’s server.

HTTP/1.1 is designed to allow keep-alive connections by default, but HTTP/1.0 is not. The HTTP/1.0 protocol designed clients and servers to close the connection after each request. Using telnet, we can actually verify this difference.

A client can use this header to send information about its requirements for retaining an open connection.

The server uses this information to determine whether or not it should honour the request for a persistent connection, and if so, how long it should wait before closing the connection if there are no other requests from that client.

For instance, if a client is using HTTP Keep-Alive for its web browser, it will use this header to tell the server that it wants to keep the connection alive for as long as possible.

The purpose of this header is to allow a sender to hint about how a connection may be used. The sender can set timeout and max amount of requests on this header.

  1. How does it Work?
  2. Virtues of Keep-Alive
  3. The Pitfalls of Connection Keep-Alive

How does it work?

KeepAlive (Keep-Alive) is a software technique for making sure that data does not get lost when there is a disruption in a network circuit.

One way that Keep-Alive works is by having the client send periodic packets to the server with no data inside.

If the server does not receive one of these, it will assume that something has gone wrong with the network and then send an acknowledgement packet back to the client so it knows that everything is working correctly.

Another way Keep-Alive works is by using a different type of packet called a "synchronise packet". This type of packet only has an ACK reply, which says that yes, we can still communicate between one another.

The server would send this type of packet every 100 milliseconds, which is a relatively long time frame, and the client will just wait for one of these.

The HTTP Keep-Alive extension allows servers to send a "keep-alive" message to a client, requesting that the client keep its connection open. If the client agrees, it will send periodic "keep-alive" messages back to the server.

If not, it will close its connection as usual. Keep-alive is one type of connection maintenance in which the server sends a message to the client asking it to keep its connection open.

Some examples are:- HTTP Keepalive Extension - TCP SYN (Connection) - TCP FIN (Closing Connection) - TLS KeepaliveClient-to-server connection maintenance involves sending a message to the server asking it to maintain a connection open.

Virtues of Keep-Alive

By using the HTTP keep-alive header, you can save time by making sure clients and servers remain in touch. In addition, persistent connections reduce the number of TCP and SSL/TLS connection requests, which lowers round trip times (RTTs).


An established TCP connection first requires a three-way handshake between the client and the server. This involves an exchange of SYN and ACK packets before data can be sent. By using a keep-alive header, this process does not have to be repeated continuously. Consequently:

  1. Improved CPU Efficiency - Creating new TCP connections requires a lot of CPUs and memory. This can be reduced by keeping connections alive longer.
  2. Drop in network congestion - By reducing the number of TCP connections between your servers and clients, network congestion can be reduced.
  3. Web page speed - Multiple files can be served at the same time using the same connection to reduce latency and speed up webpage loading.
  4. Lowers latency- A reduction in the number of three-way handshakes can lead to a lower site latency. This can be accurate for SSL/TLS connections, which require additional round-trips for encrypting and verifying connections.
  5. Saves network resource - Using a single connection per client is less resource-intensive for the network.

The Pitfalls of Connection Keep-Alive

Connection keep-alive is a technique used to maintain a connection to the internet. It is used to keep the session open in order to make it easier for other devices on the same network to access the internet.

Connection keep-alive can cause problems with media streaming and gaming because of intermittent connectivity. This can cause buffering and lag time in the experience of the user.


This keeps a session open with the server, meaning that there is a single connection being maintained between the client and server rather than multiple connections for every request.

Live streaming can also be affected by this because some requests may time out and other queued requests might not be sent because they will not be present.

Wrap-Up - Is Keep-Alive A Good Practice For Your Website?

To recapitulate, HTTP keep alive is a mechanism that improves the speed and performance of network connections by holding an open, idle connection to a remote system or node.

HTTP Keep - Alive possess both pros and cons to influence its attributes. Thus by endorsing it the networks will have less latency. As well as has reduced packet loss because packets are sent more frequently.

Accordingly, bandwidth is used more efficiently, so there is less chance of congestion. Besides Application performance will be improved as data transfer rates are increased.

Monitor API performance metrics with Atatus

Make sure to monitor your internal, external, and third-party APIs for their functionality, availability, and performance metrics to understand what your actual users experience when using the API.

Verify that the rest APIs are performing correctly and track metrics like latency, response time, and other metrics to ensure the best performance.

By employing Atatus take control of the most critical failures of the REST API. There is a possibility that a single API could cause significant issues for any of your components, and possibly lead to widespread failures that you are unaware of.

Be sure that your API does not suffer from any performance-related issues such as data coming through, latency, response time, and other performance-related metrics.Start fixing issues impacting your users right now by signing up 14days free trial!


#1 Solution for Logs, Traces & Metrics

tick-logo APM

tick-logo Kubernetes

tick-logo Logs

tick-logo Synthetics

tick-logo RUM

tick-logo Serverless

tick-logo Security

tick-logo More



Content Writer at Atatus.