(🌐) Curl : la recette secrète pour automatiser vos requêtes web.

Partage

Interroger le web sans passer par le navigateur

Cliquer toujours au même endroit. Copier une information dans une page. La coller ailleurs. Recommencer. Puis recommencer encore.

Beaucoup de tâches numériques ressemblent à cela : une succession de petites actions simples, mais répétitives. Une fois, ce n’est rien. Dix fois, cela devient pénible. Cent fois, cela devient une perte de temps. Et quand il faut vérifier plusieurs pages, récupérer des données, tester une adresse, envoyer une requête ou contrôler la réponse d’un serveur, le navigateur atteint vite ses limites.

Le navigateur est un outil formidable, oui mais.

Le navigateur est un outil formidable pour lire, explorer, chercher, comparer, cliquer. Il est pensé pour les humains. Il affiche des boutons, des menus, des images, des animations, des messages. C’est confortable pour consulter une page web, mais ce n’est pas toujours idéal pour automatiser une action.

Quand on veut travailler vite, répéter une opération, intégrer une vérification dans un script ou récupérer une réponse précise, l’interface graphique devient parfois un détour. On n’a pas toujours besoin de voir toute la page. On veut simplement poser une question à un serveur et lire sa réponse.

C’est exactement là que curl devient intéressant.

curl est un outil en ligne de commande qui permet d’envoyer des requêtes web directement depuis un terminal. Au lieu d’ouvrir une page dans un navigateur, on interroge une adresse avec une commande. Le serveur répond, et cette réponse peut être lue, enregistrée, filtrée, testée ou utilisée dans un script.

Dit autrement, curl permet de dialoguer avec le web sans passer par les boutons et les fenêtres. C’est un peu le couteau suisse des requêtes HTTP : discret, léger, disponible presque partout, mais incroyablement puissant dès qu’on comprend sa logique.

On peut s’en servir pour vérifier qu’un site répond correctement, récupérer le contenu d’une page, tester une API, envoyer des données, contrôler des en-têtes HTTP, télécharger un fichier ou automatiser une série de vérifications. Une simple commande peut parfois remplacer plusieurs minutes de manipulations manuelles.

L’objectif de cet article n’est pas de transformer immédiatement tout le monde en administrateur système ou en développeur backend. L’idée est plus simple : comprendre pourquoi curl est utile, apprendre quelques commandes de base, puis voir comment cet outil peut devenir un allié très pratique pour automatiser des tâches web du quotidien.

En résumé : si le navigateur est la vitrine du web, curl est l’accès direct à l’atelier.

Les ingrédients de base : qu’est-ce que curl ?

Avant de l’utiliser, il faut démystifier curl. Derrière ce petit nom un peu étrange se cache un outil très simple dans son principe : il permet de transférer des données à partir d’une URL.

Concrètement, au lieu d’ouvrir une adresse dans un navigateur, on demande à curl d’aller interroger cette adresse depuis le terminal. Il envoie une requête, reçoit une réponse, puis l’affiche ou l’enregistre selon ce qu’on lui demande.

Son nom vient de Client URL. L’idée est donc bien celle d’un “client” capable de communiquer avec une adresse web. Dans la pratique, curl sait travailler avec de nombreux protocoles, mais dans cet article, on va surtout l’utiliser pour les requêtes web classiques, en HTTP ou HTTPS.

Curl est disponible

La première force de curl, c’est sa disponibilité. On le retrouve sur la plupart des systèmes Linux, sur macOS, et il est aussi présent sur les versions récentes de Windows. Autrement dit, il n’est pas réservé à une machine exotique ou à un environnement très spécialisé.

Sa deuxième force, c’est sa légèreté. curl ne charge pas une page complète avec ses images, ses scripts, ses styles, ses publicités et ses animations. Il va droit au but : une adresse, une requête, une réponse. Cela le rend très rapide et particulièrement pratique lorsqu’on veut tester ou récupérer une information précise.

Enfin, curl est un outil idéal pour les scripts. Une commande que l’on tape une fois dans un terminal peut ensuite être intégrée dans un script Bash, appelée depuis Python, utilisée dans un traitement PHP, ou combinée avec d’autres outils en ligne de commande.

C’est là que curl devient vraiment intéressant : il ne sert pas seulement à “voir” une page web. Il permet de vérifier, tester, envoyer, récupérer, comparer et automatiser des échanges avec un serveur.

En résumé, curl, c’est un peu la version sans décor du navigateur : pas de boutons, pas d’onglets, pas d’interface graphique, mais un accès direct à la réponse du serveur.

