How to inspect HTTP traffic with curl in the terminal

Why curl is essential for software developers

When developing web systems or integrating third-party services, understanding the exact behavior of network requests is critical. The curl command-line utility is an extremely versatile tool used to transfer data using URLs. In practice, this means we can simulate any browser or HTTP client directly in the terminal, testing APIs and servers without opening heavy software. For anyone starting in software engineering or needing to debug a quick error, mastering this tool saves hours of investigation and eliminates guesswork regarding connection failures.

The great advantage of curl is its native presence on most modern operating systems, such as Linux, macOS, and recent Windows versions. Furthermore, its utility extends beyond traditional web development, integrating seamlessly with other system utilities and enabling automated health checks on production servers. As we detail in our guide on how to use curl to test APIs and HTTP headers effectively, the versatility of simple commands solves most daily integration issues.

Understanding the lifecycle of an HTTP request requires looking beyond the visible browser screen. When a client makes a request to a server, an exchange of invisible metadata occurs, defining data formats, session validity, and security rules. Curl puts this entire invisible ecosystem at your fingertips, letting you see precisely what enters and leaves your application.

Revealing response headers and metadata

The default behavior of curl displays only the response body sent by the server, omitting the HTTP headers containing crucial transaction information. To fix this and view the complete response, we use the uppercase i flag. In practice, this command displays the metadata preceding the useful content, allowing you to inspect details such as server type, caching policies, and set cookies.

To test receiving these data points in a real environment, you can run the following instruction in your terminal:

curl -i https://api.example.com/v1/status

Executing this instruction causes the command line to output the HTTP protocol and status code first, followed by several header lines and finally the message body. This visibility is the first step in diagnosing why an API is rejecting a request or sending data in an unexpected format.

Diagnosing status codes and redirects

HTTP status codes are three-digit numbers indicating the result of a request, such as the famous 200 for success, 404 for page not found, or 500 for internal server error. Curl makes it easy to view these codes quickly, but there is an important detail: servers often redirect clients to another address, and curl does not follow this path automatically by default.

To force the utility to follow redirects to the final destination, we add the lowercase l flag. Here is how to structure the command:

curl -L -I https://example.com/old-page

This approach is excellent for verifying whether a temporary redirect was configured correctly without causing infinite loops that freeze the end-user browser. The uppercase I parameter limits output strictly to headers, saving bandwidth and easing quick reading. To complement this implementation in production environments, see our related technical analyses on How to test shorted ceramic capacitors on board with multimeter and How to use debounce and throttle in inputs to optimize forms.

Measuring response time and API performance

Identifying whether an API is slow requires precise metrics on each step of the network connection, from address resolution to receiving the first byte. Curl features an advanced output formatting capability that lets you extract the exact duration of each executed phase.

We can create a temporary configuration file or pass a custom format directly on the command line to get a complete latency report. Use the following command to measure route performance:

curl -w "Total time: %{time_total}s\nDNS time: %{time_namelookup}s\n" -o /dev/null -s https://api.example.com/ping

This detailed reading helps isolate whether sluggishness stems from domain resolution, secure connection handshakes, or internal server processing time, serving as a baseline for infrastructure upgrades and code optimizations.

Mastering HTTP traffic inspection with curl transforms how you interact with web services and troubleshoot integration issues. The ability to audit headers, trace redirects, and measure response times directly from the terminal eliminates dependence on complex interfaces. Integrating this knowledge into your daily development workflow guarantees faster diagnostics and much more resilient systems.

Constant practice and experimentation with different parameters will further expand your technical autonomy when facing complex infrastructure and backend development scenarios.