Maitriser la commande curl

curl est l’outil de transfert de données le plus répandu dans l’écosystème DevOps — installé par défaut sur la quasi-totalité des distributions Linux. Ils est utilisé pour tester une API REST en une ligne, télécharger des fichiers, automatiser des webhooks ou déboguer des problèmes réseau. Contrairement à Postman, curl s’exécute directement dans un terminal ou un script shell, ce qui le rend indispensable dans les pipelines CI/CD et l’administration système.

Version actuelle

Ce guide utilise curl 8.18.0 (7 janvier 2026). Cette version corrige 6 CVE de sécurité dont CVE-2025-14524 (fuite de token Bearer sur redirection cross-protocole). Changelog complet.

Cheatsheet curl

Commande	Description
curl URL	Requête GET simple
curl -o fichier URL	Télécharger dans un fichier nommé
curl -O URL	Télécharger en gardant le nom distant
curl -I URL	Afficher uniquement les en-têtes HTTP
curl -L URL	Suivre les redirections
curl -X POST -d "data" URL	Envoyer des données POST
curl -H "Header: value" URL	Ajouter un en-tête personnalisé
curl -u user:pass URL	Authentification HTTP Basic
curl -F "file=@path" URL	Téléverser un fichier (multipart)
curl -c cookies.txt URL	Sauvegarder les cookies
curl -b cookies.txt URL	Envoyer les cookies
curl -w "%{http_code}" URL	Afficher le code HTTP
curl --silent --fail URL	Mode silencieux pour scripts

Glissez pour voir

Les fonctionnalités de curl

Curl (abréviation de Client URL) est un outil en ligne de commande conçu pour transférer des données vers ou depuis un serveur, en utilisant des protocoles comme HTTP, HTTPS, FTP, SFTP, SCP, LDAP, ou encore SMTP.

Il s’utilise aussi bien pour :

• Télécharger un fichier depuis Internet,
• Tester des points d’accès d’une API REST,
• Soumettre des formulaires HTML,
• Automatiser des transferts de fichiers,
• Effectuer des requêtes HTTP complexes avec headers, authentification ou cookies.

Contrairement à des outils plus lourds comme Postman, curl s’utilise directement depuis un terminal, dans des scripts, ou au sein de pipelines DevOps. Sa légèreté et sa compatibilité multi-protocole en font un outil de diagnostic et d’automatisation redoutablement efficace, que l’on soit développeur ou administrateur système.

Installation

Ubuntu/Debian

# Version du dépôt (généralement plus ancienne)
sudo apt update && sudo apt install -y curl

# Vérifier la version
curl --version

Fedora/RHEL

sudo dnf install -y curl
curl --version

Compilation (dernière version)

Pour obtenir la version 8.18.0 avec toutes les fonctionnalités :

# Dépendances
sudo apt install -y build-essential libssl-dev libnghttp2-dev

# Télécharger et compiler
cd /tmp
curl -LO https://curl.se/download/curl-8.18.0.tar.gz
tar xzf curl-8.18.0.tar.gz
cd curl-8.18.0
./configure --with-openssl --prefix=$HOME/.local
make -j$(nproc)
make install

# Ajouter au PATH
export PATH="$HOME/.local/bin:$PATH"

Vérifiez l’installation :

curl --version

Sortie

curl 8.18.0 (x86_64-pc-linux-gnu) libcurl/8.18.0 OpenSSL/3.0.13 zlib/1.3 nghttp2/1.59.0
Release-Date: 2026-01-07
Protocols: dict file ftp ftps gopher gophers http https imap imaps ipfs ipns mqtt pop3 pop3s rtsp smb smbs smtp smtps telnet tftp ws wss
Features: alt-svc AsynchDNS HSTS HTTP2 HTTPS-proxy IPv6 Largefile libz NTLM SSL threadsafe TLS-SRP UnixSockets

Syntaxe de base

La commande curl repose sur une structure simple et directe. En version minimale, elle se compose d’une URL, mais sa puissance vient des nombreuses options que l’on peut ajouter selon le besoin.

curl [options] [URL]

Les options essentielles

Voici les options les plus utilisées pour bien démarrer :

• -o fichier : enregistre le contenu dans un fichier local nommé fichier.

  curl -o page.html https://example.com

• -O : télécharge le fichier en conservant le nom d’origine sur le serveur.

  curl -O https://example.com/fichier.zip