La recette de base : votre première requête en deux secondes

La meilleure façon de comprendre curl, c’est de l’essayer sur une commande très simple. Ouvrez un terminal et tapez :

curl https://site2wouf.fr

Cette commande demande à curl d’interroger l’adresse indiquée. Le serveur répond, et curl affiche directement le contenu reçu dans le terminal.

Dans ce cas précis, vous ne voyez pas une jolie page web comme dans un navigateur. Vous voyez plutôt le code HTML brut envoyé par le serveur. C’est normal : curl ne cherche pas à mettre en page le résultat. Il récupère la réponse.

C’est un peu le “Hello World” de curl : une adresse, une commande, une réponse.

Cette première commande montre déjà une différence importante avec le navigateur. Quand vous ouvrez une page web, le navigateur interprète le HTML, charge les images, applique les styles CSS, exécute parfois du JavaScript, puis affiche une page lisible. Avec curl, on reste au niveau de la matière première : la réponse envoyée par le serveur.

Enregistrez !

Afficher le résultat dans le terminal peut être utile pour un test rapide, mais ce n’est pas toujours pratique. Si la page contient beaucoup de code, votre écran va vite être rempli. Dans ce cas, il vaut mieux enregistrer le résultat dans un fichier.

Pour cela, on peut utiliser l’option -o, suivie du nom du fichier à créer :

curl -o page.html https://site2wouf.fr

Cette fois, le contenu récupéré n’est plus affiché dans le terminal. Il est enregistré dans un fichier nommé page.html. Vous pouvez ensuite ouvrir ce fichier, l’analyser, le comparer, ou l’utiliser dans un autre traitement.

Il existe aussi l’option -O, avec un O majuscule. Elle sert à conserver le nom du fichier distant lorsque l’URL pointe vers un vrai fichier téléchargeable.

curl -O https://site2wouf.fr/favicon.ico

La différence est donc simple :

-o page.html permet de choisir soi-même le nom du fichier créé ;
-O reprend le nom du fichier présent dans l’URL.

Dans un article, un script ou une vérification rapide, cette nuance est importante. Sans option, curl affiche la réponse. Avec -o ou -O, il l’enregistre.

À ce stade, on sait déjà faire quelque chose de très utile : interroger une adresse web et conserver sa réponse. C’est simple, mais c’est la base de beaucoup d’usages plus avancés.

Les épices et assaisonnements : maîtriser les requêtes avancées

Jusqu’ici, nous avons utilisé curl comme une simple louche : on récupère une page, on l’affiche ou on l’enregistre. C’est déjà pratique, mais ce n’est que le début.

La vraie puissance de curl apparaît quand on commence à modifier la requête envoyée au serveur. On ne se contente plus de demander une page. On peut envoyer des données, ajouter des informations dans les en-têtes, simuler un navigateur, inspecter la réponse ou vérifier rapidement l’état d’une URL.

Autrement dit, on passe des pâtes au beurre au plat trois étoiles.

Envoyer des données : simuler un formulaire avec POST

Quand vous remplissez un formulaire sur un site web, votre navigateur envoie des données au serveur. Par exemple : un nom, une adresse e-mail, un mot-clé de recherche, un identifiant ou un message.

Avec curl, on peut reproduire ce type d’envoi directement depuis le terminal grâce à l’option -d, ou sa version longue --data.

curl -X POST -d "nom=Wouf" -d "message=Bonjour" https://example.com/formulaire

Dans cette commande, on indique trois choses importantes :

-X POST précise que l’on veut envoyer une requête de type POST ;
-d "nom=Wouf" envoie une première donnée ;
-d "message=Bonjour" envoie une deuxième donnée.

Dans beaucoup de cas, curl comprend automatiquement qu’une requête contenant -d doit être envoyée en POST. On peut donc souvent écrire plus simplement :

curl -d "nom=Wouf" -d "message=Bonjour" https://example.com/formulaire

Cette écriture est très utile pour tester un formulaire, une API ou un point d’entrée côté serveur sans avoir à créer une page HTML complète.

On peut aussi envoyer des données au format JSON, ce qui est très fréquent avec les API modernes :

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"nom":"Wouf","message":"Bonjour"}' \
  https://example.com/api

Ici, l’option -H ajoute un en-tête HTTP. Elle indique au serveur que les données envoyées sont au format JSON. Sans cette information, certains serveurs ne sauront pas forcément comment interpréter le contenu reçu.

Changer d’identité : utiliser un User-Agent

