curl : interroger des ressources HTTP et réseau

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. Il 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 a été rejoué avec curl 8.22.0 (2 septembre 2026), compilé depuis les sources. Cette version corrige 9 CVE, dont un use-after-free sur le push HTTP/2 (CVE-2026-18924). La 8.18.0 corrigeait déjà CVE-2025-14524 (fuite de token Bearer sur redirection cross-protocole), qui touche encore la 8.17.0. Changelog complet.

Ce que vous allez apprendre

• Envoyer des requêtes GET, POST, PUT et DELETE, avec en-têtes et corps JSON
• Télécharger et téléverser des fichiers, en HTTP comme en FTP
• Authentifier une requête : Basic, jeton Bearer, fichier de configuration -K
• Diagnostiquer un échange avec -v et les métriques de --write-out
• Fiabiliser curl dans un script : --fail, --silent, fichiers de configuration

Cheatsheet curl

Ce tableau rassemble les options que vous utiliserez au quotidien, à garder sous la main pour un accès rapide. Chacune est détaillée plus bas avec un exemple exécutable. Deux repères pour le lire : les options en majuscule et minuscule ne font pas la même chose (-o nomme le fichier, -O garde le nom distant), et les deux dernières lignes (-w, --silent --fail) sont celles qui rendent curl fiable dans un script.

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

curl est presque toujours déjà présent sur une distribution Linux. Les deux premiers onglets installent la version du dépôt de votre distribution, largement suffisante pour un usage courant. Le troisième onglet ne concerne que le cas où vous avez besoin d'une fonctionnalité récente absente de la version packagée : il compile la 8.22.0 depuis les sources officielles, dans votre répertoire personnel pour ne pas écraser le binaire système. Avant de compiler, il vérifie la signature GPG de l'archive : gpg --verify doit afficher Good signature from "Daniel Stenberg" et l'empreinte 27ED EAF2 2F3A BCEB 50DB 9A12 5CC9 08FD B71E 12C2 (vérifié le 2026-10-01). Sans libpsl-dev, le ./configure s'arrête sur libpsl libs and/or directories were not found (constaté sur Debian 13).

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.22.0 :

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

# Télécharger l'archive et sa signature
cd /tmp
curl -LO https://curl.se/download/curl-8.22.0.tar.gz
curl -LO https://curl.se/download/curl-8.22.0.tar.gz.asc

# Vérifier la signature de Daniel Stenberg avant de compiler
curl -L -o daniel.asc https://daniel.haxx.se/mykey.asc
gpg --import daniel.asc
gpg --verify curl-8.22.0.tar.gz.asc curl-8.22.0.tar.gz

# Compiler
tar xzf curl-8.22.0.tar.gz
cd curl-8.22.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.22.0 (x86_64-pc-linux-gnu) libcurl/8.22.0 OpenSSL/3.5.7 zlib/1.3.1 libpsl/0.21.2 nghttp2/1.64.0
Release-Date: 2026-09-02
Protocols: dict file ftp ftps gopher gophers http https imap imaps ipfs ipns mqtt mqtts pop3 pop3s rtsp smtp smtps telnet tftp ws wss
Features: alt-svc AsynchDNS HSTS HTTP2 HTTPS-proxy IPv6 Largefile libz PSL SSL threadsafe 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, chacune avec la commande qui la montre à l'œuvre. Le -o minuscule et le -O majuscule forment la première paire à distinguer :

• -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 contenu. Attention au nom : -O le tire de l'URL tapée, pas de l'URL finale. Ici, le fichier s'appelle donc exemple-lien. Imposez le nom avec -o, ou ajoutez -J quand le serveur annonce un nom dans l'en-tête Content-Disposition.

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, en lisant le fichier ligne par ligne : une forme for url in $(cat urls.txt) découperait sur les espaces et développerait les jokers comme * ou ? présents dans une URL.

while read -r url; do curl -O "$url"; done < urls.txt

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. Les réponses arrivent presque toujours au format JSON, que l'on peut filtrer avec jq.

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.22.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.22.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.22.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.22.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 :

chmod 600 curl.conf   # le fichier contient un secret
curl -K curl.conf