• -L : suit automatiquement les redirections HTTP (très utile sur des URLs raccourcies ou déplacées).

  curl -L https://example.com/ancien-lien

• -I : affiche uniquement les en-têtes HTTP (headers).

  curl -I https://example.com

• -X : spécifie une méthode HTTP (GET, POST, PUT, DELETE…).

  curl -X DELETE https://api.example.com/ressource

• -d : envoie des données dans le corps de la requête (POST par défaut).

  curl -d "nom=Jean&age=30" https://example.com/formulaire

• -H : ajoute un en-tête personnalisé (ex. JSON, token, cookie…).

  curl -H "Content-Type: application/json" https://api.example.com

• -u : utilise une authentification de type HTTP Basic.

  curl -u admin:motdepasse https://example.com/admin

Usages courants

L’un des usages les plus fréquents de curl, c’est le téléchargement de contenu depuis une URL. Il peut s’agir de pages HTML, d’archives, d’images, ou de scripts. Voici comment le faire efficacement.

Enregistrer dans un fichier spécifique

Pour télécharger une page ou un fichier et choisir le nom local :

curl -o page.html https://example.com

Sortie

  % Total    % Received % Xferd  Average Speed  Time    Time    Time   Current
                                 Dload  Upload  Total   Spent   Left   Speed
100    513   0    513   0      0  10421      0                              0

Cela écrit le contenu de la réponse dans un fichier nommé page.html.

Afficher uniquement les en-têtes HTTP

L’option -I permet de récupérer les métadonnées sans télécharger le contenu :

curl -I https://example.com

Sortie

HTTP/2 200
date: Sat, 24 Jan 2026 08:44:59 GMT
content-type: text/html
cf-ray: 9c2e40871e88791b-CDG
last-modified: Fri, 23 Jan 2026 20:51:32 GMT
allow: GET, HEAD
accept-ranges: bytes
age: 3591
cf-cache-status: HIT
server: cloudflare

Conserver le nom du fichier distant

Si vous voulez récupérer un fichier en gardant son nom original (extrait de l’URL) :

curl -O https://example.com/script.sh

Cela crée un fichier script.sh dans le répertoire courant.

Suivre les redirections

Certains liens vous redirigent automatiquement (HTTP 301 ou 302). Sans option, curl ne les suit pas. Il faut ajouter -L :

curl -LO https://bit.ly/exemple-lien

Cela permet d’atteindre l’URL finale et de récupérer le bon fichier.

Reprendre un téléchargement interrompu

curl peut reprendre un téléchargement si la connexion est interrompue :

curl -C - -O https://example.com/long-fichier.zip

L’option -C - détecte la taille du fichier existant et continue depuis là.

Télécharger plusieurs fichiers

Utilisez plusieurs options -O :

curl -O https://site1.com/fichier1.txt -O https://site2.com/fichier2.jpg

Ou utilisez une boucle shell pour automatiser :

for url in $(cat urls.txt); do curl -O "$url"; done

Envoi de requêtes HTTP

curl est aussi un outil puissant pour interagir avec des APIs REST. Il permet d’envoyer tous types de requêtes HTTP : GET, POST, PUT, DELETE, avec des données, des en-têtes, ou de l’authentification.

Requête GET (par défaut)

La méthode GET est celle utilisée par défaut. Elle permet de récupérer des données sans en envoyer.

curl -s https://httpbin.org/get

Sortie

{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/8.18.0",
    "X-Amzn-Trace-Id": "Root=1-69748697-791d1c236921ff1653569139"
  },
  "origin": "86.229.137.201",
  "url": "https://httpbin.org/get"
}

Requête POST avec des données simples

Envoyer des données application/x-www-form-urlencoded :

curl -X POST -d "nom=Alice&age=28" https://api.example.com/inscription

Par défaut, -d utilise POST, donc -X POST est optionnel ici.

Requête POST avec JSON

Envoyer une charge utile JSON nécessite de définir l’en-tête Content-Type :

curl -s -X POST \
  -H "Content-Type: application/json" \
  -d '{"email":"test@example.com","password":"1234"}' \
  https://httpbin.org/post

Sortie