Quand un navigateur contacte un site web, il ne se contente pas de demander une page. Il envoie aussi des informations sur lui-même. Parmi elles, on trouve le User-Agent, c’est-à-dire une chaîne de texte qui indique généralement le navigateur utilisé, le système d’exploitation, ou le type d’appareil.

Par défaut, curl annonce clairement qu’il est curl. Certains sites peuvent alors répondre différemment, limiter l’accès, ou bloquer la requête. Ce n’est pas forcément malveillant : certains serveurs sont configurés pour se protéger contre les robots, les abus ou les requêtes automatiques trop nombreuses.

Pour tester le comportement d’un site comme s’il était interrogé par un navigateur, on peut modifier le User-Agent avec l’option -A :

curl -A "Mozilla/5.0" https://site2wouf.fr

On peut être plus précis et utiliser une chaîne proche de celle d’un navigateur courant :

curl -A "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120 Safari/537.36" https://site2wouf.fr

Cette technique peut servir à diagnostiquer une différence de comportement entre une requête curl classique et une requête ressemblant davantage à celle d’un navigateur.

Il faut toutefois rester raisonnable : changer le User-Agent est utile pour tester, comprendre ou déboguer. Cela ne doit pas servir à contourner volontairement des protections, des conditions d’utilisation ou des limites mises en place par un site.

Inspecter les coulisses : lire uniquement les en-têtes HTTP

Parfois, on n’a pas besoin du contenu complet d’une page. On veut seulement savoir ce que le serveur répond en coulisses : la page existe-t-elle ? Le serveur renvoie-t-il une erreur ? Y a-t-il une redirection ? Quel type de contenu est annoncé ?

Pour cela, curl propose l’option -I, ou sa version longue --head. Elle permet de récupérer uniquement les en-têtes HTTP, sans télécharger tout le corps de la page.

curl -I https://site2wouf.fr

La réponse peut ressembler à ceci :

HTTP/2 200
content-type: text/html; charset=UTF-8
server: nginx
date: Wed, 10 Jun 2026 12:00:00 GMT

La première ligne est particulièrement importante. Elle contient le code de statut HTTP.

200 signifie que la page répond correctement ;
301 ou 302 indique une redirection ;
403 signifie que l’accès est interdit ;
404 indique que la ressource n’a pas été trouvée ;
500 signale une erreur côté serveur.

Cette commande est très pratique pour le débogage, mais aussi pour le SEO. Elle permet de vérifier rapidement si une page répond correctement, si une redirection est en place, ou si une URL renvoie une erreur.

Par exemple, pour vérifier une page précise :

curl -I https://site2wouf.fr/questions_flash.php

On peut aussi demander à curl de suivre les redirections avec l’option -L :

curl -I -L https://site2wouf.fr

L’option -L est utile lorsqu’une adresse redirige vers une autre. Sans elle, curl montre seulement la première réponse. Avec elle, il suit le chemin jusqu’à la destination finale.

Composer sa propre requête

L’intérêt de ces options, c’est qu’elles peuvent se combiner. On peut très bien envoyer une requête POST, préciser un User-Agent, ajouter un en-tête JSON, suivre les redirections et enregistrer la réponse dans un fichier.

curl -L \
  -A "Mozilla/5.0" \
  -H "Content-Type: application/json" \
  -d '{"recherche":"maths"}' \
  -o resultat.json \
  https://example.com/api/recherche

Cette commande peut sembler plus impressionnante, mais elle reste lisible si on la découpe :

-L suit les redirections ;
-A définit le User-Agent ;
-H ajoute un en-tête HTTP ;
-d envoie des données ;
-o resultat.json enregistre la réponse dans un fichier.

C’est exactement pour cela que curl est si apprécié. Chaque option ajoute une petite capacité, comme un assaisonnement. Seule, elle est simple. Combinée avec les autres, elle permet de construire des requêtes très précises.

À partir de là, curl n’est plus seulement un outil pour afficher le code HTML d’une page. Il devient un véritable instrument de test, de diagnostic et d’automatisation des échanges avec un serveur web.

🕵️‍♂️ Mission infiltration : Vérifier la présence d’une balise Title en un clin d’œil

C’est le cauchemar de tout blogueur ou spécialiste SEO : publier une page et oublier d’y configurer sa balise <title>. Pas besoin d’ouvrir votre navigateur, de faire un clic droit et d’inspecter le code source comme un archéologue. curl fait ça pour vous à la vitesse de l’éclair.

Pour tester votre site, ouvrez votre terminal et passez-lui cette commande bien assaisonnée :

curl -sL https://site2wouf.fr | grep -i "&lt;title>"

