Learn Curl - Pre-Requisites Skills & Environment Setup

#Introduction

Welcome to the Learn Curl series! This series will take you to master curl — the most widely used URL-based data transfer CLI and library in the world — from your first HTTP request to scripting, API testing, and production hardening. There are 23 episodes in total that will build your understanding layer by layer, from conceptual foundations to practices ready for the real working world.

But before typing your first curl command, there are a few basic skills and tools you must have and prepare first. Why are these prerequisites important? Because curl is a client — it talks to servers over the network using the HTTP protocol. If you don't yet understand how an HTTP conversation works, or aren't comfortable in a terminal, curl commands will feel like magic spells that sometimes work and sometimes don't, without you knowing why.

Imagine wanting to become a train driver but not yet understanding the tracks and travel signals. No matter how great the locomotive is — and curl is a very great locomotive — it's still hard to move forward without understanding the route. Episode 0 is your roadmap: we'll prepare the basic skills, make sure curl 8.21.x is installed and verified, then round out the supporting tools that will accompany you throughout the series.

#Basic Skills You Must Have

#Willingness to Learn the CLI

Curl is a Command Line Interface (CLI) tool. All of its power is accessed through a terminal — not mouse clicks. That's why the first step is to prepare your mindset: not being afraid to type, being willing to read errors, and being patient in building muscle memory.

A simple analogy: a GUI is like a TV remote control — simple, but limited to the buttons available. The CLI is like an aircraft control panel — intimidating at first, but it gives you full control over every aspect. All the DevOps work you'll encounter — testing APIs, checking servers, running scripts — starts with a command in the terminal.

Before wrestling with curl, make sure you're comfortable navigating the terminal. At a minimum, these four commands are enough as a starting point:

Command	Function
`pwd`	Shows the current working directory
`ls`	Lists directory contents
`cd`	Change to another directory
`man`	Read a command's manual

One concept you must understand from now on: stdout. When curl succeeds, its output is written to stdout — that is, your terminal screen. This output can be redirected to a file with > (redirect) or piped to another command with | (pipeline). You'll keep using this pattern, for example curl ... | jq — so understand it early on.

#Basic HTTP Concepts

HTTP (Hypertext Transfer Protocol) is the protocol you'll use most often with curl. Every HTTP request starts from a single thing called a URL — this is the destination address for transfers, and curl was indeed born to "send data via URLs".

A URL's anatomy can be broken down into five components:

Component	Example	Function
Scheme	`https`	Protocol used
Host	`example.com`	Target server's domain name
Port	`443`	Connection port on the server (default if not written)
Path	`/api/users`	Resource location on the server
Query	`?page=2`	Additional parameters for the request

Once you understand URLs, also understand the shape of the conversation: request and response. The client (curl) sends a request containing a method, path, headers, and sometimes a body. The server answers with a response containing a status code, headers, and a body. The two things most often mentioned are the method (type of action) and the status code (the outcome).

Method	Function
GET	Read data without changing anything
POST	Send new data
PUT	Replace a resource entirely
PATCH	Modify part of a resource
DELETE	Delete a resource
HEAD	Same as GET, but headers only

Status codes are the "report card" of a request. You don't need to memorize hundreds of codes; just recognize the five classes:

Class	Meaning	Example
2xx	Success	200 OK, 201 Created
3xx	Redirect	301 Moved Permanently, 302 Found
4xx	Client error	400 Bad Request, 404 Not Found
5xx	Server error	500 Internal Server Error, 503 Service Unavailable

Later, when you run curl -I https://example.com and see HTTP/2 200, you won't be confused anymore — that's a 2xx class status code, meaning everything is working well.

#Basic Networking Concepts

Besides HTTP, there are four network concepts that will keep appearing throughout this series:

Concept	Explanation	Analogy
DNS	Translates domain names into IP addresses	Phone book: you remember the name, the system finds the number
IP Address	A server's unique address on the internet	Home address
Port	A specific door on a server	Apartment unit number: 80 for HTTP, 443 for HTTPS
TLS/SSL	Encrypts data in transit	Sealed envelope: the contents can only be safely read by the recipient
Proxy	An intermediary between client and server	A receptionist who forwards your mail