{
  "args": {},
  "data": "{\"email\":\"test@example.com\",\"password\":\"1234\"}",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "*/*",
    "Content-Length": "46",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "curl/8.18.0"
  },
  "json": {
    "email": "test@example.com",
    "password": "1234"
  },
  "origin": "86.229.137.201",
  "url": "https://httpbin.org/post"
}

Envoyer des données depuis un fichier

Plutôt que d’inclure le JSON en ligne, utilisez @ pour lire depuis un fichier :

echo '{"nom":"Jean","age":30}' > data.json
curl -s -X POST \
  -H "Content-Type: application/json" \
  -d @data.json \
  https://httpbin.org/post

Sortie

{
  "data": "{\"nom\":\"Jean\",\"age\":30}",
  "json": {
    "age": 30,
    "nom": "Jean"
  }
}

Requête PUT ou DELETE

Simuler des requêtes de modification ou suppression :

curl -s -X PUT \
  -H "Content-Type: application/json" \
  -d '{"status":"actif"}' \
  https://httpbin.org/put

Sortie

{
  "data": "{\"status\":\"actif\"}",
  "json": {
    "status": "actif"
  }
}

curl -s -X DELETE https://httpbin.org/delete

Sortie

{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/8.18.0"
  },
  "json": null
}

Envoi de plusieurs en-têtes

Vous pouvez envoyer plusieurs headers HTTP personnalisés :

curl -s \
  -H "Authorization: Bearer mon_token_secret" \
  -H "Accept: application/json" \
  https://httpbin.org/headers

Sortie

{
  "headers": {
    "Accept": "application/json",
    "Authorization": "Bearer mon_token_secret",
    "Host": "httpbin.org",
    "User-Agent": "curl/8.18.0"
  }
}

Authentification

De nombreuses APIs ou serveurs exigent une authentification pour accéder à leurs ressources. curl prend en charge plusieurs méthodes : HTTP Basic, token Bearer, ou encore authentification FTP/SFTP.

Authentification HTTP Basic

C’est la forme la plus simple, où l’on transmet un nom d’utilisateur et un mot de passe encodés en base64 :

curl -s -u testuser:testpass https://httpbin.org/basic-auth/testuser/testpass

Sortie

{
  "authenticated": true,
  "user": "testuser"
}

Cette méthode fonctionne pour les APIs ou interfaces d’administration protégées par une fenêtre d’identification classique dans le navigateur.

Authentification via en-tête Bearer (token)

De nombreuses APIs modernes utilisent un jeton d’authentification (JWT ou autre) à inclure dans l’en-tête HTTP Authorization :

curl -H "Authorization: Bearer VOTRE_TOKEN" https://api.example.com/profil

Ce type de jeton est souvent obtenu via une requête POST en échange d’identifiants (flow OAuth ou authentification custom).

Sécurité CVE-2025-14524

La version 8.18.0 corrige une faille où le token Bearer pouvait fuiter lors d’une redirection cross-protocole (ex: HTTPS → HTTP). Mettez à jour curl si vous utilisez des tokens sensibles.

Authentification avec fichiers de configuration

Pour éviter de taper ses identifiants en clair ou d’utiliser des tokens en ligne de commande, curl permet de stocker des options dans un fichier :

Exemple : curl.conf

--user utilisateur:motdepasse
--url https://api.example.com/securise

Et pour l’utiliser :

curl -K curl.conf

Authentification FTP ou SFTP

curl peut aussi s’authentifier à un serveur FTP :

curl -u ftpuser:ftppass ftp://ftp.example.com/fichier.txt

Ou en SFTP :

curl -u user:sftpmdp sftp://serveur.example.com/dossier/

Utilisation avec FTP/SFTP

La commande curl permet également de transférer des fichiers via les protocoles FTP et SFTP, en lecture comme en écriture. C’est très utile pour automatiser des transferts vers des serveurs distants, des sauvegardes ou des publications.

Télécharger un fichier via FTP

Pour récupérer un fichier depuis un serveur FTP :

curl -u utilisateur:motdepasse ftp://ftp.example.com/fichier.txt -O

• -u : fournit les identifiants
• ftp:// : spécifie le protocole
• -O : conserve le nom du fichier d’origine

Téléverser un fichier via FTP

Pour envoyer un fichier vers un serveur FTP :

curl -T monfichier.txt -u utilisateur:motdepasse ftp://ftp.example.com/

• -T : indique le fichier à téléverser

Téléverser un fichier via SFTP