💡 Une petite précision pour nos amis sur Windows :
Si vous tentez de lancer cette commande depuis l’invite de commande classique de Windows (cmd), le terminal va ricaner en vous disant que grep est inconnu au bataillon. C’est normal, grep est un outil nativement taillé pour l’univers Linux et macOS.

Pas de panique, vous avez deux solutions très simples :

Utiliser la commande alternative sous PowerShell : curl -sL https://site2wouf.fr | Select-String "<title>".
Saisir l’occasion pour basculer du bon côté de la force (avec Git Bash ou WSL) ! J’ai d’ailleurs rédigé un guide complet à ce sujet : découvrez pourquoi grep est l’outil qui va vous faire regretter de ne pas être sur Linux.

La dissection de la recette :

curl -sL : On demande à curl d’agir en mode « silencieux » (-s pour Silent) pour masquer la barre de progression, et de suivre les redirections (-L) si votre site bascule automatiquement du HTTP au HTTPS.
| (le « Pipe ») : Ce caractère magique sert de passerelle. Il prend tout le code HTML récupéré par curl et l’envoie directement à la commande suivante, sans rien stocker sur votre disque.
grep -i "<title>" : grep joue les détectives et ne garde que la ligne qui contient notre balise. L’option -i permet d’ignorer la casse (que ce soit écrit <title> ou <TITLE>).

Le verdict :

Si tout va bien, le terminal vous recrachera instantanément la ligne de votre titre :

<title>Le titre incroyable de mon site web</title>

Si le terminal reste désespérément vide et vous rend la main sans rien afficher ? Alerte rouge, vous avez oublié votre balise !

Le chef en cuisine : quand curl entre dans un script

La commande précédente est déjà très pratique :

curl -sL https://site2wouf.fr | grep -i "&lt;title>"

Mais son vrai potentiel apparaît lorsqu’on arrête de la taper à la main. Une commande utile peut devenir une petite recette que l’on garde dans un fichier, que l’on relance quand on veut, puis que l’on peut même programmer pour s’exécuter automatiquement.

C’est ici que curl cesse d’être seulement un outil de test rapide. Il devient une brique d’automatisation.

Transformer une commande en mini-script

Commençons par reprendre notre vérification de balise <title>, mais en la plaçant dans un fichier Bash.

#!/bin/bash

URL="https://site2wouf.fr"

echo "Vérification de la balise title pour : $URL"

curl -sL "$URL" | grep -i "&lt;title>"

Ce script ne fait rien de magique. Il stocke simplement l’adresse du site dans une variable, puis lance la commande curl associée à grep. L’intérêt, c’est que l’on peut maintenant modifier l’URL à un seul endroit, réutiliser le fichier, ou l’enrichir progressivement.

On peut l’enregistrer sous le nom check_title.sh, puis le rendre exécutable :

chmod +x check_title.sh

Ensuite, il suffit de le lancer :

./check_title.sh

Vérifier si une page répond correctement

Autre usage très simple : vérifier si une page répond avec un code HTTP correct. Cette fois, on ne veut pas afficher tout le HTML. On veut seulement connaître le statut de la réponse.

#!/bin/bash

URL="https://site2wouf.fr"

CODE=$(curl -s -o /dev/null -w "%{http_code}" "$URL")

if [ "$CODE" = "200" ]; then
  echo "OK : $URL répond correctement."
else
  echo "Attention : $URL répond avec le code $CODE."
fi

Cette ligne est très compacte, mais elle est précieuse :

-s masque les informations inutiles ;
-o /dev/null ignore le contenu de la page ;
-w "%{http_code}" demande uniquement le code HTTP.

On obtient ainsi une petite vérification maison. Ce n’est pas une solution de monitoring professionnelle, mais pour contrôler rapidement une page importante, c’est déjà très efficace.

Garder une trace dans un fichier de log

Un script devient plus utile lorsqu’il garde une trace de ce qu’il fait. On peut donc ajouter une ligne dans un fichier de log à chaque vérification.

#!/bin/bash

URL="https://site2wouf.fr"
LOG="$HOME/check_site.log"

CODE=$(curl -s -o /dev/null -w "%{http_code}" "$URL")

if [ "$CODE" = "200" ]; then
  echo "$(date '+%Y-%m-%d %H:%M:%S') - OK : $URL répond correctement." >> "$LOG"
else
  echo "$(date '+%Y-%m-%d %H:%M:%S') - Attention : $URL répond avec le code $CODE." >> "$LOG"
fi

Le symbole >> ajoute une ligne à la fin du fichier, sans effacer ce qui existait déjà. Petit à petit, on obtient donc un historique des vérifications.

