En-têtes de réponse HTTP dans cURL : Tous les drapeaux, techniques et recettes de script

Les en-têtes de réponse HTTP sont les métadonnées qu'un serveur renvoie avec chaque réponse, couvrant tout, du type de contenu et des politiques de mise en cache aux compteurs de limitation de débit et aux directives de sécurité. Lorsque vous déboguez une API instable, que vous vérifiez qu'un CDN sert les bons en-têtes de cache ou que vous vérifiez si un site définit la bonne politique CORS, le premier outil vers lequel se tournent la plupart des développeurs est cURL.

Par défaut, cURL n'affiche que le corps de la réponse sur stdout, ce qui signifie que vous devez demander explicitement les en-têtes de réponse HTTP dans cURL avant de pouvoir les voir. La difficulté réside dans le fait que cURL propose au moins une demi-douzaine de drapeaux et de techniques pour afficher ces en-têtes, et que chacun d'entre eux est optimisé pour un flux de travail différent. Devriez-vous opter pour -i, -I, -v, ou -D? Qu'en est-il des nouvelles -w qui vous permettent d'extraire un seul en-tête par son nom ou d'exporter tous les en-têtes au format JSON ?

Ce guide passe en revue toutes les approches permettant de visualiser les en-têtes de réponse HTTP dans cURL, de la ligne de commande la plus simple aux recettes de scripts adaptées à l'automatisation, afin que vous puissiez choisir l'outil le mieux adapté à la tâche sans avoir à mémoriser chaque section de la page de manuel.

Chaque réponse HTTP comporte un ensemble d'en-têtes qui indiquent au client comment interpréter la charge utile. Un Content-Type en-tête qui indique application/json signifie une chose ; text/html en signifie une autre. Au-delà des bases, les en-têtes révèlent le comportement de mise en cache (Cache-Control, ETag), les exigences d'authentification (WWW-Authenticate), l'état de la limitation de débit (X-RateLimit-Remaining) et les politiques de sécurité (Strict-Transport-Security, Content-Security-Policy).

Pour les praticiens du web scraping, les en-têtes de réponse sont particulièrement révélateurs. Ils peuvent vous indiquer si un serveur compresse ses réponses, si vos requêtes sont redirigées via une chaîne d'URL intermédiaires, ou si vous êtes sur le point d'atteindre une limite de débit. C'est pourquoi apprendre à inspecter rapidement et précisément les en-têtes de réponse HTTP dans cURL est une compétence fondamentale pour toute personne travaillant avec HTTP en ligne de commande.

Avant de passer aux exemples, voici un tableau comparatif que vous pouvez ajouter à vos favoris. Il associe chaque indicateur à son comportement et au scénario dans lequel il est le plus utile lorsque vous devez afficher les en-têtes de réponse HTTP dans cURL.

Sélectionnez la ligne qui correspond à votre workflow, puis consultez la section correspondante ci-dessous pour obtenir des détails et des exemples.

La manière la plus simple de voir les en-têtes de réponse HTTP dans cURL est d'utiliser le -i (forme longue : --include). Il indique à cURL d'ajouter l'ensemble complet des en-têtes de réponse au début de la sortie du corps, séparés par une ligne vide.

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

La sortie commence par la ligne d'état (HTTP/1.1 200 OK), suivie de chaque en-tête sur une ligne distincte, puis d'une ligne vide, et enfin du corps de la réponse. Il s'agit d'une requête GET, et non d'une requête HEAD, vous obtenez donc la réponse réelle que le serveur renverrait à un navigateur.

Utilisez -i lorsque vous souhaitez consulter rapidement à la fois les en-têtes et le corps en une seule commande de terminal. L'inconvénient est que les en-têtes et le corps sont mélangés en un seul flux, ce qui rend leur analyse par programmation plus difficile. Pour les scripts, l'une des techniques suivantes (comme -D ou -w) est généralement plus adaptée.

Lorsque vous n'avez besoin que des en-têtes et que le corps ne vous intéresse pas du tout, utilisez -I (ou sa forme longue équivalente, --head). Ces deux options envoient une requête HTTP HEAD, qui demande au serveur uniquement les en-têtes.

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

La sortie se limite à la ligne d'état et aux en-têtes. Pas de corps, pas de bruit parasite. La --head s'écrit de la même manière mais se lit plus clairement dans les scripts shell, rendant votre intention évidente pour toute personne qui examine le code.