Why does this matter? Because curl "talks" directly with all these layers. When curl sends a request to https://example.com, it performs DNS resolution, opens a TCP connection to port 443, performs a TLS handshake, and only then sends the HTTP request. In episode 2 we'll dissect this flow step by step.

#Environment Setup & Verification

#Is Curl Already Installed?

The good news: curl 8.21.x is almost certainly already on your computer. On macOS, curl has been bundled with the system for a long time. Most Linux distros also include it by default — just open a terminal and type:

Check curl version

curl --version

Example output on a Linux system

curl 8.21.0 (x86_64-pc-linux-gnu) libcurl/8.21.0 OpenSSL/3.0.13 zlib/1.3.1 brotli/1.1.0
Release-Date: 2026-06-17
Protocols: dict file ftp ftps gopher gopher-hs http https imap imaps ldap ldaps mqtt pop3 pop3s rtsp scp sftp smb smbs smtp smtps telnet tftp ws wss
Features: alt-svc AsynchDNS brotli HSTS HTTP2 HTTP3 HTTPS-proxy IPv6 Largefile libz NTLM SSL threadsafe TLS-SRP UnixSockets zstd

Note three important parts of the output above:

First line — the curl version (curl 8.21.0) and the libcurl version (libcurl/8.21.0). Both follow the same number since the project was unified.
Protocols line — the list of protocols your curl build supports. This list is why curl is called a versatile transfer tool.
Features line — capabilities enabled at compile time. Must-haves: SSL (so HTTPS works), HTTP2 and HTTP3 (modern web protocols), and brotli (response compression).

Tip

The features listed in curl --version are determined when curl is compiled — not when it's installed. The default builds on macOS and Linux distros are almost always complete. If you come across a build lacking SSL or HTTP2, it's better to reinstall the official curl version than to fight against that build's limitations.

On Windows 10+, you can run curl directly from PowerShell or Command Prompt without installing anything. If you want an experience closer to the real working world, use WSL2 — there curl runs as a native Linux binary.

#If It's Not Installed

If curl --version instead shows command not found, install it with the package manager for your system:

sudo apt update
sudo apt install curl

#Supporting Tools

Curl is great on its own, but some jobs will be far easier with the three following companion tools:

Tool	Use in This Series	Verification
`jq`	Parse and colorize JSON output from APIs	`jq --version`
`git`	Version control; fetch sample scripts and contribute	`git --version`
`openssl`	Inspect TLS certificates and encrypted connection details	`openssl version`

jq matters most because most modern APIs return JSON, and the JSON & REST API testing episode will use it in almost every example. Make sure all three are installed by running:

Verify supporting tools

jq --version
git --version
openssl version

#Episode 0 Summary Checklist

Comfortable typing in the terminal (pwd, ls, cd, man).
Understand URL anatomy and the request/response conversation.
Know the HTTP methods and the five status code classes.
Understand the roles of DNS, port, TLS, and proxy.
curl --version shows 8.21.x with the SSL, HTTP2, HTTP3, and brotli features.
jq, git, and openssl are installed.

#Closing

In this episode 0 you've laid the foundation for the entire series: understanding basic CLI skills and HTTP concepts (URL, request/response, methods, status codes), knowing basic networking (DNS, port, TLS, proxy), making sure curl 8.21.x is installed and verified with complete features, and rounding out the supporting tools jq, git, and openssl.

Key takeaways:

Curl is a CLI tool — get comfortable with the terminal, because that's where all its power is accessed.
HTTP (URL, methods, status codes) is the language you'll speak with curl every day.
Verify your build with curl --version: make sure the SSL, HTTP2, HTTP3, and brotli features are present.
Prepare jq, git, and openssl as companions throughout the series.

In the next episode 1 we'll discuss the history, background, and why the world needs curl — from httpget written by Daniel Stenberg in 1996, curl's birth in 1998, to how a small project became the de-facto standard for URL-based data transfer for more than 25 years. Make sure your environment is ready, because the Learn Curl journey has just begun!