Skip to content

curl Aide-mémoire

Outil en ligne de commande pour transférer des données avec des URLs.

01

Démarrage

Requêtes de base

curl effectue des requêtes HTTP depuis la ligne de commande. Par défaut, c'est un GET. -v affiche une sortie détaillée, -o enregistre dans un fichier nommé, -O conserve le nom de fichier distant, -L suit les redirections, -I récupère uniquement les en-têtes (requête HEAD).

curl
# GET request (default)
curl https://example.com

# with verbose output
curl -v https://example.com

# save output to file
curl -o output.html https://example.com
curl -O https://example.com/file.zip   # keep remote filename

# follow redirects
curl -L https://example.com/redirect

# show only headers
curl -I https://example.com
curl --head https://example.com

Sortie et sauvegarde

-o écrit le corps dans un fichier nommé ; -O utilise le nom de fichier distant. --output-dir définit le répertoire de destination. -s (silencieux) masque la barre de progression et les erreurs — associez-le à -S pour afficher quand même les erreurs. Utilisez -D pour décharger les en-têtes dans un fichier tout en jetant le corps avec -o /dev/null.

curl
# print body to stdout (default)
curl https://example.com

# save body to file
curl -o page.html https://example.com

# save with remote filename
curl -O https://example.com/file.zip

# save to specific dir with remote name
curl -O --output-dir /tmp https://example.com/file.zip

# append to file
curl https://example.com >> log.txt

# discard body, keep headers
curl -o /dev/null -D headers.txt https://example.com

# silent (no progress, no errors)
curl -s https://example.com

Sortie verbeuse et en-têtes

-v (verbose) affiche la conversation complète : '>' est la requête, '<' est la réponse, '*' est une info de curl — tout part vers stderr, donc stdout reste propre pour le corps. -I envoie une requête HEAD et affiche les en-têtes. -D décharge les en-têtes dans un fichier ou '-' pour stdout ; combinez avec -o /dev/null pour inspecter les en-têtes sans enregistrer le corps.

curl
# verbose: shows request + response, sent to stderr
curl -v https://example.com

# > lines are the request, < lines are the response
# * lines are curl's internal info

# headers only (HEAD request)
curl -I https://example.com

# dump response headers to file
curl -D headers.txt -o body.html https://example.com

# dump headers to stdout, body to file
curl -D - -o body.html https://example.com

# show only response headers (no HEAD)
curl -s -o /dev/null -D - https://example.com

Suivre les redirections

-L suit les redirections HTTP 3xx ; par défaut, curl suit jusqu'à 50 sauts (limitez avec --max-redirs). RFC 301/302 convertit généralement POST en GET — utilisez --post301/--post302 pour conserver la méthode. Par défaut, les identifiants ne sont pas envoyés aux hôtes redirigés ; --location-trusted les envoie partout (risque de sécurité).

curl
# follow 3xx redirects
curl -L https://example.com/old

# limit number of redirects
curl -L --max-redirs 5 https://example.com

# treat redirects as POST (default resends as GET)
curl -L --post301 --post302 https://example.com

# show each hop in a redirect chain
curl -L -v https://short.url/abc 2>&1 | grep -i location

# follow only http/https redirects
curl -L --proto-redir http,https https://example.com

# send credentials only on first request
curl -L --location-trusted -u user:pass https://example.com

Syntaxe d'URL et globbing

curl développe les motifs de « globbing » d'URL : plages [1-10], listes {a,b,c}, avec un :step optionnel. Chaque développement déclenche une requête distincte. Utilisez -g (--globoff) pour traiter crochets et accolades littéralement — important pour les URLs contenant des tableaux JSON ou des adresses IPv6 comme http://[::1]:8080/.

curl
# range glob: requests file1, file2, file3
curl -O https://example.com/file[1-3].zip

# range with step
curl -O https://example.com/file[1-10:2].zip   # 1,3,5,7,9

# list glob: a, b, c
curl -O https://example.com/{a,b,c}.zip

# combined globs
curl -O https://example.com/{v1,v2}/file[1-2].txt

# output each URL as it is fetched
curl -O https://example.com/file[1-3].zip --write-out "%{url} -> %{filename}\n"

# disable globbing (literal brackets/braces)
curl -g "https://example.com/file[1].zip"

Aide et version

--version affiche la version de curl, les protocoles pris en charge (HTTP, HTTPS, FTP, etc.) et les fonctionnalités compilées (HTTP2, SSL, brotli). --help all liste toutes les options — pratique quand on se souvient d'un morceau de nom de flag. Les fonctionnalités dépendent de la compilation de curl (HTTP/3 exige par exemple une build spéciale).

curl
# version and supported features
curl --version

# short help (one-line per option)
curl --help

# long help (all options with details)
curl --help all

# search help for a keyword
curl --help all | grep -i cookie

# list supported protocols
curl --version | head -1

# check if a feature is built in
curl --version | grep -i http2
02

Méthodes HTTP

Requêtes GET

GET est la méthode par défaut. Mettez toujours les URLs contenant & ou ? entre guillemets pour que le shell ne les passe pas en arrière-plan ni ne les développe. -X définit explicitement la méthode mais est généralement inutile pour GET. Pour les API, définissez Accept pour négocier le format de réponse.

curl
# simple GET (default method)
curl https://api.example.com/data

# GET with query string
curl "https://api.example.com/search?q=curl&page=2"

# explicit method
curl -X GET https://example.com

# GET with headers
curl -H "Accept: application/json" https://api.example.com/data

# GET with auth
curl -u user:pass https://api.example.com/secret

Requêtes POST

Envoyer -d bascule automatiquement la méthode en POST, donc -X POST est redondant (mais inoffensif et explicite). Pour poster un fichier, utilisez -d @filename (le @ lit le fichier). Le Content-Type par défaut de -d est application/x-www-form-urlencoded ; remplacez-le par -H pour du JSON.

curl
# POST with form data (application/x-www-form-urlencoded)
curl -X POST -d "name=Alice&age=30" https://api.example.com/users

# -d implies POST, so -X is optional
curl -d "name=Alice" https://api.example.com/users

# POST with no body
curl -X POST https://api.example.com/trigger

# POST JSON
curl -X POST -H "Content-Type: application/json" \
     -d '{"name":"Alice"}' https://api.example.com/users

# POST with data from a file
curl -X POST -d @form.txt https://api.example.com/users

PUT et PATCH

PUT remplace une ressource entière ; PATCH applique une mise à jour partielle. Les deux exigent -X car curl n'a pas de raccourci -d pour eux. -T (upload-file) envoie un fichier en flux comme corps de requête, idéal pour les uploads PUT. Utilisez --data-binary au lieu de -d pour éviter de supprimer les sauts de ligne lors de l'envoi de fichiers bruts.

curl
# PUT (replace entire resource)
curl -X PUT -H "Content-Type: application/json" \
     -d '{"name":"Alice","age":31}' \
     https://api.example.com/users/1

# PATCH (partial update)
curl -X PATCH -H "Content-Type: application/json" \
     -d '{"age":32}' \
     https://api.example.com/users/1

# PUT a file as body
curl -X PUT --data-binary @config.json \
     -H "Content-Type: application/json" \
     https://api.example.com/config

# PUT with upload file
curl -X PUT -T localfile.txt https://example.com/remote.txt

DELETE

DELETE supprime une ressource. La plupart des API exigent une authentification, donc ajoutez -u ou un en-tête Authorization. Certaines API acceptent un corps (raison, flags de cascade) — ajoutez -d et un en-tête Content-Type. Utilisez -w '%{http_code}' pour vérifier le résultat : 204 (No Content) et 200 sont des succès typiques.

curl
# delete a resource
curl -X DELETE https://api.example.com/users/1

# delete with auth
curl -X DELETE -H "Authorization: Bearer TOKEN" \
     https://api.example.com/users/1

# delete with confirmation check
curl -X DELETE -w "%{http_code}" -o /dev/null -s \
     https://api.example.com/users/1

# delete with request body (some APIs require it)
curl -X DELETE -H "Content-Type: application/json" \
     -d '{"reason":"spam"}' \
     https://api.example.com/users/1

HEAD et OPTIONS

-I envoie une requête HEAD (en-têtes seuls, sans corps) — utile pour vérifier la taille (Content-Length), le type (Content-Type) et la dernière modification sans télécharger. OPTIONS révèle les méthodes autorisées (l'en-tête Allow) et sert au preflight CORS des navigateurs. Ajoutez les en-têtes Origin et Access-Control-Request-Method pour simuler un vrai preflight.

curl
# HEAD: headers only, no body
curl -I https://example.com
curl --head https://example.com

# OPTIONS: discover allowed methods
curl -X OPTIONS https://api.example.com/users

# OPTIONS with CORS preflight headers
curl -X OPTIONS \
     -H "Origin: https://mysite.com" \
     -H "Access-Control-Request-Method: POST" \
     https://api.example.com/users

# check allowed methods from Allow header
curl -X OPTIONS -s -D - -o /dev/null https://api.example.com | grep -i allow
03

En-têtes

Définir des en-têtes (-H)

-H (--header) ajoute un en-tête de requête. Répétez -H pour plusieurs en-têtes. Un point-virgule final (X-Empty;) envoie une valeur vide. @headers.txt lit les en-têtes depuis un fichier (un 'Nom: valeur' par ligne) — pratique pour garder les tokens Authorization hors de l'historique du shell.

curl
# single header
curl -H "Accept: application/json" https://api.example.com/data

# multiple headers
curl -H "Accept: application/json" \
     -H "Authorization: Bearer TOKEN" \
     -H "X-Custom: value" \
     https://api.example.com/data

# header with empty value
curl -H "X-Empty;" https://example.com

# headers from a file (one per line)
curl -H @headers.txt https://example.com

# Content-Type for POST
curl -X POST -H "Content-Type: application/json" \
     -d '{"a":1}' https://api.example.com

En-têtes courants

Les en-têtes les plus courants : Accept indique au serveur le format souhaité ; Content-Type décrit le corps de la requête ; Authorization transporte les identifiants. --compressed demande à curl de requêter des réponses compressées (gzip, br) et de les décompresser automatiquement, sans gestion manuelle de l'encodage.

curl
# Accept: negotiate response format
curl -H "Accept: application/json" https://api.example.com
curl -H "Accept: text/html" https://example.com

# Content-Type: describe request body
curl -H "Content-Type: application/json" -d '{"a":1}' https://api.example.com
curl -H "Content-Type: application/x-www-form-urlencoded" -d "a=1" https://api.example.com

# Authorization: credentials
curl -H "Authorization: Bearer TOKEN" https://api.example.com

# Accept-Encoding: ask for compression
curl -H "Accept-Encoding: gzip, br" --compressed https://example.com

# Cache-Control
curl -H "Cache-Control: no-cache" https://api.example.com

User-Agent

Certains serveurs bloquent le User-Agent par défaut de curl. -A (--user-agent) le définit ; un -A vide le supprime entièrement. La forme longue est -H 'User-Agent: ...'. Beaucoup de sites anti-scraping vérifient les signatures de vrais navigateurs, un User-Agent réaliste est donc souvent nécessaire.

curl
# default User-Agent looks like: curl/8.7.1
curl -v https://example.com 2>&1 | grep -i user-agent

# set a custom User-Agent
curl -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" https://example.com
curl -H "User-Agent: MyBot/1.0" https://example.com

# empty User-Agent
curl -A "" https://example.com

# fake a real browser (some sites require it)
curl -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) \
AppleWebKit/537.36 (KHTML, like Gecko) \
Chrome/120.0 Safari/537.36" https://example.com

# per-site default via config
# user-agent = "MyBot/1.0"  in ~/.curlrc

Referer et Host

-e (--referer) définit l'en-tête Referer. Remplacer Host est essentiel pour tester des virtual hosts par IP : le serveur choisit le bon site selon Host. Les endpoints sensibles au CORS exigent souvent Origin ; X-Forwarded-For/Proto simulent des requêtes derrière un proxy ou un load balancer.

curl
# set Referer header
curl -H "Referer: https://google.com" https://example.com/page
curl -e https://google.com https://example.com/page

# set Host header (override DNS)
curl -H "Host: api.example.com" https://192.168.1.10/users

# combined: test a vhost by IP with custom Host
curl -H "Host: api.example.com" \
     -H "X-Forwarded-Proto: https" \
     http://10.0.0.5/health

# Origin header (for CORS/POST forms)
curl -H "Origin: https://mysite.com" \
     -X POST -d "x=1" https://api.example.com/form

# X-Forwarded-For (debugging proxies)
curl -H "X-Forwarded-For: 1.2.3.4" https://api.example.com

