Maitriser la commande curl

Maîtriser la commande curl, c’est se donner les moyens d’interagir simplement avec des services distants, sans interface graphique. Que ce soit pour tester une API, télécharger des fichiers, envoyer des requêtes HTTP, ou encore travailler avec FTP ou SFTP, curl devient vite un réflexe en ligne de commande. Sa richesse fonctionnelle, sa portabilité et sa simplicité d’utilisation en font un outil incontournable pour automatiser les échanges entre machines et services.

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.

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

Avec seulement quelques options, on peut déjà simuler des appels d’API, faire du diagnostic réseau ou automatiser des interactions web. La suite du guide montrera comment tirer parti de ces options dans des cas réels.

Téléchargement de fichiers

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 fichier.html https://example.com

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

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 un fichier texte contenant une liste d’URLs :

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

Le téléchargement avec curl est très flexible. Il s’intègre parfaitement dans des scripts de déploiement, de sauvegarde ou de mise à jour automatisée.

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 https://api.example.com/utilisateurs

Avec suivi des redirections et affichage détaillé :

curl -Lv https://api.example.com/utilisateurs

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 -X POST -H "Content-Type: application/json" \
     -d '{"email": "test@example.com", "motdepasse": "1234"}' \
     https://api.example.com/connexion

Requête PUT ou DELETE

Simuler des requêtes de modification ou suppression :

curl -X PUT -H "Content-Type: application/json" \
     -d '{"status": "actif"}' \
     https://api.example.com/utilisateurs/42

curl -X DELETE https://api.example.com/utilisateurs/42

Envoi de plusieurs en-têtes

Vous pouvez envoyer plusieurs headers HTTP personnalisés :

curl -H "Accept: application/json" \
     -H "Authorization: Bearer MON_TOKEN" \
     https://api.example.com/profil

Ces usages de curl sont particulièrement utiles pour tester une API REST sans outil graphique, automatiser des appels d’API, ou déboguer des erreurs côté serveur.

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 -u utilisateur:motdepasse https://api.example.com/securise

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).

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/

Quel que soit le protocole ou le mode d’authentification, curl fournit les mécanismes nécessaires pour tester en local, script-er l’accès sécurisé, ou intégrer des appels protégés dans vos automatisations.

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

Avec ces commandes, on peut automatiser des envois et récupérations de fichiers, sans passer par un client FTP graphique. curl devient alors un composant clé dans les scripts de déploiement ou de synchronisation.

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. Voici les cas les plus courants.

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

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

curl -F "fichier=@/chemin/vers/image.jpg" https://example.com/upload

• -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

Téléversement via FTP/SFTP (rappel)

Pour envoyer un fichier via FTP :

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

Et en SFTP :

curl -T archive.tar.gz -u user:pass sftp://sftp.example.com/uploads/

Ces fonctions de téléversement sont particulièrement utiles dans les scripts d’automatisation : publication de contenu, sauvegarde de fichiers sur un serveur, ou tests d’interfaces de formulaire sans interface graphique.

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. Ces fonctions permettent d’intégrer curl dans des contextes professionnels ou automatisés.

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 -A "Mozilla/5.0 (compatible; curl-test)" https://example.com

Gérer les cookies

Enregistrer les cookies dans un fichier :

curl -c cookies.txt https://example.com/login

Puis les réutiliser :

curl -b cookies.txt https://example.com/espace-prive

Afficher les détails de la requête et de la réponse

L’option -v (verbose) donne une vue complète des échanges réseau :

curl -v https://example.com

Pour un affichage encore plus complet avec les en-têtes envoyés et reçus :

curl -i -v https://example.com

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

---

Avec ces options avancées, curl devient un véritable couteau suisse réseau, capable de s’adapter à des environnements complexes, sécurisés ou simulés. Parfait pour les scripts, tests automatisés, ou environnements d’entreprise.

Bonnes pratiques

Pour tirer le meilleur parti de curl, il est utile d’adopter quelques habitudes simples qui rendent vos commandes plus sûres, plus lisibles et plus réutilisables. Voici les conseils que j’applique personnellement dans mes scripts et tests.

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" ...

Et pour les autorisations :

curl -H "Authorization: Bearer VOTRE_TOKEN"

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" ...

Bien commenter ses commandes complexes

Un fichier curl.sh bien commenté est plus facile à maintenir qu’une suite de lignes obscures. Expliquez les paramètres importants avec des #.

Adopter ces bonnes pratiques permet d’utiliser curl de façon fiable, claire et sécurisée, que ce soit dans des scripts critiques, des tests d’API, ou des environnements automatisés.

Conclusion

Maîtriser la commande curl, c’est disposer d’un outil simple mais extrêmement puissant pour interagir avec le web, les APIs, ou des serveurs distants. Grâce à sa flexibilité et sa portabilité, elle s’intègre parfaitement dans les workflows d’administration, de test et d’automatisation. En ligne de commande comme en script, curl reste un incontournable du quotidien.