Même principe que pour FTP, mais avec un protocole sécurisé :

curl -T fichier.txt -u user:motdepasse sftp://sftp.example.com/chemin/

Lister le contenu d’un répertoire FTP

Pour obtenir la liste des fichiers d’un répertoire distant :

curl -u utilisateur:motdepasse ftp://ftp.example.com/

Cela renvoie une vue brute du contenu du répertoire cible.

Ajouter un port personnalisé

Si le serveur n’utilise pas les ports standards :

curl -u user:pass ftp://ftp.example.com:2121/fichier.txt -O

Téléversement de fichiers

Avec curl, il est aussi possible de téléverser (uploader) des fichiers vers un serveur, notamment via des formulaires HTML (en multipart/form-data) ou via FTP/SFTP.

Téléverser un fichier avec POST (multipart/form-data)

Pour simuler l’envoi d’un fichier depuis un formulaire HTML :

echo "fichier test upload" > upload.txt
curl -s -F "file=@upload.txt" https://httpbin.org/post

Sortie

{
  "files": {
    "file": "fichier test upload\n"
  },
  "headers": {
    "Content-Type": "multipart/form-data; boundary=------------------------ym8RxeZV33VnKHabQKinXP",
    "User-Agent": "curl/8.18.0"
  }
}

• -F : envoie les données comme un formulaire
• @ : indique que le contenu du fichier doit être envoyé

Téléverser plusieurs fichiers en une seule requête

On peut envoyer plusieurs champs, y compris plusieurs fichiers :

curl -F "photo1=@image1.jpg" -F "photo2=@image2.jpg" https://example.com/galerie

Et aussi ajouter des champs texte en même temps :

curl -F "titre=Vacances" -F "photo=@plage.jpg" https://example.com/album

Téléversement via PUT (API REST)

Certaines APIs acceptent l’envoi de fichiers via une méthode PUT :

curl -T script.sh -X PUT https://api.example.com/scripts/

Vous pouvez aussi définir un en-tête MIME spécifique :

curl -T data.csv -H "Content-Type: text/csv" https://api.example.com/donnees

Utilisation avancée

Au-delà des requêtes simples, curl offre des options puissantes pour des usages plus complexes : proxy, user-agent, cookies, debug, configuration, etc.

Utiliser un proxy

Pour faire passer une requête par un serveur proxy HTTP :

curl -x http://proxy.mondomaine.local:3128 https://example.com

Et pour un proxy avec authentification :

curl -x http://proxy:port -U utilisateur:motdepasse https://example.com

Spécifier un User-Agent personnalisé

Certains serveurs répondent différemment selon le navigateur simulé. Pour changer l’identifiant du client :

curl -s -A "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36" \
  https://httpbin.org/user-agent

Sortie

{
  "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
}

Gérer les cookies

1. Enregistrer les cookies dans un fichier :

   curl -s -c cookies.txt -L https://httpbin.org/cookies/set/session/abc123

2. Vérifier le fichier cookies :

   cat cookies.txt

   Sortie

   # Netscape HTTP Cookie File
   httpbin.org     FALSE   /       FALSE   0       session abc123

3. Réutiliser les cookies :

   curl -s -b cookies.txt https://httpbin.org/cookies

   Sortie

   {
     "cookies": {
       "session": "abc123"
     }
   }

Afficher les métriques de la requête

L’option -w (write-out) permet d’extraire des métriques :

curl -s -w "\n--- Métriques ---\nCode HTTP: %{http_code}\nTemps total: %{time_total}s\nTaille: %{size_download} octets\n" \
  -o /dev/null https://example.com

Sortie

--- Métriques ---
Code HTTP: 200
Temps total: 0.074715s
Taille: 513 octets

Limiter le débit

Simuler une connexion lente avec --limit-rate :

curl --limit-rate 100k -O https://example.com/film.mp4

Utiliser un fichier de configuration

Vous pouvez enregistrer les options curl dans un fichier texte :

options.conf :

--user utilisateur:mdp
--header "Accept: application/json"
--url https://api.example.com/data

Et exécuter :

curl -K options.conf

Bonnes pratiques

Pour tirer le meilleur parti de curl, adoptez ces habitudes qui rendent vos commandes plus sûres, plus lisibles et plus réutilisables.

Toujours vérifier la version installée