2026-06-10 22:00:01 - OK : https://site2wouf.fr répond correctement.
2026-06-10 23:00:01 - OK : https://site2wouf.fr répond correctement.
2026-06-11 00:00:01 - Attention : https://site2wouf.fr répond avec le code 500.

Télécharger automatiquement un fichier

curl peut aussi servir à récupérer automatiquement un fichier : une archive, une image, un export CSV, un fichier JSON ou une sauvegarde.

Par exemple, pour télécharger une icône depuis un site et l’enregistrer dans un dossier local :

#!/bin/bash

URL="https://site2wouf.fr/favicon.ico"
DOSSIER="$HOME/telechargements_curl"
FICHIER="$DOSSIER/favicon.ico"

mkdir -p "$DOSSIER"

curl -L -o "$FICHIER" "$URL"

echo "Fichier enregistré dans : $FICHIER"

Dans cette recette, mkdir -p crée le dossier s’il n’existe pas, puis curl -L -o télécharge le fichier en suivant les éventuelles redirections.

Le même principe peut être adapté à un fichier dont le nom change chaque jour. On fabrique alors la date automatiquement :

#!/bin/bash

DATE=$(date '+%Y-%m-%d')
URL="https://example.com/sauvegardes/archive-$DATE.zip"
DEST="$HOME/sauvegardes/archive-$DATE.zip"

mkdir -p "$HOME/sauvegardes"

curl -L -o "$DEST" "$URL"

Ce type de script devient intéressant dès qu’une tâche se répète : récupérer un fichier quotidien, vérifier une page, archiver une réponse ou contrôler un export.

Programmer la recette avec cron

Dernière étape : ne plus lancer le script soi-même. Sous Linux, l’outil classique pour cela s’appelle cron. Il permet de planifier une commande à heure fixe.

Pour ouvrir la table de planification de l’utilisateur :

crontab -e

Et pour exécuter un script tous les jours à 7 h, on peut ajouter :

0 7 * * * /home/laurent/check_site.sh

Enfin pour lancer un téléchargement automatique toutes les nuits à 2 h 30 :

30 2 * * * /home/laurent/telecharge_fichier.sh

Et pour conserver une trace de ce que fait le script, on peut rediriger sa sortie vers un fichier de log :

30 2 * * * /home/laurent/telecharge_fichier.sh >> /home/laurent/cron_curl.log 2>&amp;1

Cette fin de ligne est très utile : elle enregistre à la fois les messages normaux et les erreurs éventuelles. Sans cela, un script lancé automatiquement peut échouer discrètement, sans laisser d’indice visible.

La vraie force de curl

À ce stade, on voit mieux pourquoi curl est si précieux. Une commande isolée permet de tester mais une commande dans un script permet de répéter. Une commande planifiée avec cron permet d’automatiser.

La recette tient donc en trois ingrédients :

curl pour interroger le web ;
un script pour organiser la tâche ;
cron pour la lancer automatiquement.

Le navigateur reste parfait pour explorer une page. Mais pour une action répétitive, une vérification régulière ou un téléchargement planifié, une petite ligne de commande peut devenir beaucoup plus efficace.

Conclusion : une petite commande pour reprendre la main

curl peut sembler austère au premier contact. Une commande dans un terminal, des options avec des tirets, des réponses en texte brut : on est loin du confort visuel d’un navigateur moderne.

Et pourtant, c’est précisément ce qui fait sa force. curl va droit au but. Il interroge une URL, récupère une réponse, envoie des données, teste des en-têtes, télécharge un fichier ou s’intègre dans un script sans demander d’interface graphique.

Ce n’est donc pas seulement un outil réservé aux administrateurs système en pull noir, cachés derrière trois écrans et une cafetière fatiguée. C’est aussi un outil d’émancipation numérique pour toutes celles et ceux qui veulent comprendre ce qui circule entre leur machine et le web.

Avec quelques commandes bien choisies, on peut gagner du temps, éviter des clics répétitifs, vérifier rapidement une page, automatiser une tâche simple ou construire une petite routine utile. Pas besoin de tout maîtriser d’un coup : une seule commande bien comprise peut déjà changer la manière de travailler.

Le navigateur reste indispensable pour lire, explorer et interagir confortablement avec les sites. Mais dès qu’une action devient répétitive, testable ou planifiable, curl mérite sa place dans la boîte à outils.

Alors, à vous de jouer : quelle est la première tâche répétitive que vous pourriez confier à curl ? Une vérification de page ? Un téléchargement régulier ? Un contrôle SEO ? Un petit script de surveillance maison ?