When using CURL to make HTTP requests, understanding the exchanged data can provide insights into how servers respond and handle requests. This blog post analyzes a simple CURL request to Google and breaks down the request-response flow, including HTTP versions, headers, and chunked data.

Running the CURL Command

Run the following command to send a request as a test to the Google server:

curl -v --trace output.txt http://google.com

-v for verbose output, displaying request and response details.
--trace logs detailed output to output.txt file.

The full output.txt file: output.txt

If we open the output.txt file, we will see the following result at the top:

== Info:   Trying 142.251.140.14:80...
== Info: Connected to google.com (142.251.140.14) port 80 (#0)

This indicates that CURL is resolving the actual IP address of google.com using the DNS protocol and attempting to establish a connection over port 80 using the HTTP protocol (without TLS encryption).

Once the client and server connected to each other, the client sends an HTTP request with the following headers:

=> Send header, 74 bytes (0x4a)
0000: 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a        GET / HTTP/1.1..
0010: 48 6f 73 74 3a 20 67 6f 6f 67 6c 65 2e 63 6f 6d           Host: google.com
0020: 0d 0a 55 73 65 72 2d 41 67 65 6e 74 3a 20 63 75        ..User-Agent: cu
0030: 72 6c 2f 37 2e 38 38 2e 31 0d 0a 41 63 63 65 70        rl/7.88.1..Accep
0040: 74 3a 20 2a 2f 2a 0d 0a 0d 0a                                           t: */*....

Explanation of the Request

GET / HTTP/1.1: specifies the HTTP GET request for the root path (/) of the website.
Host: google.com: specifies the destination hostname.
User-Agent: Identifies which software making the request.
Accept: Indicates that the client can accept which types of content in the response...

Understanding the Hexadecimal Dump

The hexadecimal representation of the request headers shows the raw byte values being transmitted:

0000: 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a

If The whole hexadecimal converted to ASCII) it will be: GET / HTTP/1.1..
If only take 47 45 54 they mean GET as follows:

47 (Hex) = G (ASCII)
45 (Hex) = E (ASCII)
54 (Hex) = T (ASCII)

How the Server Sends the Response

After the client sends the request, the server processes it and prepares a response. The response is divided into chunks, but in this specific case, all chunks are sent together in a single transmission. This means:

The server waits until the response is fully generated.
The response is split into chunks internally (as seen in the hexadecimal output).
Instead of sending chunks one by one, the server sends all chunks together in a single network transmission.
The client receives the response all at once, but it is still structured in chunks.

<= Recv header, 32 bytes (0x20)
0000: 48 54 54 50 2f 31 2e 31 20 33 30 31 20 4d 6f 76 HTTP/1.1 301 Mov
0010: 65 64 20 50 65 72 6d 61 6e 65 6e 74 6c 79 0d 0a ed Permanently..

<= Recv header, 34 bytes (0x22)
0000: 4c 6f 63 61 74 69 6f 6e 3a 20 68 74 74 70 3a 2f Location: http:/
0020: 0d 0a ..

<= Recv header, 40 bytes (0x28)
0000: 43 6f 6e 74 65 6e 74 2d 54 79 70 65 3a 20 74 65 Content-Type: te
0010: 78 74 2f 68 74 6d 6c 3b 20 63 68 61 72 73 65 74 xt/html; charset
0020: 3d 55 54 46 2d 38 0d 0a =UTF-8..

Each Recv header line represents a separate chunk of the response. However, in this case:

The entire response was sent at once—the server didn’t delay individual chunks.
The data was structured in chunks internally, but all arrived together.
This behavior is different from streaming or long responses, where chunks may be sent over time.

Why This Happens

Google’s server handled this as a quick, small response (a simple redirect), so:

The server did not need to send chunks separately over time.
The response was fully prepared before sending.
All chunks were transmitted in one network response.

Note: For larger responses or long-running server processes like a large file uploading or downloading , chunks may be sent gradually over time.

Practically analyzing HTTP Request-Response Flow | Headers, Chunks, and Server Behavior