Le mot de passe ne passe plus par la ligne de commande, donc ni par l'historique du shell ni par ps aux. En contrepartie, il vit en clair dans le fichier : limitez-en la lecture à votre compte et ne le versionnez jamais dans un dépôt Git.

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/

SFTP et SCP dépendent de la façon dont curl a été compilé. Le paquet de Debian 13 les prend en charge, celui d'AlmaLinux 10 ne gère que file, ftp, ftps, http, https, ipfs et ipns, et répond curl: (1) Protocol "sftp" not supported. Vérifiez la ligne Protocols de curl --version avant de bâtir un script dessus.

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.22.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/

En HTTP, -T envoie déjà un PUT : le -X PUT est redondant. Et comme l'URL se termine par /, curl y ajoute le nom du fichier, la requête part donc vers /scripts/script.sh.

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

Pour tester un site qui maintient une session, curl sait enregistrer les cookies reçus dans un fichier, puis les renvoyer à la requête suivante. Deux options se répondent : -c (cookie jar) écrit les cookies reçus, -b les relit et les envoie. La séquence ci-dessous enchaîne les deux pour rejouer une session complète.

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 barre de progression et les messages d'erreur, pas le contenu téléchargé
• --fail : renvoie le code retour 22 si le HTTP code ≥ 400
• --show-error : réaffiche les messages d'erreur masqués par --silent

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 en revue, tant que le fichier ne contient aucun secret. Les identifiants vont dans un second fichier en chmod 600, hors du dépôt, ou passent par l'entrée standard comme décrit dans la section suivante.

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 un script, mais méfiez-vous aussi de la fausse bonne idée des variables : curl -u "$API_USER:$API_PASS" est développé par le shell avant l'appel, et le secret se retrouve dans les arguments du processus. curl tente d'effacer la valeur de -u après son démarrage, mais un ps lancé au même instant la lit encore, et un en-tête passé par -H n'est jamais effacé. La forme sûre fait transiter le secret par l'entrée standard, que -K - lit comme un fichier de configuration :

printf 'user = "%s:%s"\n' "$API_USER" "$API_PASS" | curl -sS -K - https://api.example.com/securise
printf 'header = "Authorization: Bearer %s"\n' "$API_TOKEN" | curl -sS -K - https://api.example.com/profil

printf est une commande interne du shell : aucun processus ne porte le secret en argument. Mesuré avec curl 8.18.0, le serveur reçoit bien l'en-tête Authorization dans les deux cas. Évitez enfin le nom $USER pour vos variables : le shell le remplit déjà avec votre identifiant de connexion, et c'est lui qui partirait vers le serveur.

Dépannage

Les erreurs de curl se répartissent en deux familles faciles à distinguer. Les codes entre parenthèses (curl: (6), (7), (35)...) sont des erreurs curl : le transfert n'a pas abouti, le problème est côté réseau, DNS ou TLS. Les codes 4xx, en revanche, signifient que la requête est bien arrivée mais que le serveur l'a refusée : l'échange fonctionne, c'est l'authentification ou les droits qui bloquent. Identifier la famille oriente d'emblée vers la bonne colonne.

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) TLS connect error	Négociation TLS impossible (version ou suite de chiffrement refusée)	Comparer les versions TLS acceptées des deux côtés
curl: (60) SSL certificate ... verify result	Certificat expiré, auto-signé ou d'une autorité inconnue	Renouveler le certificat, mettre à jour ca-certificates, ou --cacert ; --insecure en dev uniquement
curl: (60) ... no alternative certificate subject name matches	Le nom de l'URL n'est pas dans le certificat	Vérifier les noms (SAN) 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

À retenir

• curl transfère des données via une trentaine de protocoles selon sa compilation (29 sur Debian 13, 7 sur AlmaLinux 10)
• 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
• Gardez curl à jour : la 8.18.0 corrigeait 6 CVE, la 8.22.0 en corrige 9 autres
• Passez les secrets par un fichier -K en chmod 600 ou par l'entrée standard (-K -), jamais en argument de la commande

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% 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

Ressources

Ces liens mènent à la documentation officielle du projet curl, la référence pour vérifier une option ou la liste des avis de sécurité.

• Site officiel : curl.se
• Documentation : curl.se/docs
• Changelog 8.22.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 →