Certaines fonctionnalités peuvent ne pas être disponibles dans les versions plus anciennes :

curl --version

Cela vous donne aussi les protocoles pris en charge (HTTP/2, SSL, etc.).

Utiliser --silent pour les scripts automatisés

Pour éviter le bruit dans les scripts (barres de progression ou erreurs mineures) :

curl --silent --fail --show-error -o fichier.txt https://example.com

• --silent : supprime la sortie normale
• --fail : renvoie une erreur si le HTTP code ≥ 400
• --show-error : affiche les erreurs s’il y en a

Préférer les fichiers de configuration pour les commandes longues

Plutôt que de taper une commande de 5 lignes, placez les options dans un fichier curl.conf et lancez :

curl -K curl.conf

C’est plus lisible, versionnable et facile à relire.

Toujours spécifier les en-têtes explicitement pour les API

De nombreuses APIs nécessitent Content-Type: application/json. Soyez explicite :

curl -H "Content-Type: application/json" ...

Ne jamais exposer de mots de passe dans des scripts partagés

Évitez les identifiants en dur dans les lignes de commande. Utilisez des variables d’environnement ou des fichiers sécurisés :

curl -u "$USER:$MDP" ...

Ou encore :

source .env && curl -u "$FTP_USER:$FTP_PASS" ...

Dépannage

Problème	Cause probable	Solution
curl: (6) Could not resolve host	DNS ou nom de domaine incorrect	Vérifier l’URL et la connexion réseau
curl: (7) Failed to connect	Port fermé ou firewall	Vérifier que le service écoute
curl: (35) SSL connect error	Certificat invalide ou expiré	Ajouter --insecure (dev uniquement) ou mettre à jour ca-certificates
curl: (51) SSL peer certificate	Nom de domaine ne correspond pas	Vérifier le CN du certificat
curl: (56) Recv failure	Connexion interrompue	Réessayer avec -C - pour reprendre
HTTP 401 Unauthorized	Token ou credentials invalides	Vérifier -u ou header Authorization
HTTP 403 Forbidden	Permissions insuffisantes	Vérifier les droits d’accès
HTTP 429 Too Many Requests	Rate limiting	Ajouter un délai entre les requêtes

Glissez pour voir

Contrôle de connaissances

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

10 questions

5 min.

80% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• curl transfère des données via 25+ protocoles (HTTP, FTP, SFTP, etc.)
• L’option -o enregistre dans un fichier, -O conserve le nom distant
• -I affiche les en-têtes HTTP, -L suit les redirections
• Pour les APIs : -X définit la méthode, -H ajoute des headers, -d envoie des données
• -u user:pass pour l’auth Basic, -H "Authorization: Bearer TOKEN" pour les tokens
• -F "file=@chemin" téléverse des fichiers en multipart
• --silent --fail --show-error pour une utilisation dans les scripts
• Mettez à jour vers 8.18.0 pour corriger 6 CVE de sécurité
• Utilisez des variables d’environnement pour les credentials sensibles

Prochaines étapes

Planification de tâches avec les timers systemd Automatiser vos appels curl avec systemd

Cron et Crontab Planifier des tâches récurrentes sous Linux

jq : manipuler du JSON en ligne de commande Parser les réponses JSON de vos requêtes curl

Scripts Bash avancés Intégrer curl dans vos scripts d'automatisation

Ressources

• Site officiel : curl.se
• Documentation : curl.se/docs
• Changelog 8.18.0 : curl.se/changes.html
• CVE curl : curl.se/docs/security.html

FAQ - Questions Fréquemment Posées

Qu'est-ce que la commande curl ?

Quels sont les principaux usages de curl ?

Quelle est la syntaxe de base de la commande curl ?

Comment télécharger un fichier avec curl ?

Comment envoyer des données avec curl ?

Comment suivre les redirections HTTP avec curl ?

Comment authentifier une requête avec curl ?

Curl permet-il de téléverser des fichiers ?

Comment utiliser curl avec un proxy ?

Comment afficher uniquement les en-têtes HTTP avec curl ?

Qu'est-ce que l'option -v dans curl ?

Comment limiter la vitesse de téléchargement avec curl ?

Comment gérer les cookies avec curl ?

Comment sécuriser les identifiants dans les scripts curl ?

Que fait l'option --insecure dans curl ?

×

📖 Voir la documentation →