Supprimer des en-têtes

Fournir -H 'Header-Name:' (avec deux-points mais sans valeur) demande à curl de n'envoyer aucune valeur pour cet en-tête, supprimant ainsi un en-tête par défaut comme User-Agent ou Accept-Encoding. curl remplace un en-tête si vous précisez à nouveau le même nom au lieu d'envoyer des doublons. Utile pour envoyer la requête minimale.

curl
# remove a header by giving it no value
curl -H "User-Agent:" https://example.com

# remove Accept-Encoding (disable compression)
curl -H "Accept-Encoding:" https://example.com

# remove all auto-added headers and send minimal request
curl -H "Host:" -H "User-Agent:" -H "Accept:" https://example.com

# prevent curl from adding Accept-Encoding
curl --no-keepalive https://example.com

# replace a default header instead of adding a duplicate
# (curl replaces, doesn't duplicate, when -H name matches)
curl -H "Accept: text/plain" https://example.com
04

Données POST et formulaires

Données de formulaire (-d)

-d (--data) envoie des données de formulaire encodées en URL et bascule la méthode en POST. Plusieurs flags -d sont joints par &. -d supprime les espaces et sauts de ligne en début/fin ; --data-binary les préserve ; --data-raw désactive complètement la fonctionnalité @file (une valeur littérale commençant par @ est alors envoyée telle quelle).

curl
# URL-encoded form data
curl -d "name=Alice&age=30" https://api.example.com/form

# explicit POST (same result; -d implies POST)
curl -X POST -d "name=Alice" https://api.example.com/form

# multiple -d are joined with &
curl -d "name=Alice" -d "age=30" https://api.example.com/form

# -d strips newlines; use --data-binary to preserve them
curl --data-binary "line1\nline2" https://api.example.com

# raw data, no content-type added
curl --data-raw "name=Alice&age=30" https://api.example.com

# default Content-Type: application/x-www-form-urlencoded
curl -v -d "a=1" https://api.example.com 2>&1 | grep -i content-type

Encodage URL

--data-urlencode encode en pourcentage la valeur (ou tout le name=value), inutile d'encoder manuellement les espaces, &, = ou les caractères non ASCII. Avec name@file, le contenu du fichier est encodé en URL comme valeur. Utilisez-le toujours pour les données fournies par l'utilisateur afin de ne pas casser la structure du formulaire.

curl
# spaces and special chars must be encoded
curl -d "name=Alice%20Smith" https://api.example.com
curl -d "name=Alice+Smith" https://api.example.com

# --data-urlencode encodes the value for you
curl --data-urlencode "name=Alice Smith" https://api.example.com
curl --data-urlencode "[email protected]" https://api.example.com

# encode name=value pair (both encoded)
curl --data-urlencode "name=Alice & Bob" https://api.example.com

# encode only the value after =, with explicit content-type
curl --data-urlencode "query=SELECT * FROM users" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     https://api.example.com/search

# encode content of a file
curl --data-urlencode [email protected] https://api.example.com

Données binaires

--data-binary envoie un fichier octet par octet (en préservant les sauts de ligne et les octets nuls), contrairement à -d qui les supprime. -T envoie le fichier en flux, la mémoire reste donc faible pour les gros uploads. Pour envoyer des données pré-compressées, pipez-les avec -H 'Content-Encoding: gzip' — le serveur doit le prendre en charge ; sinon utilisez Transfer-Encoding: chunked.

curl
# send a binary file as the body
curl --data-binary @image.png https://api.example.com/upload

# upload with explicit content type
curl --data-binary @image.png \
     -H "Content-Type: image/png" \
     https://api.example.com/upload

# raw bytes (no @ expansion, no stripping)
curl --data-raw "$(printf '\x00\x01\x02')" https://api.example.com

# stream a large file without buffering in memory
curl -T bigfile.iso https://api.example.com/upload

# send gzipped body
gzip -c data.json | curl --data-binary @- \
     -H "Content-Encoding: gzip" \
     -H "Content-Type: application/json" \
     https://api.example.com/data

Lire depuis un fichier (@file)

-d @file lit le corps de la requête depuis un fichier (le @ déclenche la lecture du fichier). --data-binary @file préserve les octets. -d @- lit depuis stdin — parfait pour piper jq, curl ou d'autres transformations. Si une valeur littérale commence par @ et que vous ne voulez pas de lecture de fichier, utilisez --data-raw.

curl
# read body from a file
curl -d @data.txt https://api.example.com/form

# read JSON body from a file
curl -H "Content-Type: application/json" \
     -d @payload.json https://api.example.com

# binary-safe file read
curl --data-binary @image.png https://api.example.com/upload

# read from stdin
echo '{"a":1}' | curl -d @- https://api.example.com

# pipe through curl (transform then send)
jq '{name, age}' input.json | \
  curl -H "Content-Type: application/json" -d @- https://api.example.com

# file name starting with @ (use --data-raw)
curl --data-raw "@mention" https://api.example.com

Content-Type et formulaires

Faites toujours correspondre Content-Type au format du corps : application/x-www-form-urlencoded (défaut de -d), application/json (avec -H), multipart/form-data (défini automatiquement par -F), text/xml pour SOAP. Ajouter charset=utf-8 est une bonne pratique pour les données non ASCII. Un décalage fait que le serveur rejette ou analyse mal le corps.

curl
# default for -d: application/x-www-form-urlencoded
curl -d "name=Alice" https://api.example.com

# JSON body
curl -H "Content-Type: application/json" \
     -d '{"name":"Alice"}' https://api.example.com

# multipart form (file upload, see File Upload section)
curl -F "[email protected]" https://api.example.com/upload

# text/plain body
curl -H "Content-Type: text/plain" -d "hello" https://api.example.com

# XML body (SOAP)
curl -H "Content-Type: text/xml" \
     -d '<?xml version="1.0"?><env:Envelope/>' \
     https://api.example.com/soap

# set charset explicitly
curl -H "Content-Type: application/json; charset=utf-8" \
     -d '{"name":"éàç"}' https://api.example.com
05

Requêtes JSON

POST JSON de base

Les requêtes JSON exigent -H 'Content-Type: application/json' plus -d avec une chaîne JSON. Entourez le JSON de guillemets simples pour que le shell ne touche pas aux guillemets doubles internes. Pipez la réponse dans jq '.' pour une sortie lisible, ou jq '.field' pour extraire une valeur précise.

curl
# JSON POST request
curl -X POST \
     -H "Content-Type: application/json" \
     -d '{"name":"Alice","age":30}' \
     https://api.example.com/users

# -d already implies POST, so -X is optional
curl -H "Content-Type: application/json" \
     -d '{"name":"Alice"}' \
     https://api.example.com/users

# ask for JSON back
curl -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     -d '{"name":"Alice"}' \
     https://api.example.com/users

# pretty-print the JSON response (pipe to jq)
curl -s -H "Accept: application/json" \
     https://api.example.com/users/1 | jq .

JSON depuis un fichier

Pour un JSON complexe, stockez-le dans un fichier .json et utilisez -d @file (ou --data-binary @file pour préserver les octets exacts, y compris les sauts de ligne finaux). Piping jq -n permet de construire le JSON par programmation sans échappement pénible. Validez toujours avec jq . d'abord — une erreur de syntaxe gaspille une requête.

curl
# POST JSON body from a file
curl -H "Content-Type: application/json" \
     -d @payload.json https://api.example.com/users

# binary-safe (preserves exact bytes)
curl -H "Content-Type: application/json" \
     --data-binary @payload.json https://api.example.com/users

# generate JSON with jq, then POST
jq -n '{name: "Alice", age: 30}' | \
  curl -H "Content-Type: application/json" \
       -d @- https://api.example.com/users

# validate JSON before sending
jq . payload.json && \
  curl -H "Content-Type: application/json" \
       -d @payload.json https://api.example.com/users

# send a JSON array
curl -H "Content-Type: application/json" \
     -d '[{"id":1},{"id":2}]' https://api.example.com/batch

JSON avec variables

Interpoler des variables dans des chaînes JSON casse sur les guillemets et caractères spéciaux. Le pattern sûr est jq --arg/--argjson : il construit un JSON valide et échappe les valeurs correctement. --arg pour les chaînes, --argjson pour nombres/booléens. Pour les secrets, préférez un fichier d'en-têtes (-H @file) aux arguments de ligne de commande pour éviter une fuite via ps.

curl
# interpolate a shell variable into JSON (risky for special chars)
NAME="Alice"
curl -H "Content-Type: application/json" \
     -d "{\"name\":\"$NAME\"}" https://api.example.com

# safer: build JSON with jq
NAME="Alice"
jq -n --arg name "$NAME" '{name: $name}' | \
  curl -H "Content-Type: application/json" -d @- https://api.example.com

# multiple variables
NAME="Alice"; AGE=30
jq -n --arg name "$NAME" --argjson age "$AGE" \
  '{name: $name, age: $age}' | \
  curl -H "Content-Type: application/json" -d @- https://api.example.com

# read secret from env, hide from ps
TOKEN="$API_TOKEN" curl -H "Authorization: Bearer $API_TOKEN" \
     -d '{"x":1}' https://api.example.com

Requêtes GraphQL

GraphQL utilise un endpoint POST unique avec un corps JSON contenant une chaîne 'query' et des 'variables' optionnelles. Écrire la requête en ligne exige d'échapper les guillemets doubles internes ; stockez donc les requêtes complexes dans un fichier .json avec -d @file. L'introspection (la requête __schema) liste les types de l'API, idéal pour l'exploration.

curl
# GraphQL query as JSON body
curl -X POST \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer TOKEN" \
     -d '{"query":"{ user(id:1) { name email } }"}' \
     https://api.example.com/graphql

# query with variables
curl -X POST \
     -H "Content-Type: application/json" \
     -d '{"query":"query($id:Int!){ user(id:$id){name} }","variables":{"id":1}}' \
     https://api.example.com/graphql

# query from a file (multi-line, no escaping pain)
curl -X POST \
     -H "Content-Type: application/json" \
     -d @query.json https://api.example.com/graphql

# introspection: list all types
curl -s -X POST -H "Content-Type: application/json" \
     -d '{"query":"{ __schema { types { name } } }"}' \
     https://api.example.com/graphql | jq

Négociation de contenu

Accept négocie le format de réponse ; beaucoup d'API REST renvoient du JSON par défaut mais acceptent XML ou CSV. --compressed demande gzip/brotli et décompresse automatiquement. Les API se versionnent souvent via Accept (ex. GitHub : application/vnd.github+json). Vérifiez le Content-Type réellement renvoyé pour confirmer la négociation.

curl
# request JSON
curl -H "Accept: application/json" https://api.example.com/users

# request XML
curl -H "Accept: application/xml" https://api.example.com/users

# request a specific version
curl -H "Accept: application/vnd.api+json; version=2" \
     https://api.example.com/users

# request anything (default is */*)
curl -H "Accept: */*" https://example.com

# request compression and auto-decompress
curl --compressed -H "Accept-Encoding: gzip, br" https://example.com

# inspect what the server actually returns
curl -s -o /dev/null -D - https://api.example.com/users | grep -i content-type
06

Upload de fichiers

Upload multipart (-F)

-F (--form) construit une requête multipart/form-data — le standard pour l'upload de fichiers. -F file=@path lit le fichier. Ajoutez ;filename= pour remplacer le nom vu par le serveur, et ;type= pour définir le Content-Type de la partie. Plusieurs fichiers dans le même nom de champ (avec [] dans beaucoup de frameworks) exigent plusieurs flags -F.

curl
# upload a file as a multipart form field
curl -F "[email protected]" https://api.example.com/upload

# -F sets POST + multipart/form-data automatically
# the @ prefix reads the file

# add a text field alongside the file
curl -F "[email protected]" -F "description=My photo" \
     https://api.example.com/upload

# rename the uploaded file (server sees "avatar.jpg")
curl -F "[email protected];filename=avatar.jpg" \
     https://api.example.com/upload

# set explicit content-type for the file part
curl -F "[email protected];type=image/jpeg" \
     https://api.example.com/upload

# upload multiple files in one field
curl -F "[email protected]" -F "[email protected]" \
     https://api.example.com/upload

Plusieurs fichiers et champs

Les formulaires multipart peuvent mélanger fichiers et champs texte. Utilisez [] dans les noms de champs pour les uploads en tableau (des frameworks comme Rails/PHP les analysent en tableaux). Un champ peut porter du JSON via ;type=application/json — le serveur le lit comme données structurées et non comme fichier. Curl ne sait pas uploader des répertoires ; tardez-les d'abord.