Une mise en garde : une réponse HEAD n’est pas toujours identique à une réponse GET. Certains serveurs renvoient des en-têtes différents (ou omettent complètement certains en-têtes) pour les requêtes HEAD. Si vous effectuez un dépannage sur un en-tête qui n’apparaît que sur une véritable requête GET, ce drapeau vous induira en erreur.

La solution consiste à utiliser la -s -o /dev/null -D - technique, qui envoie une requête GET complète mais ignore le corps et affiche uniquement les en-têtes de réponse sur stdout :

curl -s -o /dev/null -D - https://httpbin.org/get

Voici ce que fait chaque élément : -s désactive la barre de progression, -o /dev/null envoie le corps nulle part, et -D - écrit les en-têtes vers stdout (le tiret signifie « stdout » au lieu d'un nom de fichier). Cela vous donne les en-têtes GET réels sans le bruit du corps, et c'est un modèle essentiel lorsque vous avez besoin d'en-têtes de réponse HTTP précis dans cURL mais que HEAD n'est pas fiable.

Le mode verbose est le couteau suisse du débogage HTTP. Le -v (ou --verbose) force cURL à afficher la transaction complète : détails de la négociation TLS, en-têtes de requête, en-têtes de réponse et corps.

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

Dans la sortie, les lignes préfixées par > sont les en-têtes de requête envoyés par votre client, les lignes préfixées par < sont les en-têtes de réponse renvoyés par le serveur, et les lignes préfixées par * sont des messages d'information provenant de cURL lui-même (informations de connexion, négociation TLS, etc.).

Pour réduire le bruit, combinez -v avec -s pour masquer la barre de progression. Si vous souhaitez capturer uniquement les lignes d'en-tête d'une sortie détaillée dans un script, vous pouvez rediriger stderr (où -v écrit ses informations de débogage) et de filtrer :

curl -vs https://httpbin.org/get 2>&1 | grep '^<'

Cela redirige à la fois stdout et stderr, puis ne conserve que les lignes commençant par <, vous offrant ainsi une liste claire des en-têtes de réponse issues de la sortie détaillée de cURL. C'est idéal pour un débogage ponctuel rapide, mais pour les scripts de production, vous préférerez les approches plus structurées abordées ci-après.

Le -D (abréviation de --dump-header) écrit les en-têtes de réponse dans un fichier au lieu de les afficher sur stdout. Combinez-le avec -o pour enregistrer le corps séparément :

curl -D headers.txt -o body.html https://example.com

Une fois cette opération effectuée, headers.txt contient tous les en-têtes de réponse et body.html contient le contenu de la page. C'est idéal pour la journalisation, lorsque vous souhaitez archiver les en-têtes et le corps côte à côte pour une consultation ultérieure.

Pour la journalisation horodatée (utile dans les scripts de surveillance), générez le nom de fichier de manière dynamique :

curl -D "headers_$(date +%Y%m%d_%H%M%S).txt" -o /dev/null https://example.com

Chaque exécution crée un nouveau fichier tel que headers_20240615_143022.txt, ce qui vous permet de suivre l'évolution des en-têtes de réponse HTTP dans cURL au fil du temps. Associez cela à une tâche cron et vous disposez d'un outil de surveillance des en-têtes léger, sans aucun outil tiers.

Parfois, un seul en-tête vous intéresse, comme Content-Type ou X-RateLimit-Remaining. Rediriger la sortie de cURL vers des outils Unix standard vous permet d'y parvenir rapidement.

Extrayez un en-tête unique par son nom avec grep (sans distinction de casse) :

curl -sI https://httpbin.org/get | grep -i "content-type"

Pour isoler uniquement la valeur (sans le nom de l'en-tête), ajoutez cut ou awk:

curl -sI https://httpbin.org/get | grep -i "content-type" | cut -d':' -f2- | xargs

La cut commande sépare au niveau du deux-points et conserve tout ce qui suit, tandis que xargs supprime les espaces autour. Sinon, awk vous pouvez le faire en une seule fois :

curl -sI https://httpbin.org/get | awk -F': ' '/^[Cc]ontent-[Tt]ype/ {print $2}'

Attention aux correspondances partielles de noms. Une recherche avec Content renverrait également Content-Length, Content-Encodinget tout autre élément commençant de la même manière. Recherchez toujours le nom complet de l'en-tête suivi d'un deux-points pour éviter les faux positifs.

À partir de la version 7.83 environ (publiée début 2022), cURL a introduit deux variables de sortie qui simplifient l'extraction des en-têtes de réponse HTTP dans les scripts cURL : %header{name} pour un en-tête unique et %{header_json} pour tous les en-têtes au format JSON.

Extrayez un en-tête proprement, sans avoir besoin de grep :

curl -s -o /dev/null -w '%header{content-type}' https://httpbin.org/get

Cela affiche uniquement la valeur de l' Content-Type en-tête. Pas d'analyse syntaxique, pas de pipes, pas d'expressions régulières.

Pour obtenir tous les en-têtes de réponse sous forme d'objet JSON, utilisez :

curl -s -o /dev/null -w '%{header_json}' https://httpbin.org/get

La sortie est un JSON valide, ce qui signifie que vous pouvez la rediriger directement vers jq pour un affichage formaté ou l'extraction de champs :

curl -s -o /dev/null -w '%{header_json}' https://httpbin.org/get | jq '.["content-type"]'

Lorsque des noms d'en-têtes en double apparaissent (comme plusieurs Set-Cookie en-têtes), cURL les regroupe dès la première occurrence et rassemble toutes les valeurs dans un tableau JSON, afin que vous ne perdiez jamais de données.

Remarque importante : ces variables de sortie nécessitent cURL 7.83 ou une version ultérieure. Exécutez curl --version pour vérifier la vôtre. Si vous utilisez une version plus ancienne, l' grep/awk approche de la section précédente reste votre meilleure option.

Une fois que vous pouvez extraire les en-têtes de réponse HTTP dans cURL, l'étape suivante consiste à créer des workflows reproductibles autour d'eux. Voici trois modèles qui fonctionnent bien pour l'audit des en-têtes à grande échelle.

Auditer un en-tête spécifique sur plusieurs URL :

while IFS= read -r url; do
  val=$(curl -s -o /dev/null -w '%header{strict-transport-security}' "$url")
  echo "$url → $val"
done < urls.txt

Importez un fichier d'URL et obtenez un rapport rapide indiquant celles qui définissent l' Strict-Transport-Security en-tête.

Surveiller les changements d'en-tête au fil du temps avec diff :

curl -sI https://example.com > /tmp/headers_prev.txt
# ... wait, or run via cron ...
curl -sI https://example.com > /tmp/headers_now.txt
diff /tmp/headers_prev.txt /tmp/headers_now.txt

Intégrez cette opération dans une tâche cron et envoyez le résultat de la comparaison vers un webhook Slack ou par e-mail. C'est un moyen simple de détecter les modifications de configuration inattendues.

Créez un alias shell pour les vérifications fréquentes :

alias hcheck='curl -s -o /dev/null -D - -w "\n"'

Vous pouvez désormais taper hcheck https://example.com pour extraire rapidement les en-têtes de réponse de n'importe quelle URL à l'aide d'une requête GET standard.

Même les inspections d'en-têtes les plus simples peuvent mal tourner. Vous trouverez ci-dessous trois situations que vous êtes susceptible de rencontrer lorsque vous travaillez avec des en-têtes de réponse HTTP dans cURL, ainsi que les options permettant de les résoudre.

Si cURL refuse de se connecter en raison d'un problème de certificat, vous pouvez contourner la vérification avec -k (ou --insecure):

curl -kI https://self-signed.example.com

N'utilisez cette option que dans des environnements de développement ou de test interne. En production, la meilleure solution consiste à fournir le bon ensemble de certificats CA avec --cacert /path/to/ca-bundle.crt afin que la connexion soit bel et bien vérifiée.

Par défaut, cURL ne suit pas les redirections. Si une URL renvoie un code 301 ou 302, vous ne voyez que les en-têtes de la réponse initiale. Ajoutez -L (ou --location) pour suivre la chaîne :

curl -LI https://example.com

Pour capturer les en-têtes à chaque étape (et pas seulement à la destination finale), combinez -L avec -D:

curl -L -D all_headers.txt -o /dev/null https://example.com

Le fichier all_headers.txt contiendra les blocs d'en-tête de chaque redirection, séparés par des lignes vides. Vous pouvez également définir --max-redirs 5 pour limiter le nombre de sauts et éviter les boucles infinies.

De nombreux serveurs compressent les réponses avec gzip ou Brotli, ce qui peut donner un aspect indéchiffrable au corps brut de la réponse. L' --compressed indicateur demande à cURL d'envoyer l'en-tête approprié Accept-Encoding et de décompresser automatiquement la réponse :

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

Cela ne modifie pas les en-têtes eux-mêmes, mais cela garantit que vous pouvez lire le corps en même temps qu'eux. Si vous inspectez uniquement les en-têtes, la compression n'est pas un problème, mais elle a son importance lorsque vous combinez -i pour les consulter tous les deux.

• Utilisez -i pour des vérifications visuelles rapides qui affichent les en-têtes de réponse en ligne avec le corps, et -I lorsque vous n'avez besoin que des en-têtes d'une requête HEAD.
• Le -s -o /dev/null -D - modèle est indispensable lorsque les réponses HEAD diffèrent de celles de GET : il vous fournit les véritables en-têtes GET sans le bruit du corps.
• Le mode Verbose (-v) est l'outil le plus complet de votre arsenal, affichant les en-têtes de requête, les en-têtes de réponse et les détails TLS en un seul coup d'œil.
• Variables de sortie de cURL 7.83+ (%header{name} et %{header_json}) éliminent le besoin de pipelines grep/awk et s'intègrent parfaitement aux workflows basés sur JSON.
• Combinez -L avec -D pour capturer les en-têtes à chaque étape de redirection, et vérifiez toujours votre version de cURL avant de vous fier aux nouvelles fonctionnalités.

curl -i Envoie une requête GET standard et inclut les en-têtes de réponse au-dessus du corps dans la sortie. curl -I Envoie une requête HEAD, qui renvoie uniquement les en-têtes sans aucun corps. La version en minuscules -i vous donne la réponse complète ; la majuscule -I est plus rapide mais peut renvoyer des en-têtes différents de ceux d'une véritable requête GET sur certains serveurs.

Utilisez la -w '%{header_json}' variable write-out, disponible dans cURL 7.83 et versions ultérieures. Exécutez curl -s -o /dev/null -w '%{header_json}' <URL> pour obtenir un objet JSON valide contenant tous les en-têtes. Redirigez le résultat vers jq pour un affichage formaté ou l'extraction de champs. Les en-têtes en double sont automatiquement regroupés dans des tableaux JSON.

Sous Windows, curl dans PowerShell est un alias de Invoke-WebRequest. Exécutez (Invoke-WebRequest -Uri "https://example.com" -Method Head).Headers pour afficher une table de hachage des en-têtes de réponse. Si vous souhaitez utiliser le binaire cURL proprement dit, appelez curl.exe -I https://example.com pour contourner l'alias et utiliser les mêmes indicateurs que ceux décrits dans ce guide.

Combinez -L (suivre les redirections) avec -D (afficher les en-têtes) comme ceci : curl -L -D headers.txt -o /dev/null https://example.com. Le fichier obtenu contiendra des blocs d'en-têtes distincts pour chaque étape de redirection, délimités par des lignes vides. Vous pouvez également utiliser curl -Lv pour afficher les en-têtes de chaque étape en temps réel sur stderr.

L'inspection des en-têtes de réponse HTTP dans cURL est l'une de ces compétences qui s'avère utile au quotidien une fois que vous la maîtrisez. Pour des vérifications rapides, -i et -I vous permettent d'y parvenir en une seule commande. Lorsque vous avez besoin d'une visibilité plus approfondie, -v affiche la transaction complète et -D vous permet de consigner les en-têtes dans des fichiers pour une analyse ultérieure. Et si vous construisez des pipelines automatisés, les nouvelles -w variables d'écriture (disponibles dans cURL 7.83+) vous permettent d'extraire les en-têtes sous forme de JSON propre sans aucune manipulation complexe de traitement de texte.

La clé est d'associer le bon indicateur à la tâche. Utilisez le tableau de référence rapide de ce guide comme aide-mémoire et inspirez-vous des exemples de scripts pour transformer des commandes ponctuelles en vérifications reproductibles.

Si vos scripts cURL se heurtent à des protections anti-bot, des CAPTCHA ou des blocages d'IP avant même que vous ne puissiez inspecter les en-têtes, WebScrapingAPI peut gérer la couche de requêtes à votre place, en gérant la rotation des proxys et le contournement des blocages derrière un seul point de terminaison API, afin que vous puissiez vous concentrer sur les données plutôt que sur l'infrastructure.