curl
# upload two files and a caption
curl -F "[email protected]" \
     -F "[email protected]" \
     -F "caption=Summer trip" \
     https://api.example.com/gallery

# array-style field names (PHP/Rails style)
curl -F "files[][email protected]" -F "files[][email protected]" \
     https://api.example.com/upload

# send a file's contents as a regular text field
curl -F "[email protected];type=application/json" \
     https://api.example.com/upload

# mix file and JSON fields
curl -F "[email protected]" \
     -F "options={\"priority\":\"high\"};type=application/json" \
     https://api.example.com/upload

# upload a directory as a tar (workaround)
tar -cf - mydir/ | curl -F "tar=@-;filename=dir.tar" \
     https://api.example.com/upload

Upload en flux (-T)

-T (--upload-file) utilise PUT et envoie le fichier en flux, la mémoire reste donc stable même pour d'énormes uploads — bien mieux que -d @file pour les gros volumes. -T - lit depuis stdin. -C - reprend un transfert interrompu. Avec un slash final sur l'URL, curl ajoute le nom de fichier local (comme un HTTP PUT en miroir).

curl
# upload a file with PUT (streaming, low memory)
curl -T localfile.txt https://example.com/upload/remote.txt

# upload to a URL with the local filename
curl -T localfile.txt https://example.com/upload/

# stream from stdin (pipe into PUT body)
cat data.json | curl -T - https://api.example.com/data

# upload with authentication
curl -T file.zip -u user:pass \
     https://example.com/upload/file.zip

# upload with progress bar
curl -T bigfile.iso --progress-bar \
     https://example.com/upload/bigfile.iso

# resume an interrupted upload
curl -T bigfile.iso -C - https://example.com/upload/bigfile.iso

Upload avec progression

Par défaut, curl affiche une jauge de progression sur stderr. --progress-bar bascule sur une barre plus simple. -s (silencieux) la masque ; ajoutez S (-sS) pour garder les erreurs. Les infos de progression vont sur stderr, donc stdout (le corps) reste propre — pratique pour piper. Utilisez -w avec %{size_upload} et %{time_total} pour un résumé d'une ligne.

curl
# default progress meter (terminal)
curl -T file.zip https://example.com/upload

# simple progress bar
curl -T file.zip --progress-bar https://example.com/upload

# no progress at all (silent)
curl -T file.zip -s https://example.com/upload

# show progress but only errors (silent + show-error)
curl -T file.zip -sS https://example.com/upload

# custom progress with --write-out
curl -T file.zip -w "Uploaded %{size_upload} bytes in %{time_total}s\n" \
     -o /dev/null https://example.com/upload

# redirect progress to stderr, body to file
curl -T file.zip --progress-bar 2> progress.log \
     -o response.txt https://example.com/upload

Champs et types d'upload

Curl devine le type MIME depuis l'extension du fichier. Remplacez-le avec ;type=. L'option ;filename= change ce que voit le serveur, utile pour des noms assainis. Le préfixe < lit le contenu d'un fichier dans un champ texte (au lieu de l'envoyer comme fichier) — pratique quand l'API attend une chaîne alors que les données sont dans un fichier.

curl
# specify MIME type explicitly
curl -F "[email protected];type=text/csv" https://api.example.com/import

# let curl guess from the extension (default)
curl -F "[email protected]" https://api.example.com/upload

# force generic type
curl -F "[email protected];type=application/octet-stream" \
     https://api.example.com/upload

# send a file with a custom filename visible to server
curl -F "upload=@/tmp/abc123;filename=report.pdf;type=application/pdf" \
     https://api.example.com/upload

# send a string as if it were a file
curl -F "file=hello world" https://api.example.com/upload

# send a string as a file with a filename
curl -F "file=<inline.txt" https://api.example.com/upload
07

Authentification

Auth basique (-u)

-u (--user) envoie une auth HTTP Basic (user:pass encodé en base64). Omettez le mot de passe pour qu'il soit demandé (plus sûr — hors de l'historique du shell). --netrc lit les identifiants depuis ~/.netrc pour qu'ils n'apparaissent jamais en ligne de commande. Basic est peu sûr sur HTTP simple ; utilisez toujours HTTPS. Toute personne ayant accès au shell voit les arguments de -u via ps.

curl
# HTTP Basic authentication
curl -u user:pass https://api.example.com/secret
curl --user user:pass https://api.example.com/secret

# prompt for password (don't put it on the command line)
curl -u user https://api.example.com/secret

# basic auth with explicit method (curl picks the safest by default)
curl -u user:pass --basic https://api.example.com/secret

# use a .netrc file instead of -u
echo "machine example.com login user password pass" > ~/.netrc
curl --netrc https://example.com/secret

# base64-encode credentials manually (equivalent)
curl -H "Authorization: Basic $(echo -n user:pass | base64)" \
     https://api.example.com/secret

Token Bearer

Les tokens Bearer (OAuth2, JWT) passent dans l'en-tête Authorization. Évitez de mettre les tokens en ligne de commande — ps les expose aux autres utilisateurs. Lisez depuis un fichier (-H @file) ou une variable d'environnement, et utilisez un fichier d'en-têtes pour les valeurs sensibles. Le snippet refresh-token montre le flux OAuth2 client-credentials standard.

curl
# Bearer token (OAuth2 / JWT)
curl -H "Authorization: Bearer ACCESS_TOKEN" \
     https://api.example.com/protected

# token from an environment variable
curl -H "Authorization: Bearer $TOKEN" \
     https://api.example.com/protected

# token from a file (avoids shell history and ps)
curl -H "Authorization: Bearer $(cat ~/.token)" \
     https://api.example.com/protected

# headers from a file (cleanest for secrets)
echo "Authorization: Bearer $TOKEN" > /tmp/hdr.txt
curl -H @/tmp/hdr.txt https://api.example.com/protected
rm /tmp/hdr.txt

# refresh token flow (simplified)
TOKEN=$(curl -s -u client:secret -d "grant_type=refresh_token" \
        -d "refresh_token=$REFRESH" \
        https://auth.example.com/token | jq -r .access_token)
curl -H "Authorization: Bearer $TOKEN" https://api.example.com/data

Clé API dans un en-tête

Les clés API apparaissent dans des en-têtes personnalisés (X-API-Key, X-Client-Id) ou en paramètres de requête. Les query strings fuient dans les logs serveur et l'historique du navigateur, préférez donc les en-têtes. Pour AWS, --aws-sigv4 signe la requête avec vos clés access/secret. GitHub utilise Bearer avec un personal access token (ghp_...).

curl
# API key in a custom header (varies by service)
curl -H "X-API-Key: abc123" https://api.example.com/data

# API key as a query parameter
curl "https://api.example.com/data?api_key=abc123"

# GitHub personal access token
curl -H "Authorization: Bearer ghp_TOKEN" \
     https://api.github.com/user

# AWS-style signature v4 (use the AWS CLI or aws-sigv4)
curl --aws-sigv4 "aws:amz:us-east-1:service" \
     -u "ACCESS:SECRET" https://service.amazonaws.com/

# multiple keys
curl -H "X-API-Key: abc123" \
     -H "X-Client-Id: my-app" \
     https://api.example.com/data

Fichiers netrc

--netrc lit les identifiants depuis ~/.netrc, qui associe des hôtes à des paires login/password. Le fichier doit être en chmod 600 ou curl refuse de l'utiliser. --netrc-file pointe vers un emplacement personnalisé. L'entrée 'default' s'applique à tout hôte sans entrée machine spécifique. C'est la façon la plus propre de garder les secrets hors de la ligne de commande.

curl
# ~/.netrc stores credentials per host
# format:
#   machine api.example.com
#   login alice
#   password secret
#   machine github.com
#   login alice
#   password ghp_TOKEN

# use netrc automatically
curl --netrc https://api.example.com/data

# use a custom netrc file
curl --netrc-file ~/.netrc.work https://api.example.com/data

# ignore netrc for this request
curl --netrc-optional -u user:pass https://api.example.com/data

# secure the file (required by curl on some systems)
chmod 600 ~/.netrc

# machine + default for any host
# default
# login anonymous
# password guest

Digest et NTLM

Basic envoie les identifiants en clair (acceptable sur HTTPS). Digest envoie un hash, jamais le mot de passe. NTLM et Negotiate gèrent le SSO Windows/Kerberos. --anyauth laisse curl choisir selon l'en-tête WWW-Authenticate du serveur. Le serveur doit prendre en charge la méthode ; -v montre les challenges émis.

curl
# digest authentication (challenge-response, more secure than Basic)
curl -u user:pass --digest https://api.example.com/secret

# NTLM (Windows auth)
curl -u user:pass --ntlm https://intranet.example.com/

# negotiate (Kerberos/SPNEGO)
curl -u user:pass --negotiate https://intranet.example.com/

# anyauth: let curl pick the method
curl -u user:pass --anyauth https://api.example.com/secret

# specify the service principal for negotiate
curl -u user:pass --negotiate --service-name HTTP/intranet.example.com \
     https://intranet.example.com/

# show which method the server requested
curl -v -u user:pass --anyauth https://api.example.com 2>&1 | grep -i www-authenticate

OAuth et tokens

OAuth2 a plusieurs types de grant : client_credentials (serveur à serveur), authorization_code (après connexion navigateur), password (hérité). L'endpoint de token renvoie un access_token (et souvent un refresh_token) ; utilisez l'access_token comme en-tête Bearer pour les requêtes suivantes. Les mots de passe d'application (GitLab, GitHub) fonctionnent avec -u et contourment les restrictions 2FA.

curl
# OAuth2 client credentials grant
curl -u client_id:client_secret \
     -d "grant_type=client_credentials" \
     -d "scope=read write" \
     https://auth.example.com/oauth/token

# OAuth2 authorization code (after browser redirect)
curl -d "grant_type=authorization_code" \
     -d "code=AUTH_CODE" \
     -d "redirect_uri=https://app.example.com/callback" \
     -u client_id:client_secret \
     https://auth.example.com/oauth/token

# OAuth2 password grant (deprecated but still seen)
curl -d "grant_type=password" \
     -d "username=user" -d "password=pass" \
     -u client_id:client_secret \
     https://auth.example.com/oauth/token

# use the access token
curl -H "Authorization: Bearer $ACCESS_TOKEN" \
     https://api.example.com/me

# basic auth with username and app password (e.g., GitLab)
curl -u "user:app_password" https://gitlab.example.com/api/v4/user
08

Cookies

Envoyer des cookies (-b)

-b (--cookie) envoie des cookies. Une chaîne est envoyée telle quelle ; un nom de fichier (format Netscape) charge des cookies enregistrés. Plusieurs cookies sont séparés par des points-virgules. -b définit aussi l'en-tête Cookie — équivalent à -H 'Cookie: ...'. Curl n'analyse pas Set-Cookie par défaut ; associez -b à -c pour conserver les nouveaux cookies.

curl
# send a single cookie
curl -b "session=abc123" https://example.com/dashboard

# send multiple cookies
curl -b "session=abc123; theme=dark; lang=en" \
     https://example.com/dashboard

# send cookies from a file (Netscape format)
curl -b cookies.txt https://example.com/dashboard

# send a cookie with attributes (path, domain)
curl -b "session=abc123; Path=/; Domain=.example.com" \
     https://example.com/

# cookie via header (manual)
curl -H "Cookie: session=abc123; theme=dark" \
     https://example.com/dashboard

Enregistrer des cookies (-c)

-c (--cookie-jar) écrit les en-têtes de réponse Set-Cookie dans un fichier au format Netscape. Associez -b (lecture) et -c (écriture) sur le même fichier pour maintenir une session entre requêtes : connectez-vous une fois, puis réutilisez le cookie jar pour les appels authentifiés. -c - décharge sur stdout pour inspection.

curl
# save response cookies to a file
curl -c cookies.txt https://example.com/login

# send and save cookies in one request
curl -b cookies.txt -c cookies.txt https://example.com/dashboard

# dump cookies to stdout (Netscape format)
curl -c - https://example.com/

# inspect cookies with --dump-header
curl -D headers.txt https://example.com/
grep -i set-cookie headers.txt

# login then reuse the session cookie
curl -c cookies.txt -d "user=alice&pass=secret" \
     https://example.com/login
curl -b cookies.txt https://example.com/dashboard

Cookie jar

Un cookie jar (format Netscape) conserve les cookies entre les invocations de curl, simulant une session de navigateur. Utilisez le même fichier de jar pour -b et -c afin que les cookies se rafraîchissent à chaque requête. Le format est séparé par des tabulations : domaine, flag sous-domaines inclus, chemin, flag secure, expiration (temps unix), nom, valeur. Supprimez le jar pour vous déconnecter.

curl
# Netscape cookie file format:
# domain  flag  path  secure  expiration  name  value
# .example.com  TRUE  /  FALSE  1735689600  session  abc123

# full session: login, then call API with the same jar
JAR=/tmp/cookies.txt
curl -s -c "$JAR" -d "user=alice&pass=secret" https://example.com/login
curl -s -b "$JAR" https://example.com/api/profile
curl -s -b "$JAR" https://example.com/api/settings

# update the jar on every request (refresh expiring cookies)
curl -b "$JAR" -c "$JAR" https://example.com/api/data

# expire all cookies by deleting the jar
rm "$JAR"

# view the jar contents
cat "$JAR"
# or human-readable
curl -b "$JAR" -c - -o /dev/null https://example.com/

Cookie depuis une chaîne

Pour des requêtes ponctuelles, -b avec une chaîne est plus simple qu'un jar. Les cookies sont séparés par des points-virgules ; les valeurs avec caractères spéciaux doivent être encodées en URL. L'en-tête Cookie (via -H) est équivalent et permet de coller verbatim la chaîne de cookies d'un navigateur — utile pour rejouer une session capturée.

curl
# one-off cookie (no file)
curl -b "session=abc123" https://example.com/

# multiple cookies in one string
curl -b "session=abc123; theme=dark; lang=en" https://example.com/

# build cookie string from variables
SID="abc123"; THEME="dark"
curl -b "session=$SID; theme=$THEME" https://example.com/

# encode a value containing special chars
curl -b "data=$(python3 -c 'import urllib.parse;print(urllib.parse.quote("a&b"))')" \
     https://example.com/

# emulate a browser cookie header exactly
curl -H "Cookie: __cfduid=abc; _ga=GA1.2.xxx; session=xyz" \
     https://example.com/

Gestion de session

Les connexions web exigent souvent un token CSRF de la page de connexion plus la persistance des cookies. Le pattern : GET du formulaire (en enregistrant les cookies), extraction du token, POST des identifiants (avec cookies + token), puis réutilisation du jar pour les appels authentifiés. Chaque requête met à jour le jar (-c) pour que les cookies de session rafraîchis se propagent. Déconnectez-vous et supprimez le jar une fois terminé.

curl
# full login flow with cookie persistence
JAR=/tmp/session.txt

# 1. GET login page (capture CSRF token + cookies)
curl -s -c "$JAR" https://example.com/login > login.html
CSRF=$(grep csrf_token login.html | head -1 | grep -oP 'value="\K[^"]+')

# 2. POST credentials with CSRF and cookies
curl -s -b "$JAR" -c "$JAR" \
     -d "user=alice&pass=secret&csrf=$CSRF" \
     https://example.com/login

# 3. Access protected resources with the session
curl -s -b "$JAR" https://example.com/dashboard
curl -s -b "$JAR" https://example.com/api/data

# 4. Logout (invalidate session)
curl -s -b "$JAR" -c "$JAR" https://example.com/logout
rm "$JAR"
09

Proxy

Proxy HTTP/HTTPS

-x (--proxy) route la requête via un proxy. Les variables d'environnement http_proxy/https_proxy/no_proxy sont honorées automatiquement. Pour des cibles HTTPS via un proxy HTTP, curl utilise CONNECT pour créer un tunnel. Définissez no_proxy pour contourner le proxy pour les hôtes internes — séparés par des virgules, un point initial signifiant les sous-domaines.

curl
# use a proxy for all requests
curl -x http://proxy.example.com:8080 https://example.com
curl --proxy http://proxy.example.com:8080 https://example.com

# HTTPS proxy (proxy connection itself is TLS)
curl -x https://proxy.example.com:8443 https://example.com

# proxy via environment variable
export https_proxy=http://proxy.example.com:8080
curl https://example.com

# proxy for a specific scheme only
curl --proxy http://proxy:8080 http://example.com
curl --proxy https://secure-proxy:8443 https://example.com

# bypass proxy for specific hosts
export no_proxy="localhost,127.0.0.1,.internal.example.com"
curl https://internal.example.com   # direct, no proxy

Proxy SOCKS

SOCKS5 est indépendant du protocole, il tunnelise donc HTTP, HTTPS et plus. --socks5-hostname fait résoudre le DNS par le proxy (utile pour atteindre des hôtes que votre machine ne peut pas résoudre). Une astuce courante : ssh -D 1080 crée un proxy SOCKS local qui tunnelise le trafic via un serveur SSH distant — idéal pour naviguer en sécurité sur des réseaux non fiables.

curl
# SOCKS5 proxy
curl -x socks5://proxy.example.com:1080 https://example.com
curl --socks5 proxy.example.com:1080 https://example.com

# SOCKS5 with local DNS resolution (server resolves)
curl --socks5-hostname proxy.example.com:1080 https://example.com

# SOCKS4 proxy
curl --socks4 proxy.example.com:1080 https://example.com

# SSH tunnel as a SOCKS proxy (run separately)
# ssh -D 1080 user@remote -N
curl -x socks5://localhost:1080 https://example.com

# SOCKS proxy with authentication
curl -x socks5://user:[email protected]:1080 https://example.com

Authentification proxy

Les proxys exigent souvent une authentification. -U (--proxy-user) fournit les identifiants ; --proxy-ntlm/--proxy-digest/--proxy-anyauth choisissent le schéma. Intégrer user:pass dans l'URL de -x est équivalent. Pour NTLM (proxys Windows d'entreprise), --proxy-ntlm gère la poignée de main multi-étapes. -U user (sans mot de passe) demande en interactif.

curl
# proxy with username/password
curl -x http://user:[email protected]:8080 https://example.com

# separate proxy auth flag
curl -x http://proxy.example.com:8080 -U user:pass https://example.com
curl --proxy-user user:pass -x http://proxy.example.com:8080 https://example.com

# prompt for proxy password
curl -U user -x http://proxy.example.com:8080 https://example.com

# NTLM-authenticated proxy
curl -U user:pass --proxy-ntlm \
     -x http://proxy.example.com:8080 https://example.com

# digest-authenticated proxy
curl -U user:pass --proxy-digest \
     -x http://proxy.example.com:8080 https://example.com

# anyauth for proxy
curl -U user:pass --proxy-anyauth \
     -x http://proxy.example.com:8080 https://example.com

No proxy et contournement

--noproxy (ou la variable d'env no_proxy) liste les hôtes qui contournent le proxy. Un point initial signifie « ce domaine et tous ses sous-domaines ». '*' contourne le proxy pour tout. Les plages CIDR fonctionnent dans les versions récentes de curl. C'est essentiel quand un proxy externe ne peut pas atteindre les hôtes internes de l'entreprise.

curl
# bypass proxy for specific hosts
curl --noproxy "localhost,127.0.0.1,.internal.com" \
     -x http://proxy:8080 https://example.com

# via environment variable
export no_proxy="localhost,127.0.0.1,.internal.com,10.0.0.0/8"
curl https://internal.com   # direct

# wildcard match for a domain and all subdomains
export no_proxy=".example.com"
curl https://api.example.com   # bypasses proxy

# disable proxy entirely for one request
curl --noproxy "*" -x http://proxy:8080 https://example.com

# ignore *_proxy env vars for one request
curl --noproxy "*" https://example.com

# CIDR ranges (curl 7.86+)
export no_proxy="192.168.0.0/16,10.0.0.0/8"

En-têtes proxy et tunnelisation

--proxy-header ajoute des en-têtes destinés au proxy lui-même (comme Proxy-Authorization), non transmis à la cible. -p (--proxytunnel) force curl à utiliser CONNECT même pour du HTTP simple (normalement CONNECT ne sert qu'au HTTPS). Utile quand le proxy intercepte le HTTP simple et que vous voulez un tunnel de bout en bout.

curl
# add a header sent only to the proxy (not the target)
curl -x http://proxy:8080 \
     --proxy-header "Proxy-Authorization: Bearer xyz" \
     https://example.com

# custom header to proxy + normal header to target
curl -x http://proxy:8080 \
     --proxy-header "X-Proxy-Tag: abc" \
     -H "X-Target-Tag: def" \
     https://example.com

# force CONNECT tunneling even for HTTP
curl -p -x http://proxy:8080 http://example.com
curl --proxytunnel -x http://proxy:8080 http://example.com

# inspect the CONNECT request to the proxy
curl -v -x http://proxy:8080 https://example.com 2>&1 | grep -i connect

# disable proxy tunneling (send HTTP directly through proxy)
curl --proxytunnel -p -x http://proxy:8080 http://example.com
10

SSL/TLS

Sauter la vérification (--insecure)

-k (--insecure) saute la vérification du certificat — uniquement pour des certs auto-signées de dev, jamais en production, car cela permet des attaques MITM. Par défaut, curl vérifie la chaîne de certificats et le nom d'hôte. --resolve permet d'épingler une IP en gardant le bon Host/SNI — pratique pour tester un backend précis derrière un load balancer.

curl
# skip certificate verification (DANGEROUS)
curl -k https://self-signed.example.com
curl --insecure https://self-signed.example.com

# verify normally (default)
curl https://example.com

# show the cert chain
curl -v https://example.com 2>&1 | grep -E "SSL|cert"

# only verify the cert, not the hostname
curl --insecure https://example.com   # both off
# (no built-in flag to verify cert but skip hostname;
#  use a custom CA bundle instead)

# connect to a host with a mismatched certificate
curl -k --resolve example.com:443:1.2.3.4 https://example.com

# debug TLS handshake
curl -v https://example.com 2>&1 | grep -E "TLS|SSL|cert|cipher"

Certificats clients

Le TLS mutuel (mTLS) exige un certificat client (--cert) et sa clé privée (--key). PEM par défaut ; --cert-type P12 gère les bundles PKCS#12. --pass fournit le mot de passe de la clé. --cacert remplace la liste des CA de confiance (défaut : magasin système) — pratique pour les CA internes. Le mTLS est courant en zero-trust et service mesh.

curl
# client certificate + private key (mTLS)
curl --cert client.pem --key client.key \
     https://mtls.example.com/api

# PKCS#12 bundle (combined cert + key)
curl --cert client.p12 --cert-type P12 \
     https://mtls.example.com/api

# password-protected key
curl --cert client.pem --key client.key \
     --pass secret https://mtls.example.com/api

# PEM cert with password
curl --cert client.pem:secret https://mtls.example.com/api

# specify CA bundle to verify the server
curl --cacert custom-ca.pem https://internal.example.com

# mutual TLS with custom CA
curl --cert client.pem --key client.key \
     --cacert internal-ca.pem \
     https://mtls.internal.example.com

Version TLS

--tlsv1.X fixe la version minimale ; --tls-max la plafonne. Forcer 1.2+ désactive les protocoles hérités (SSLv3, TLS 1.0/1.1) aux faiblesses connues. Par défaut, la version mutuellement la plus récente est négociée. -v révèle la version négociée et le cipher sur la ligne 'SSL connection using'.

curl
# force a minimum TLS version
curl --tlsv1.2 https://example.com
curl --tlsv1.3 https://example.com

# force an exact TLS version
curl --tls-max 1.2 https://example.com   # cap at 1.2
curl --tls-max 1.3 https://example.com

# negotiate the highest version both support (default)
curl https://example.com

# disable specific versions
curl --tlsv1.2 --tls-max 1.2 https://example.com   # only 1.2

# list versions curl supports
curl --version | grep -i tls

# debug which version was negotiated
curl -v https://example.com 2>&1 | grep -i "SSL connection"

Ciphers et bundle CA

--ciphers restreint la suite de ciphers (syntaxe OpenSSL). --cacert pointe vers un bundle CA personnalisé pour vérifier les serveurs avec des CA internes/privées — le bundle système (/etc/ssl/certs ou trousseau macOS) est utilisé par défaut. Si le bundle CA est périmé, des serveurs avec des certs valides peuvent être rejetés ; mettre à jour curl (ou le paquet ca-certificates) corrige cela.

curl
# specify allowed ciphers
curl --ciphers "AES256-GCM-SHA384:AES128-GCM-SHA256" \
     https://example.com

# use a custom CA bundle to verify the server
curl --cacert /etc/ssl/certs/internal-ca.pem \
     https://internal.example.com

# use the system CA store (default)
curl https://example.com

# use Mozilla's CA bundle (download separately)
curl --cacert cacert.pem https://example.com

# show the cipher used
curl -v https://example.com 2>&1 | grep -i cipher

# disable certificate revocation checks (CRL/OCSP)
curl --cacert ca.pem --no-clobber https://example.com

Inspection de certificats

Utilisez -v pour inspecter le certificat du serveur (sujet, émetteur, dates de validité). --pinnedpubkey impose l'épinglage de clé — la requête échoue si la clé publique du serveur ne correspond pas, neutralisant les CA voyous. Pour un débogage TLS approfondi, --trace-ascii décharge toute la poignée de main. openssl s_client est une alternative plus puissante pour inspecter les certs.

curl
# show the server certificate in verbose mode
curl -v https://example.com 2>&1 | grep -A1 "server certificate"

# extract certificate details (subject, issuer, dates)
curl -v https://example.com 2>&1 | grep -E "subject|issuer|start date|expire date"

# download the server certificate (PEM)
curl -v https://example.com 2>&1 | \
  awk '/-----BEGIN CERT/,/-----END CERT/' > server.pem

# verify cert only, don't transfer body
curl -I https://example.com

# pin a specific certificate (fingerprint)
curl --pinnedpubkey sha256//BASE64= https://example.com

# check OCSP stapling
curl -v https://example.com 2>&1 | grep -i ocsp

# show full TLS trace
curl --trace-ascii - https://example.com | grep -i cert
11

Téléchargement

Enregistrer dans un fichier (-o/-O)

-o écrit vers un nom de fichier choisi ; -O utilise le nom distant (basename de l'URL). --output-dir définit le dossier de destination pour -O. Plusieurs flags -O téléchargent plusieurs fichiers en une invocation. -o /dev/null jette le corps — utile pour déclencher des webhooks ou mesurer des timings sans enregistrer les données.

curl
# save with a custom name
curl -o page.html https://example.com/index.html

# save with the remote filename
curl -O https://example.com/file.zip

# save to a specific directory
curl -O --output-dir /tmp/downloads https://example.com/file.zip

# save with remote name to a specific dir
curl -o /tmp/file.zip https://example.com/file.zip

# download multiple files with remote names
curl -O https://example.com/a.zip -O https://example.com/b.zip

# save to /dev/null (just trigger the request)
curl -o /dev/null https://example.com/webhook

Reprendre les téléchargements (-C)

-C - (--continue-at -) reprend un téléchargement là où il s'était arrêté, en utilisant la taille du fichier existant comme offset en octets. Le serveur doit prendre en charge les requêtes Range (vérifiez Accept-Ranges: bytes). Combinez avec --retry pour gérer les connexions instables — curl réessaie et reprend, évitant le gaspillage de bande passante.

curl
# resume a partial download
curl -C - -o file.zip https://example.com/file.zip
curl --continue-at - -o file.zip https://example.com/file.zip

# resume with -O (remote name)
curl -C - -O https://example.com/file.zip

# start download at a specific byte offset
curl -C 1024 -o file.zip https://example.com/file.zip

# server must support Range requests
curl -I https://example.com/file.zip | grep -i accept-ranges

# resume an interrupted large download
curl -C - --progress-bar -O https://example.com/bigfile.iso

# combine with retry for unreliable connections
curl -C - --retry 5 --retry-all-errors -O \
     https://example.com/bigfile.iso

Barre de progression

--progress-bar affiche une barre ### plus simple au lieu de la jauge par défaut. -s silencie toute progression ; -sS conserve les erreurs. La progression va sur stderr, donc elle ne pollue pas le corps sur stdout — vous pouvez capturer les deux séparément. -w avec %{size_download} et %{time_total} donne un résumé d'une ligne propre pour les scripts.

curl
# default progress meter
curl -O https://example.com/file.zip

# simple progress bar (alternative style)
curl --progress-bar -O https://example.com/file.zip

# silent (no progress, no body output)
curl -s -O https://example.com/file.zip

# silent but still show errors
curl -sS -O https://example.com/file.zip

# show only errors (no progress, body to file)
curl -sS -o file.zip https://example.com/file.zip

# custom one-line progress
curl -o file.zip -w "%{size_download} bytes in %{time_total}s\n" \
     https://example.com/file.zip

# redirect progress to a file, body to another
curl -o file.zip --progress-bar 2> progress.log \
     https://example.com/file.zip

Plage de téléchargement

-r (--range) demande une plage d'octets, avec réponse 206 Partial Content. Utile pour prévisualiser de gros fichiers, reprendre, ou télécharger en parallèle multi-connexions. Le serveur doit annoncer Accept-Ranges: bytes. Combinez avec l'arrière-plan shell (&) pour télécharger des plages en parallèle, puis concaténez — c'est la base des accélérateurs de téléchargement comme aria2.

curl
# download bytes 0-1023 (first 1KB)
curl -r 0-1023 -o part1.bin https://example.com/file.zip

# download from byte 1024 to end
curl -r 1024- -o rest.bin https://example.com/file.zip

# download last 500 bytes
curl -r -500 -o tail.bin https://example.com/file.zip

# check if server supports ranges
curl -I https://example.com/file.zip | grep -i accept-ranges
# Accept-Ranges: bytes  -> supported

# parallel range download (split a large file)
curl -r 0-49999999    -o part1.bin https://example.com/big.iso &
curl -r 50000000-99999999 -o part2.bin https://example.com/big.iso &
wait
cat part1.bin part2.bin > big.iso

# HTTP/1.1 206 Partial Content confirms success
curl -r 0-100 -v https://example.com/file.zip 2>&1 | grep HTTP

Plusieurs fichiers et globbing

Le globbing d'URL ([1-3], {a,b,c}) émet une requête par développement. --output-dir définit où -O les enregistre. Pour un vrai parallélisme (curl lui-même est séquentiel), pipez les URLs vers xargs -P N pour lancer N curls en parallèle. Cela accélère fortement le téléchargement de nombreux petits fichiers du même hôte (respectez les limites de débit du serveur).

curl
# download file1.zip, file2.zip, file3.zip
curl -O https://example.com/file[1-3].zip

# download with a step (1, 3, 5, 7, 9)
curl -O https://example.com/file[1-9:2].zip

# download from multiple paths
curl -O https://example.com/{a,b,c}.zip

# download to a specific directory
curl -O --output-dir /tmp/downloads \
     https://example.com/file[1-3].zip

# sequential download (one at a time)
for url in https://example.com/{a,b,c}.zip; do
  curl -O "$url"
done

# parallel download with xargs
echo "https://example.com/{a,b,c}.zip" | tr ' ' '\n' | \
  xargs -n1 -P3 curl -O

Miroir et récursion

Curl est mono-URL par conception — il ne récuse pas. Pour mettre un site en miroir, utilisez wget --mirror ou scriptez l'extraction de liens avec grep. Pour des téléchargements en lot, listez les URLs dans un fichier et alimentez xargs -P N pour le parallélisme. L'exemple sitemap récupère et télécharge chaque page indexée d'un site — pratique pour des instantanés hors ligne.

curl
# curl doesn't recurse like wget, but you can script it
# download a page and extract its links
curl -s https://example.com/ | \
  grep -oP 'href="\K[^"]+' | grep '^http' > urls.txt

# download all linked PDFs
curl -s https://example.com/docs | \
  grep -oP 'href="\K[^"]+\.pdf' | \
  while read pdf; do curl -O "https://example.com/$pdf"; done

# use wget instead for true mirroring
# wget --mirror --convert-links --page-requisites https://example.com/

# download a list of URLs from a file
xargs -n1 -P4 curl -O < urls.txt

# fetch a sitemap and download every URL
curl -s https://example.com/sitemap.xml | \
  grep -oP '<loc>\K[^<]+' | xargs -n1 -P4 curl -O
12

Délais d'attente et tentatives

Délai de connexion

--connect-timeout plafonne le temps d'établissement de la connexion TCP/TLS (mais pas le transfert). Sans lui, curl peut rester bloqué des minutes sur des hôtes injoignables (défaut OS ~2 minutes). Dans les scripts, fixez toujours --connect-timeout (échouer vite sur les hôtes morts) et --max-time (plafonner toute l'opération) pour éviter les blocages.

curl
# max time to establish the connection (seconds)
curl --connect-timeout 10 https://example.com

# connect timeout in milliseconds (curl 7.32+)
curl --connect-timeout 2.5 https://example.com

# connect timeout + overall max time
curl --connect-timeout 10 --max-time 30 https://example.com

# DNS resolution timeout (curl 7.88+, otherwise OS-controlled)
curl --happy-eyeballs-timeout-ms 1000 https://example.com

# fail fast on unreachable hosts
curl --connect-timeout 3 -sS https://example.com || echo "unreachable"

# combine with --retry for resilience
curl --connect-timeout 5 --max-time 20 --retry 3 \
     https://example.com

Temps maximum

--max-time (-m) plafonne toute l'opération (DNS + connexion + transfert). --speed-time/--speed-limit abandonnent si le transfert passe sous un débit donné pendant une durée — parfait pour les téléchargements bloqués. Le code de sortie 28 signifie timeout ; vérifiez $? dans les scripts. Fixez toujours un max-time pour éviter les blocages infinis sur des serveurs lents ou plantés.

curl
# overall timeout for the whole operation
curl --max-time 30 https://example.com
curl -m 30 https://example.com

# max time in milliseconds (decimal)
curl --max-time 2.5 https://example.com

# max time with no data transfer (idle timeout)
curl --speed-time 30 --speed-limit 1000 https://example.com
# abort if speed < 1000 bytes/sec for 30 sec

# max time for a file upload
curl -T big.iso --max-time 600 https://example.com/upload

# max time per redirect hop
curl -L --max-time 60 https://example.com/redirect

# check exit code (28 = timed out)
curl --max-time 5 https://slow.example.com || echo "exit code: $?"

Tentatives de reprise

--retry réessaie sur les erreurs transitoires (timeouts, 5xx, 429) par défaut ; --retry-all-errors étend à toutes les erreurs. --retry-delay ajoute une attente fixe (doublée à chaque tentative) entre les essais. --retry-connrefused réessaie même si la connexion est refusée (ex. serveur en redémarrage). Associez à -C - pour reprendre les téléchargements partiels. Essentiel pour des scripts résilients.

curl
# retry up to 3 times on transient errors
curl --retry 3 https://example.com

# retry on any error (not just transient)
curl --retry 3 --retry-all-errors https://example.com

# retry with exponential backoff
curl --retry 5 --retry-delay 2 https://example.com
# waits 2s, 4s, 6s, 8s, 10s between retries (curl 7.66+)

# retry on connection-refused specifically
curl --retry 3 --retry-connrefused https://example.com

# retry only on HTTP 5xx and 429
curl --retry 3 --retry-all-errors \
     -H "Accept: application/json" https://api.example.com

# combine with resume for large downloads
curl --retry 5 --retry-all-errors -C - -O \
     https://example.com/bigfile.iso

Délai de reprise et backoff

--retry-delay N attend N secondes avant la première reprise, puis double (N, 2N, 4N...). Curl honore l'en-tête Retry-After du serveur pour les réponses 429/503. Pour une logique personnalisée (jitter, attente totale max, condition sur le code de statut), enveloppez curl dans une boucle shell. Associez toujours --retry à --max-time pour que les reprises ne durent pas indéfiniment.

curl
# fixed delay between retries
curl --retry 5 --retry-delay 2 https://example.com

# exponential backoff (curl doubles the delay each time)
curl --retry 5 --retry-delay 1 https://example.com
# waits: 1s, 2s, 4s, 8s, 16s

# honor Retry-After header (default with --retry)
curl --retry 3 https://example.com

# cap retry delay with a max-time
curl --retry 10 --retry-delay 1 --max-time 60 https://example.com

# custom backoff in a shell loop
for i in 1 2 3 4 5; do
  curl -s --max-time 10 https://example.com && break
  echo "attempt $i failed, waiting $((i*2))s..."
  sleep $((i*2))
done

# retry on specific HTTP status codes
curl --retry 5 --retry-all-errors \
     -w "%{http_code}" -o /dev/null -s https://example.com

Limites de débit

--speed-time/--speed-limit abandonne un transfert bloqué (pas de données pendant N secondes à un débit sous la limite) — code de sortie 28. --limit-rate plafonne le débit (suffixes K/M/G acceptés), utile pour ne pas saturer la bande passante ou pour simuler un réseau lent. Combinez avec --retry pour reprendre automatiquement les téléchargements interrompus.

curl
# abort if speed drops below 1000 bytes/sec for 30 sec
curl --speed-limit 1000 --speed-time 30 -O \
     https://example.com/bigfile.iso

# shorthand: --speed-time defaults to 30 if only --speed-limit is set
curl --speed-limit 1000 -O https://example.com/bigfile.iso

# limit max download rate (bytes/sec)
curl --limit-rate 100k -O https://example.com/file.zip

# limit rate with units (K, M, G)
curl --limit-rate 1M -O https://example.com/file.zip

# limit upload rate
curl -T big.iso --limit-rate 500k https://example.com/upload

# combine with retry on stall
curl --speed-limit 1000 --speed-time 30 \
     --retry 5 --retry-all-errors \
     -O https://example.com/bigfile.iso
13

Débogage

Mode verbeux (-v)

-v (verbose) est l'outil de débogage principal. Les lignes '>' sont la requête, '<' la réponse, '*' les détails internes de curl (DNS, TLS, connexion) — tout sur stderr, stdout reste donc propre pour le corps. Redirigez 2>&1 pour filtrer avec grep. Utilisez -o /dev/null pour inspecter les en-têtes sans enregistrer le corps.

curl
# verbose: full request + response + curl internals
curl -v https://example.com

# output goes to stderr; body to stdout
curl -v https://example.com > body.txt 2> debug.log

# only show request headers (> lines)
curl -v https://example.com 2>&1 | grep '^>'

# only show response headers (< lines)
curl -v https://example.com 2>&1 | grep '^<'

# only show curl info (* lines)
curl -v https://example.com 2>&1 | grep '^\*'

# verbose without sending the body
curl -v -o /dev/null https://example.com

Trace

--trace décharge tout (corps inclus) en hexa + ASCII ; --trace-ascii omets l'hexa. --trace-time ajoute des horodatages. Contrairement à -v, trace montre les corps de requête et de réponse, c'est donc l'outil pour déboguer des données binaires ou compressées. Attention : --trace journalise les secrets (mots de passe, tokens) — nettoyez avant de partager.

curl
# trace: dump all sent and received data (hex + ASCII)
curl --trace - https://example.com

# trace ASCII only (no hex dump)
curl --trace-ascii - https://example.com

# trace to a file
curl --trace trace.log https://example.com

# trace including time per packet
curl --trace-ascii - --trace-time https://example.com

# trace with request body (hidden by default in -v)
curl --trace-ascii - -d "secret=data" https://example.com

# compare verbose vs trace
curl -v https://example.com 2>&1 | head
curl --trace-ascii - https://example.com | head

En-têtes seuls

-I envoie une requête HEAD (la plupart des serveurs renvoient les mêmes en-têtes que GET sans le corps). -D décharge les en-têtes dans un fichier ou '-' (stdout). Pour voir ce que curl a envoyé (en-têtes de requête), utilisez -v et grep '^>'. Pour le seul code de statut, -w '%{http_code}' est le plus propre. Note : certains serveurs répondent différemment à HEAD et à GET.

curl
# HEAD request: response headers only
curl -I https://example.com
curl --head https://example.com

# dump response headers to stdout, discard body
curl -D - -o /dev/null https://example.com

# dump response headers to a file
curl -D headers.txt -o body.html https://example.com

# show request headers (what curl sent)
curl -v -o /dev/null https://example.com 2>&1 | grep '^>'

# show both request and response headers
curl -v -o /dev/null https://example.com 2>&1 | grep -E '^[<>]'

# show only the status line
curl -s -o /dev/null -w "%{http_code} %{http_version}\n" \
     https://example.com
curl -D - -o /dev/null -s https://example.com | head -1

Séparation requête/réponse

La sortie verbeuse va sur stderr, le corps sur stdout, ils peuvent donc être capturés séparément par redirection. -D enregistre les en-têtes de réponse ; -o le corps ; -v (stderr) la conversation complète. Cette séparation est essentielle pour déboguer les API : inspectez en-têtes et corps indépendamment, journalisez les timings, comparez requête et réponse.

curl
# capture request and response separately
curl -v https://example.com \
     -o body.txt \
     1> /dev/null 2> verbose.log

# extract request only
curl -v https://example.com 2>&1 1>/dev/null | grep '^>' > request.txt

# extract response only
curl -v https://example.com 2>&1 1>/dev/null | grep '^<' > response.txt

# split headers and body cleanly
curl -s -D headers.txt -o body.txt https://example.com

# capture everything: body, headers, request, timing
curl -s -D headers.txt -o body.txt \
     -w "@curl-format.txt" https://example.com >> timing.log

# show body to terminal, headers to file
curl -D headers.txt https://example.com

Options de débogage

--dry-run affiche ce que curl ferait sans envoyer — parfait pour vérifier le globbing d'URL et la config. --resolve épingle un hôte à une IP, en contournant le DNS (essentiel pour tester un backend précis). --interface se lie à une carte réseau ou une IP. --no-keepalive force une connexion neuve par requête, utile pour reproduire des bugs au niveau connexion.

curl
# show what curl would do without sending
curl --dry-run https://example.com

# dump parsed config files
curl --config /dev/null -v https://example.com 2>&1 | grep -i config

# force a fresh connection (no keep-alive reuse)
curl --no-keepalive https://example.com

# disable DNS cache
curl --doh-url https://dns.example.com/dns-query https://example.com

# use a specific network interface
curl --interface eth0 https://example.com
curl --interface 192.168.1.5 https://example.com

# resolve a hostname to a specific IP (no DNS)
curl --resolve example.com:443:1.2.3.4 https://example.com

# debug globbing (list URLs without fetching)
curl --dry-run -O https://example.com/file[1-3].zip
14

Infos de réponse

Code de statut HTTP

-w '%{http_code}' extrait juste le code de statut pour les scripts. -f (--fail) fait sortir curl avec un code non nul sur 4xx/5xx (sans lui, curl renvoie 0 même pour un 404). --fail-with-body affiche aussi le corps de réponse en cas d'erreur (plus utile pour déboguer). Branchez sur le code de statut dans les scripts : 2xx succès, 3xx redirection, 4xx erreur client, 5xx erreur serveur.

curl
# get only the status code
curl -s -o /dev/null -w "%{http_code}" https://example.com
echo   # 200

# status code with newline
curl -s -o /dev/null -w "%{http_code}\n" https://example.com

# full status line
curl -s -o /dev/null -w "%{http_version} %{http_code}\n" https://example.com

# branch on status code
CODE=$(curl -s -o /dev/null -w "%{http_code}" https://example.com)
if [ "$CODE" = "200" ]; then echo "ok"; else echo "fail: $CODE"; fi

# fail on HTTP errors (4xx, 5xx)
curl -f https://example.com || echo "HTTP error"
curl --fail-with-body https://example.com   # 7.76+: still print body

# check redirect chain status codes
curl -L -w "%{num_redirects} redirects, final %{http_code}\n" \
     -o /dev/null -s https://short.url/abc

Format write-out

-w (--write-out) formate les infos du transfert via des placeholders %{variable}. Les timings (time_namelookup, time_connect, time_appconnect, time_total) décomposent où passe le temps — essentiel pour l'analyse de performance. %{json} sort toutes les variables en JSON (curl 7.70+). Stockez un format dans un fichier et utilisez -w @file pour le réutiliser.

curl
# built-in variables with -w / --write-out
curl -s -o /dev/null -w "HTTP %{http_code} in %{time_total}s\n" \
     https://example.com

# URL info
curl -s -o /dev/null -w "URL: %{url_effective}\nIP: %{remote_ip}\n" \
     https://example.com

# timing breakdown
curl -s -o /dev/null \
     -w "dns=%{time_namelookup} connect=%{time_connect} tls=%{time_appconnect} total=%{time_total}\n" \
     https://example.com

# size info
curl -s -o /dev/null \
     -w "downloaded=%{size_download} uploaded=%{size_upload}\n" \
     https://example.com

# write format from a file
cat > fmt.txt <<EOF
http_code: %{http_code}
time_total: %{time_total}s
EOF
curl -s -o /dev/null -w "@fmt.txt" https://example.com

# JSON output (curl 7.70+)
curl -s -o /dev/null -w "%{json}" https://example.com

Temps de réponse

Les variables de timing décomposent la requête : time_namelookup (DNS), time_connect (TCP), time_appconnect (TLS), time_starttransfer (TTFB — premier octet reçu), time_total (transfert entier). Le TTFB est la métrique clé de latence API. Comparez les timings entre endpoints pour identifier les goulots (DNS, réseau, TLS ou traitement serveur).

curl
# total time
curl -s -o /dev/null -w "%{time_total}\n" https://example.com

# DNS resolution time
curl -s -o /dev/null -w "%{time_namelookup}\n" https://example.com

# TCP connect time
curl -s -o /dev/null -w "%{time_connect}\n" https://example.com

# TLS handshake time (after connect)
curl -s -o /dev/null -w "%{time_appconnect}\n" https://example.com

# time to first byte (TTFB)
curl -s -o /dev/null -w "%{time_starttransfer}\n" https://example.com

# full timing breakdown
curl -s -o /dev/null -w \
  "dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}\n" \
  https://example.com

# compare two endpoints
curl -s -o /dev/null -w "%{time_total}\n" https://api1.example.com
curl -s -o /dev/null -w "%{time_total}\n" https://api2.example.com

Extraire les en-têtes

-D - décharge les en-têtes de réponse sur stdout ; pipez dans grep pour extraire un en-tête précis. -I (HEAD) fonctionne aussi mais peut différer de GET. -w fournit %{url_effective} (URL finale après redirections), %{remote_ip} (IP du serveur) et %{num_redirects}. Inestimables pour déboguer le routage CDN, les redirections et l'identification du serveur.

curl
# dump all response headers to stdout, discard body
curl -s -D - -o /dev/null https://example.com

# extract one header (Content-Type)
curl -s -D - -o /dev/null https://example.com | \
  grep -i "^content-type:"

# extract Content-Length (size)
curl -s -I https://example.com/file.zip | grep -i content-length

# extract Set-Cookie
curl -s -D - -o /dev/null https://example.com | grep -i set-cookie

# extract the final URL after redirects
curl -s -L -o /dev/null -w "%{url_effective}\n" https://short.url/abc

# extract the server's IP address
curl -s -o /dev/null -w "%{remote_ip}\n" https://example.com

# count redirects
curl -s -L -o /dev/null -w "%{num_redirects}\n" https://short.url/abc

Variables de format

-w (--write-out) accepte des dizaines de variables (lancez 'curl -w "%{json}"' pour toutes les voir en JSON). Les variables de timing sont le fondement de la supervision de performance ; celles de taille suivent la bande passante ; url_effective et num_redirects déboguent le routage. %{json} (curl 7.70+) est le moyen le plus simple de tout capturer pour les logs ou les dashboards.

curl
# complete list of common -w variables
# %{http_code}        - response status code
# %{http_version}     - HTTP version (1.1, 2, 3)
# %{url_effective}    - final URL after redirects
# %{remote_ip}        - server IP address
# %{remote_port}      - server port
# %{time_namelookup}  - DNS resolution time
# %{time_connect}     - TCP connect time
# %{time_appconnect}  - TLS handshake time
# %{time_pretransfer} - time before transfer starts
# %{time_starttransfer} - TTFB (first byte)
# %{time_total}       - total time
# %{size_download}    - bytes downloaded
# %{size_upload}      - bytes uploaded
# %{size_header}      - header bytes
# %{size_request}     - request bytes
# %{num_redirects}    - number of redirects
# %{ssl_verify_result}- SSL verification result
# %{content_type}     - response content type
# %{json}             - all variables as JSON (7.70+)

# reference: curl -w "%{json}" https://example.com
curl -s -o /dev/null -w "%{json}" https://example.com | jq
15

FTP et SMTP

Bases du FTP

curl prend en charge le FTP pour les téléchargements (GET) comme les uploads (PUT via -T). -u fournit les identifiants ; le FTP anonyme utilise 'anonymous' + un email. FTPS (--ftp-ssl) chiffre le canal de contrôle. Le mode passif (défaut) passe les NAT/pare-feu ; utilisez --ftp-port pour le mode actif si le serveur l'exige.

curl
# anonymous FTP download
curl ftp://ftp.example.com/file.txt

# authenticated FTP
curl -u user:pass ftp://ftp.example.com/file.txt

# list a directory
curl ftp://ftp.example.com/directory/

# download a file
curl -O ftp://ftp.example.com/file.txt

# upload a file (PUT)
curl -T local.txt ftp://ftp.example.com/remote.txt -u user:pass

# use explicit FTPS (FTP over TLS)
curl --ftp-ssl ftp://ftp.example.com/file.txt -u user:pass

# passive mode (default; needed behind NAT/firewalls)
curl --ftp-pasv ftp://ftp.example.com/ -u user:pass

Upload FTP

-T envoie un fichier via la commande STOR du FTP. --ftp-create-dirs crée les répertoires parents avec MKD. --append utilise APPE pour ajouter à un fichier existant. -C - reprend un upload interrompu. Le globbing ({a,b}) envoie plusieurs fichiers en une invocation. Pour les répertoires, tardez-les d'abord — le FTP ne peut pas envoyer de dossiers directement.

curl
# upload a single file
curl -T local.txt ftp://ftp.example.com/remote.txt -u user:pass

# upload with explicit filename
curl -T local.txt -o remote.txt ftp://ftp.example.com/ -u user:pass

# upload to a directory
curl -T local.txt ftp://ftp.example.com/uploads/ -u user:pass

# create a directory (MKD command)
curl --ftp-create-dirs -T local.txt \
     ftp://ftp.example.com/newdir/file.txt -u user:pass

# append to a remote file
curl -T local.txt --append ftp://ftp.example.com/remote.txt -u user:pass

# upload multiple files with globbing
curl -T "{file1,file2}.txt" ftp://ftp.example.com/ -u user:pass

# resume an interrupted upload
curl -C - -T bigfile.iso ftp://ftp.example.com/bigfile.iso -u user:pass

Listage FTP

Une URL FTP terminée par / liste le répertoire. --list-only renvoie juste les noms de fichiers. -v montre les commandes FTP sous-jacentes (USER, PASS, PASV, LIST, RETR) — inestimable pour déboguer des problèmes de permissions ou de pare-feu. Curl ne récuse pas dans les sous-répertoires ; utilisez wget --mirror ou un script pour des téléchargements FTP récursifs.

curl
# list a directory (default format)
curl ftp://ftp.example.com/ -u user:pass

# list with --list-only (names only, no details)
curl --list-only ftp://ftp.example.com/ -u user:pass

# list a specific directory
curl ftp://ftp.example.com/pub/ -u user:pass

# recursive listing (curl doesn't recurse natively)
# use --ftp-method to control PASV/EPSV behavior
curl --ftp-method nocwd ftp://ftp.example.com/ -u user:pass

# download all files in a directory (with globbing)
curl -O ftp://ftp.example.com/pub/*.txt -u user:pass

# show server responses (FTP commands)
curl -v ftp://ftp.example.com/ -u user:pass 2>&1 | grep -E "^\*|^[<>]"

Envoyer un email via SMTP

curl peut envoyer des emails via SMTP. Le corps (avec les en-têtes) est dans un fichier pipé via -T. --mail-from et --mail-rcpt définissent l'enveloppe (distincte des en-têtes To/From du corps). --ssl-reqd force STARTTLS (port 587) ; smtps:// utilise le TLS implicite (port 465). Auth via -u (LOGIN/PLAIN). Idéal pour des alertes scriptées depuis des serveurs sans client mail.

curl
# send email via SMTP
curl --url "smtp://smtp.example.com:587" \
     --mail-from "[email protected]" \
     --mail-rcpt "[email protected]" \
     -u "[email protected]:password" \
     -T email.txt

# email body from a file
cat > email.txt <<EOF
From: [email protected]
To: [email protected]
Subject: Test from curl

Hello from curl!
EOF
curl --url "smtp://smtp.example.com:587" \
     --mail-from "[email protected]" \
     --mail-rcpt "[email protected]" \
     -u "[email protected]:password" \
     --ssl-reqd \
     -T email.txt

# multiple recipients
curl --url "smtp://smtp.example.com:587" \
     --mail-from "[email protected]" \
     --mail-rcpt "[email protected]" \
     --mail-rcpt "[email protected]" \
     -T email.txt

# STARTTLS (port 587)
curl --ssl-reqd --url "smtp://smtp.example.com:587" \
     --mail-from "[email protected]" --mail-rcpt "[email protected]" \
     -T email.txt

# SMTPS (implicit TLS, port 465)
curl --url "smtps://smtp.example.com:465" \
     --mail-from "[email protected]" --mail-rcpt "[email protected]" \
     -T email.txt

IMAP et POP3

curl peut lire le courrier via IMAP et POP3. La syntaxe d'URL inclut les sélecteurs de dossier, d'UID et de section. IMAP gère la recherche (?UNSEEN, ?SUBJECT, etc.). imaps:// et pop3s:// utilisent le TLS implicite. Note : curl est en lecture seule pour le courrier — il peut récupérer mais pas envoyer via IMAP/POP3 (passez par SMTP). Le corps est renvoyé en texte de message brut RFC 822.

curl
# list IMAP mailboxes
curl -u "user:pass" --url "imap://imap.example.com:143"

# list messages in INBOX
curl -u "user:pass" --url "imap://imap.example.com/INBOX"

# fetch a specific message (UID 1)
curl -u "user:pass" --url "imap://imap.example.com/INBOX;UID=1"

# fetch message headers only
curl -u "user:pass" --url "imap://imap.example.com/INBOX;UID=1;SECTION=HEADER"

# search for unread messages
curl -u "user:pass" --url "imap://imap.example.com/INBOX?UNSEEN"

# POP3: list messages
curl -u "user:pass" --url "pop3://pop.example.com/"

# POP3: retrieve message #1
curl -u "user:pass" --url "pop3://pop.example.com/1"

# use IMAPS (implicit TLS, port 993)
curl -u "user:pass" --url "imaps://imap.example.com/INBOX"

FTPS et SFTP

Le FTP a trois variantes chiffrées : FTPS explicite (--ftp-ssl, mise à niveau sur le port 21), FTPS implicite (ftps://, TLS dès le début sur le port 990), et SFTP (sftp://, protocole totalement différent par SSH sur le port 22). Le SFTP gère l'auth par clé via --key (avec --pass pour les clés chiffrées). Le SFTP est aujourd'hui généralement préféré au FTPS pour sa simplicité et sa compatibilité pare-feu.

curl
# FTPS: explicit TLS (upgrade to TLS on plain FTP port)
curl --ftp-ssl --ssl-reqd ftp://ftp.example.com/ -u user:pass

# FTPS: implicit TLS (TLS from the start, port 990)
curl ftps://ftp.example.com:990/ -u user:pass

# SFTP (SSH File Transfer Protocol, port 22)
curl -u user sftp://sftp.example.com/file.txt

# SFTP with key authentication
curl -u user --key ~/.ssh/id_rsa \
     sftp://sftp.example.com/file.txt

# SFTP with a password-protected key
curl -u user --key ~/.ssh/id_rsa --pass passphrase \
     sftp://sftp.example.com/file.txt

# SFTP upload
curl -u user -T local.txt sftp://sftp.example.com/remote.txt

# SFTP list directory
curl -u user sftp://sftp.example.com/
16

Parallèle et lot

Téléchargements parallèles

Curl est séquentiel par lui-même — pour télécharger en parallèle, lancez plusieurs curls via & et wait, ou utilisez xargs -P N pour en exécuter N à la fois. Cela accélère fortement de nombreux petits fichiers. Soyez raisonnable : trop de connexions parallèles peuvent saturer le serveur ou déclencher une limitation. 4-8 en parallèle est un défaut raisonnable.

curl
# background multiple curls (shell parallelism)
curl -O https://example.com/a.zip &
curl -O https://example.com/b.zip &
curl -O https://example.com/c.zip &
wait

# parallel with xargs (4 concurrent)
echo -e "https://example.com/a.zip\nhttps://example.com/b.zip" | \
  xargs -n1 -P4 curl -O

# parallel with a URL list file
xargs -n1 -P4 curl -O < urls.txt

# zsh-specific parallel with {..}
for url in https://example.com/{a,b,c}.zip; do
  curl -O "$url" &
done; wait

# bash-specific using arrays and &
urls=("https://example.com/a.zip" "https://example.com/b.zip")
for url in "${urls[@]}"; do curl -O "$url" & done; wait

Parallèle avec xargs

xargs -P N exécute N processus en parallèle, en alimentant chaque ligne de stdin comme argument. -a lit depuis un fichier. -I {} permet de placer l'URL n'importe où dans une commande. C'est le moyen le plus simple de paralléliser les téléchargements curl sans outil supplémentaire. Pour une limitation consciente de l'hôte ou une logique de reprise complexe, utilisez un gestionnaire de téléchargement dédié comme aria2c.

curl
# download each URL from a file, 4 concurrent
xargs -n1 -P4 -a urls.txt curl -O

# download with custom names, parallel
cat urls.txt | xargs -n2 -P4 sh -c 'curl -o "$0" "$1"'

# download and process each response
cat urls.txt | xargs -n1 -P4 -I {} sh -c \
  'curl -s {} | jq .field'

# retry failures in parallel
xargs -n1 -P4 -a urls.txt curl --retry 3 -O

# limit total concurrent connections to a host
# (xargs doesn't know about hosts; use a queue or a download manager)
xargs -n1 -P4 -a urls.txt curl -O --limit-rate 1M

# show progress for parallel downloads
xargs -n1 -P4 -a urls.txt curl -O --progress-bar 2>&1

Globbing d'URL

Le globbing développe les URLs en plusieurs requêtes : plages [1-10] (avec :step optionnel et bourrage de zéros via des zéros initiaux) et listes {a,b,c}. -o 'file#1.zip' utilise #1 comme compteur pour des noms de sortie personnalisés. -g (--globoff) désactive le développement — essentiel pour les URLs contenant des [ ] ou { } littéraux (JSON, IPv6).

curl
# numeric range: 1, 2, 3
curl -O https://example.com/file[1-3].zip

# range with step: 0, 5, 10, 15, 20
curl -O https://example.com/file[0-20:5].zip

# leading zeros (zero-padded)
curl -O https://example.com/file[01-10].zip   # 01, 02, ..., 10

# list expansion: a, b, c
curl -O https://example.com/{a,b,c}.zip

# nested globs
curl -O https://example.com/{v1,v2}/file[1-2].txt

# save each with a custom name pattern
curl -o "file#1.zip" https://example.com/file[1-3].zip

# disable globbing (literal brackets)
curl -g "https://example.com/file[1].zip"

Plage séquentielle

Pour des téléchargements séquentiels (quand le parallélisme saturerait le serveur ou violerait les limites de débit), bouclez sur les URLs en bash. Ajoutez sleep par politesse. -sf (silencieux + fail) fait sortir curl avec un code non nul sur les erreurs HTTP pour que la boucle puisse s'arrêter tôt. C'est le pattern sûr pour le scraping ou le crawling : soyez respectueux, ajoutez des délais, gérez les erreurs.

curl
# fetch URLs one at a time (no parallelism)
for i in 1 2 3 4 5; do
  curl -O "https://example.com/page$i.html"
done

# range with brace expansion (bash/zsh)
for i in {1..10}; do
  curl -s -O "https://example.com/page$i.html"
done

# with a delay between requests (rate limiting)
for i in {1..10}; do
  curl -s -O "https://example.com/page$i.html"
  sleep 1
done

# retry each URL individually
for url in $(cat urls.txt); do
  curl -s --retry 3 -O "$url"
done

# conditional: stop on first error
for url in $(cat urls.txt); do
  curl -sf -O "$url" || { echo "failed: $url"; break; }
done

GNU parallel et curl

GNU parallel est plus puissant que xargs : il conserve l'ordre de sortie, affiche la progression (--bar) et gère les arguments plus souplement. -j N fixe la concurrence. :::: lit depuis un fichier, ::: depuis la ligne de commande. Parallel est idéal pour les tests d'API en lot, le scraping et les benchmarks où l'on veut une sortie propre et ordonnée de requêtes concurrentes.

curl
# GNU parallel: smarter than xargs (preserves order, progress)
parallel -j4 curl -O {} ::: https://example.com/a.zip \
                            https://example.com/b.zip

# parallel from a file
parallel -j4 curl -O :::: urls.txt

# parallel with progress bar
parallel --bar -j4 curl -O :::: urls.txt

# parallel with output capture
parallel -j4 'curl -s -o {}.out {}' :::: urls.txt

# parallel with retry and timing
parallel -j4 'curl -s -w "{} %{time_total}s\n" -o /dev/null {}' :::: urls.txt

# parallel POST requests
parallel -j4 'curl -s -X POST -d "id={}" https://api.example.com/{}' \
  ::: 1 2 3 4 5

# combine with --dry-run to preview
parallel --dry-run -j4 curl -O :::: urls.txt
17

Fichiers de config

Bases de .curlrc

~/.curlrc contient les options par défaut appliquées à chaque invocation de curl. Utilisez les noms longs sans le -- initial. Une option par ligne ; les valeurs peuvent être citées. Cela garde les réglages courants (timeouts, reprises, User-Agent) cohérents entre scripts et usage interactif. Contournez par requête en passant l'option explicitement en ligne de commande.

curl
# ~/.curlrc is read automatically by curl
# one option per line, long option names without the --

# ~/.curlrc example:
# show progress by default
silent
# always follow redirects
location
# default User-Agent
user-agent = "MyApp/1.0"
# default headers
header = "Accept: application/json"
# retry transient errors
retry = 3
# connect timeout
connect-timeout = 10
# max time
max-time = 30

# lines starting with # are comments
# blank lines are ignored

# test: curl https://example.com now uses all the above

Emplacement du fichier de config

Curl lit ~/.curlrc (ou $CURL_HOME/.curlrc) par défaut. -K (--config) pointe vers un fichier précis ; -K - lit depuis stdin. -q (--disable) ignore entièrement le fichier de config — utile quand une option par défaut casse une requête précise. CURL_HOME déplace le répertoire de recherche pour des configurations portables.

curl
# default locations (searched in order):
# 1. ~/.curlrc (or $CURL_HOME/.curlrc)
# 2. /etc/curl/curlrc (system-wide, if compiled in)

# set a custom config directory
export CURL_HOME=/etc/curl
# curl then reads $CURL_HOME/.curlrc

# specify a config file explicitly
curl -K /path/to/myconfig https://example.com
curl --config /path/to/myconfig https://example.com

# read config from stdin
echo "silent" | curl -K - https://example.com

# disable config file reading
curl -q https://example.com
curl --disable https://example.com

# check which config curl reads
curl -v https://example.com 2>&1 | grep -i config

Config avec -K

-K charge les options depuis un fichier, parfait pour des configs par environnement (tokens dev vs prod, timeouts, en-têtes). Stocker les secrets dans un fichier de config (chmod 600) les garde hors de l'historique du shell et de ps. Plusieurs fichiers -K sont traités dans l'ordre, les suivants remplacent les précédents — utile pour une config de base plus des surcharges par environnement.

curl
# use a config file for a specific request
curl -K prod.conf https://api.example.com/data

# prod.conf:
# header = "Authorization: Bearer prod-token"
# header = "X-Environment: production"
# connect-timeout = 5
# max-time = 20

# dev.conf (different settings)
# header = "Authorization: Bearer dev-token"
# header = "X-Environment: development"
# max-time = 60

# switch environments by config file
curl -K dev.conf https://api.example.com/data
curl -K prod.conf https://api.example.com/data

# config file with URL
# echo "url = https://api.example.com/data" > req.conf
curl -K req.conf

# multiple config files (later ones override earlier)
curl -K defaults.conf -K override.conf https://example.com

Défauts courants

Un bon ~/.curlrc rend chaque invocation de curl plus sûre et cohérente : les timeouts évitent les blocages, les reprises gèrent les échecs transitoires, --compressed gère le gzip de façon transparente, et un User-Agent épuré réduit le fingerprinting. La ligne write-out journalise le timing et le statut de chaque requête — inestimable pour des vérifications de performance rapides.

curl
# ~/.curlrc with sensible production defaults

# always follow redirects
location
# limit redirects
max-redirs = 5

# timeouts (fail fast, cap total)
connect-timeout = 10
max-time = 60

# retry transient failures
retry = 3
retry-delay = 2
retry-all-errors

# show errors even when silent
show-error

# auto-decompress responses
compressed

# negotiate HTTP/2
http2

# verify SSL by default (explicit for clarity)
cacert = /etc/ssl/certs/ca-certificates.crt

# don't leak the curl version
user-agent = ""

# verbose timing on failure
write-out = "time: %{time_total}s code: %{http_code}\n"

Configs multiples

Découper la config en fichiers en couches (base, auth, api, environnement) garde les choses modulaires et sûres. Traitez-les avec plusieurs flags -K dans l'ordre — les fichiers suivants remplacent les précédents. Placez les secrets dans un fichier en permission 600 hors gestion de versions. Un script d'encapsulation qui charge la pile permet d'appeler 'mycurl' avec tous les défauts appliqués.

curl
# base.conf — shared defaults
# silent
# show-error
# compressed
# connect-timeout = 10
# max-time = 30

# auth.conf — credentials (chmod 600)
# user = alice:secret
# header = "Authorization: Bearer TOKEN"

# api.conf — API-specific options
# header = "Accept: application/json"
# header = "X-Client: my-app/2.0"
# retry = 5

# combine configs in order (later overrides earlier)
curl -K base.conf -K auth.conf -K api.conf \
     https://api.example.com/data

# config file referencing another (nesting not supported)
# but you can source them in a wrapper script:
#   #!/bin/bash
#   curl -K base.conf -K auth.conf -K api.conf "$@"

# environment-specific overlay
curl -K base.conf -K "${ENV}.conf" https://api.example.com
18

Techniques avancées

Réutilisation de connexion

Au sein d'une même invocation, la connexion TCP est réutilisée pour plusieurs URLs du même hôte (HTTP keep-alive), économisant la poignée de main TLS. --no-keepalive désactive cela. --max-connects plafonne les connexions concurrentes pour les fetches multi-URL. Entre des appels curl distincts, il n'y a pas de réutilisation — pour cela, utilisez un client persistant comme httpie ou un script en Python/Node.

curl
# curl reuses connections within a single invocation
# multiple URLs in one command share the TCP connection
curl -o a.txt https://example.com/a \
     -o b.txt https://example.com/b

# keep-alive is on by default
# disable it for a single request
curl --no-keepalive https://example.com

# limit max connections (for multi-URL)
curl --max-connects 4 \
     -O https://example.com/a -O https://example.com/b

# persistent session across shell calls (not natively supported)
# but you can use a config file to reduce overhead
curl -K session.conf https://example.com/a
curl -K session.conf https://example.com/b

# check if connection was reused
curl -v https://example.com 2>&1 | grep -i "Connection #0"

HTTP/2 et HTTP/3

HTTP/2 multiplexe les requêtes sur une connexion ; HTTP/3 utilise QUIC sur UDP, supprimant le blocage head-of-line. --http2 négocie via ALPN sur TLS ; --http2-prior-knowledge saute la négociation (pour h2c en clair). --http3 exige une build spéciale de curl. Vérifiez %{http_version} pour confirmer ce qui a réellement été utilisé. La plupart des CDN modernes gèrent h2 par défaut.

curl
# negotiate HTTP/2 (needs TLS + ALPN)
curl --http2 https://example.com

# force HTTP/2 (fail if not available)
curl --http2-only https://example.com

# negotiate HTTP/3 (QUIC, needs curl built with quiche/openssl-quic)
curl --http3 https://example.com

# force HTTP/3 only
curl --http3-only https://example.com

# check what version was negotiated
curl -s -o /dev/null -w "%{http_version}" https://example.com
echo   # 2 or 3

# list supported HTTP versions
curl --version | grep -i -E "http2|http3"

# HTTP/2 with prior knowledge (no upgrade negotiation)
curl --http2-prior-knowledge http://example.com

Requêtes conditionnelles

Les requêtes conditionnelles économisent la bande passante : le serveur renvoie 304 Not Modified (sans corps) si la ressource n'a pas changé. -z (--time-cond) définit If-Modified-Since depuis une date ou le mtime d'un fichier local. Pour un cache basé sur les ETag, définissez If-None-Match manuellement. If-Unmodified-Since active la concurrence optimiste — le PUT échoue si quelqu'un d'autre a modifié la ressource.

curl
# fetch only if modified since a date
curl -z "Wed, 21 Oct 2025 07:28:00 GMT" \
     -O https://example.com/data.json
curl --timecond "Wed, 21 Oct 2025 07:28:00 GMT" \
     -O https://example.com/data.json

# fetch only if changed (use a local file's mtime)
curl -z local_copy.json -O https://example.com/data.json

# ETag-based conditional (If-None-Match)
curl -H 'If-None-Match: "abc123"' \
     -o data.json https://example.com/data.json
# server returns 304 Not Modified if ETag matches

# If-Modified-Since header manually
curl -H "If-Modified-Since: Wed, 21 Oct 2025 07:28:00 GMT" \
     https://example.com/data.json

# If-Unmodified-Since (for concurrency control)
curl -X PUT -H "If-Unmodified-Since: Wed, 21 Oct 2025 07:28:00 GMT" \
     -d '{"x":1}' https://api.example.com/data

Interface et DNS

--interface se lie à une carte réseau ou une IP — utile sur les machines multi-homed. --resolve épingle un hôte à une IP en contournant le DNS, parfait pour tester des backends derrière un load balancer. --doh-url utilise le DNS-over-HTTPS (confidentialité). -4/-6 forcent une famille d'IP. Happy Eyeballs (défaut) essaie IPv4 et IPv6 pour éviter les délais de blackhole IPv6.

curl
# bind to a specific network interface
curl --interface eth0 https://example.com
curl --interface 192.168.1.5 https://example.com

# pin a hostname to an IP (skip DNS)
curl --resolve example.com:443:1.2.3.4 https://example.com

# pin multiple hosts
curl --resolve example.com:443:1.2.3.4 \
     --resolve api.example.com:443:1.2.3.5 \
     https://example.com/

# use a custom DNS server (DoH)
curl --doh-url https://dns.google/dns-query https://example.com
curl --doh-url https://cloudflare-dns.com/dns-query https://example.com

# use a specific DNS resolver (plain DNS, curl 7.84+)
curl --dns-servers 8.8.8.8,1.1.1.1 https://example.com

# happy eyeballs: try IPv4 and IPv6 in parallel
curl --happy-eyeballs-timeout-ms 200 https://example.com

# force IPv4 or IPv6
curl -4 https://example.com
curl -6 https://example.com

Requêtes Range et partielles

Les requêtes Range (-r) récupèrent une partie d'un fichier, avec réponse 206 Partial Content. Cas d'usage : prévisualiser de gros fichiers, téléchargements parallèles multi-connexions (découper en plages, récupérer en parallèle, concaténer), et reprendre des transferts interrompus (-C -). Le serveur doit annoncer Accept-Ranges: bytes. C'est la base des accélérateurs de téléchargement comme aria2.

curl
# request a byte range (first 1024 bytes)
curl -r 0-1023 -o part.bin https://example.com/file.zip

# request from byte 1024 to end
curl -r 1024- -o rest.bin https://example.com/file.zip

# request last 500 bytes
curl -r -500 -o tail.bin https://example.com/file.zip

# check if server supports ranges
curl -I https://example.com/file.zip | grep -i accept-ranges

# download in parallel chunks
curl -r 0-49999999    -o part1.bin https://example.com/big.iso &
curl -r 50000000-     -o part2.bin https://example.com/big.iso &
wait
cat part1.bin part2.bin > big.iso

# resume a partial download
curl -C - -o file.zip https://example.com/file.zip

# HTTP 206 = Partial Content (range succeeded)
curl -r 0-100 -v https://example.com/file.zip 2>&1 | grep HTTP

Codes de sortie

Les codes de sortie de curl distinguent les modes d'échec : 6 (DNS), 7 (connexion), 22 (erreur HTTP, seulement avec -f), 28 (timeout), 35 (TLS), 60 (cert). Utilisez-les pour construire des scripts robustes qui réessaient à bon escient (ex. réessayer sur 28 mais échouer vite sur 6). --fail-with-body renvoie le corps de réponse même sur 4xx/5xx, ce qui facilite bien plus le débogage des erreurs d'API que -f.

curl
# common curl exit codes:
# 0  - success
# 1  - unsupported protocol
# 3  - malformed URL
# 6  - couldn't resolve host (DNS failure)
# 7  - failed to connect
# 22 - HTTP error (use with -f)
# 26 - couldn't read a file (e.g., -d @missing.txt)
# 28 - operation timeout
# 35 - SSL connect error
# 47 - too many redirects
# 52 - server didn't reply anything
# 55 - failed sending network data
# 56 - failed receiving network data
# 60 - certificate verification failed

# check exit code
curl -sf https://example.com || echo "failed: $?"

# branch on specific codes
curl --max-time 5 https://example.com
case $? in
  0)  echo "ok" ;;
  6)  echo "DNS failure" ;;
  7)  echo "connection refused" ;;
  28) echo "timeout" ;;
  *)  echo "error: $?" ;;
esac

# treat HTTP errors as failures
curl -f https://api.example.com || echo "HTTP error"

# still print body on HTTP error (7.76+)
curl --fail-with-body https://api.example.com

Was this helpful?