Aide-mémoire curl : 40+ exemples de commandes HTTP et API

Vous êtes à trois sauts SSH de profondeur sur une machine de staging, une API renvoie quelque chose d’incorrect, et le seul client HTTP installé est curl. Ou bien vous lisez un script de CI qui vérifie l’état de santé d’un service et vous voulez savoir ce que fait réellement -fsS. Ou encore, un collègue a collé une ligne de commande dans Slack et vous devez l’adapter. curl est partout, et ses options sont assez laconiques pour que personne ne les retienne toutes.

Cet aide-mémoire curl est conçu précisément pour ces moments-là. Vous obtenez un tableau de référence rapide regroupant la douzaine d’options que vous utilisez au quotidien, puis des exemples de commandes prêtes à copier pour chaque tâche courante : requêtes GET et POST, envoi d’en-têtes, authentification par token Bearer, upload et download de fichiers, et tests d’API dans des scripts. Chaque commande utilise une URL réelle et exécutable (httpbin.org ou un placeholder api.example.com), pour que vous puissiez la coller et l’essayer. Le comportement décrit s’appuie sur la documentation officielle de curl et sur la RFC 9110, la norme actuelle de sémantique HTTP.

Référence rapide : les options curl que vous utiliserez vraiment

Quatre-vingt-dix pour cent de l’usage quotidien de curl tient dans une douzaine d’options. Mettez ce tableau en favori ; le reste du guide détaille chacune d’elles avec des exemples de commandes curl exécutables.

Option	Signification	Exemple
`-X`	Définir la méthode HTTP	`curl -X DELETE https://api.example.com/items/42`
`-H`	Ajouter un en-tête de requête (répétable)	`curl -H "Accept: application/json" https://httpbin.org/get`
`-d`	Envoyer un corps de requête (implique POST)	`curl -d "name=alice" https://httpbin.org/post`
`--json`	Envoyer un corps JSON + définir les en-têtes JSON	`curl --json '{"id":1}' https://httpbin.org/post`
`-F`	Envoyer un champ/fichier de formulaire multipart	`curl -F "file=@report.pdf" https://httpbin.org/post`
`-o`	Enregistrer la sortie sous un nom de fichier choisi	`curl -o page.html https://example.com`
`-O`	Enregistrer en utilisant le nom de fichier distant	`curl -O https://example.com/archive.zip`
`-L`	Suivre les redirections	`curl -L https://httpbin.org/redirect/2`
`-u`	Auth basique `user:pass`	`curl -u alice:s3cret https://httpbin.org/basic-auth/alice/s3cret`
`-i`	Inclure les en-têtes de réponse dans la sortie	`curl -i https://httpbin.org/get`
`-I`	Récupérer uniquement les en-têtes (HEAD)	`curl -I https://example.com`
`-v`	Verbeux : afficher la requête + le handshake TLS	`curl -v https://example.com`
`-s`	Silencieux (pas de barre de progression)	`curl -s https://httpbin.org/get`
`-w`	Écrire des variables après le transfert	`curl -s -o /dev/null -w "%{http_code}" https://example.com`
`-b`	Envoyer des cookies (chaîne ou fichier)	`curl -b cookies.txt https://httpbin.org/cookies`
`-c`	Enregistrer les cookies reçus dans un jar	`curl -c cookies.txt https://httpbin.org/cookies/set/a/1`
`-k`	Ignorer la vérification du certificat TLS	`curl -k https://self-signed.example.com`
`--http2`	Demander HTTP/2	`curl --http2 https://example.com`
`--http3`	Demander HTTP/3 (QUIC)	`curl --http3 https://example.com`
`-T`	Uploader un fichier avec PUT	`curl -T backup.tar https://api.example.com/files/backup.tar`
`--data-urlencode`	URL-encoder un champ du corps	`curl --data-urlencode "q=hello world" https://httpbin.org/get -G`
`--max-time`	Limite la durée totale du transfert (secondes)	`curl --max-time 10 https://example.com`
`--connect-timeout`	Limite l’établissement de la connexion (secondes)	`curl --connect-timeout 5 https://example.com`
`--retry`	Réessaie un transfert échoué N fois	`curl --retry 3 https://example.com`
`--limit-rate`	Limite la bande passante du transfert	`curl --limit-rate 2M -O https://example.com/big.iso`

Les bases de la syntaxe curl : anatomie d’une requête

Une commande curl, c’est le binaire, quelques options et une URL. L’URL peut venir avant ou après les options ; curl ne se soucie pas de l’ordre. Ce qui compte, en revanche, c’est de savoir quelles options impliquent une méthode ou un corps, car ces éléments interagissent entre eux.

Une simple requête GET

Sans option de méthode, curl envoie un GET. Voici la commande entière :

curl https://httpbin.org/get

httpbin vous renvoie votre requête en écho sous forme de JSON, ce qui en fait un terrain de test idéal. Ajoutez une chaîne de requête de la même manière que vous le feriez dans un navigateur :

curl "https://httpbin.org/get?page=2&sort=desc"

Mettez l’URL entre guillemets. Un & non protégé indique à votre shell de passer la commande en arrière-plan et supprime silencieusement tout ce qui suit — l’une des erreurs curl les plus courantes, traitée dans la section sur les pièges plus bas.

Voir la réponse : corps, en-têtes, ou les deux

Par défaut, curl n’affiche que le corps de la réponse. Trois options modifient ce que vous voyez :

# Corps + ligne de statut + en-têtes de réponse
curl -i https://httpbin.org/get

# En-têtes uniquement — envoie une requête HEAD, sans corps
curl -I https://example.com

# Trace complète : ligne de requête, en-têtes de requête, handshake TLS, réponse
curl -v https://example.com

Utilisez -i quand vous voulez le corps plus un coup d’œil rapide sur Content-Type ou un Set-Cookie. Utilisez -I pour inspecter une ressource sans la télécharger (taille du fichier, date de dernière modification, cible de redirection). Sortez -v quand quelque chose ne va pas et que vous devez voir exactement ce que curl a envoyé.

Suivre les redirections

curl ne suit pas les redirections sauf si vous le lui demandez. Atteignez une URL qui renvoie 301 ou 302 sans -L et vous obtenez la réponse de redirection elle-même, pas la destination :

# S'arrête au 302, n'affiche rien d'utile
curl https://httpbin.org/redirect/1

# Suit la chaîne jusqu'au 200 final
curl -L https://httpbin.org/redirect/1

Si vous ne savez pas pourquoi une requête atterrit là où elle atterrit, -IL affiche le code de statut de chaque saut. Pour savoir ce que signifie chacun de ces codes — et pourquoi 301 et 302 ne sont pas interchangeables — consultez l’aide-mémoire des codes HTTP.

Les méthodes HTTP avec curl (GET, POST, PUT, PATCH, DELETE)

curl choisit la méthode automatiquement en fonction de vos options : -d ou --json implique POST, une URL simple implique GET. N’utilisez -X que lorsque vous avez besoin d’une méthode qui ne correspond pas au corps que vous envoyez.

GET avec des paramètres de requête

Construire une chaîne de requête à la main devient source d’erreurs dès que les valeurs contiennent des espaces ou des &. L’option -G indique à curl d’ajouter les champs --data-urlencode à l’URL sous forme de chaîne de requête correctement encodée :

curl -G https://httpbin.org/get \
  --data-urlencode "q=hello world" \
  --data-urlencode "tag=c++"

Cela produit ?q=hello%20world&tag=c%2B%2B — curl gère le pourcentage-encodage pour que vous ne transmettiez pas une URL cassée.

POST : données de formulaire ou JSON

Une requête POST avec curl prend deux formes courantes. Encodage de formulaire (le corps classique des formulaires HTML) :

curl -d "name=alice&role=admin" https://httpbin.org/post

-d définit Content-Type: application/x-www-form-urlencoded et bascule la méthode sur POST à votre place. Pour une API JSON, envoyez plutôt du JSON :

curl -d '{"name":"alice","role":"admin"}' \
  -H "Content-Type: application/json" \
  https://httpbin.org/post

Il existe une manière plus propre de faire cela, présentée dans la section suivante.

PUT et PATCH

PUT remplace une ressource ; PATCH en met à jour une partie. PUT est idempotent — l’envoyer deux fois laisse le même état.

# Remplacer la ressource entière
curl -X PUT -d '{"name":"alice","role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

# Mettre à jour un seul champ
curl -X PATCH -d '{"role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

DELETE

DELETE ne transporte généralement aucun corps, donc -X suffit :

curl -X DELETE https://api.example.com/users/7

Envoyer des en-têtes et des corps JSON

L’essentiel du travail réel sur les API tient dans les en-têtes et le JSON. Deux options portent tout le poids : -H et --json.

En-têtes curl personnalisés avec `-H`

-H ajoute un en-tête et peut être répété autant de fois que nécessaire. C’est ainsi que vous définissez Accept, Authorization, des en-têtes X- personnalisés et des identifiants de requête :

curl https://httpbin.org/headers \
  -H "Accept: application/json" \
  -H "X-Request-Id: 9f3c1a" \
  -H "User-Agent: my-cli/1.0"

Pour supprimer un en-tête par défaut que curl enverrait sinon, donnez-lui une valeur vide (-H "User-Agent:"). Pour envoyer un en-tête sans valeur, utilisez un point-virgule (-H "X-Empty;").

POST JSON : `-d` face à la moderne option `--json`

Depuis curl 7.82, --json est la manière idiomatique d’envoyer une requête POST JSON avec curl. Elle fait trois choses à la fois : elle définit Content-Type: application/json, définit Accept: application/json et envoie le corps tel quel.

# Verbeux, à l'ancienne — trois éléments à garder synchronisés
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name":"alice"}' \
  https://httpbin.org/post

# Équivalent moderne
curl --json '{"name":"alice"}' https://httpbin.org/post

--json est répétable et se concatène, et --json @file.json lit le corps depuis un fichier. Privilégiez-la pour toute API JSON.

Content-Type et Accept

Ces deux en-têtes sont à l’origine des erreurs 415 et 406. Content-Type décrit le corps que vous envoyez ; Accept indique ce que vous voulez recevoir. Envoyez du JSON à un endpoint qui n’accepte que des données de formulaire et vous obtenez 415 Unsupported Media Type. Demandez du XML à une API uniquement JSON et vous obtiendrez peut-être 406 Not Acceptable. (Ces codes sont décortiqués dans le guide des codes HTTP.)

Lorsque la réponse revient sous forme d’un mur de JSON minifié, formatez-le joliment avec le Formateur JSON, ou redirigez-le directement vers jq pour en extraire un champ :

curl -s https://httpbin.org/json | jq '.slideshow.title'

Pour l’ensemble complet des filtres jq — sélectionner, mapper et remodeler les réponses d’API — consultez l’Aide-mémoire jq.

L’authentification avec curl

Quatre styles d’authentification couvrent presque toutes les API : auth basique, tokens Bearer, clés d’API et cookies.

Auth basique (`-u user:pass`)

-u envoie un en-tête HTTP Authorization: Basic avec vos identifiants encodés en Base64 :

curl -u alice:s3cret https://httpbin.org/basic-auth/alice/s3cret

Omettez le mot de passe (-u alice) et curl vous le demande, le tenant ainsi à l’écart de l’historique de votre shell.

Tokens Bearer et OAuth

La plupart des API modernes utilisent un token Bearer avec curl : un token d’accès OAuth 2.0 ou un token d’API dans l’en-tête Authorization. curl dispose d’un raccourci, --oauth2-bearer, équivalent à écrire l’en-tête à la main :

# En-tête explicite
curl -H "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.abc" \
  https://api.example.com/me

# Raccourci
curl --oauth2-bearer "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.abc" \
  https://api.example.com/me

Si le backend rejette le token, décodez-le avec le Décodeur JWT pour vérifier les claims exp (expiration), aud (audience) et iss (issuer) avant d’accuser curl — un token expiré ou avec une mauvaise audience en est la cause habituelle.

Clés d’API (en-tête ou paramètre de requête)

Certaines API veulent la clé dans un en-tête, d’autres dans un paramètre de requête. Les en-têtes sont plus sûrs car les URL fuitent dans les journaux et l’historique du navigateur :

# À privilégier : clé dans un en-tête
curl -H "X-API-Key: sk_live_a1b2c3" https://api.example.com/data

# Moins sûr : clé dans l'URL (finit dans les journaux d'accès)
curl "https://api.example.com/data?api_key=sk_live_a1b2c3"

Cookies (`-b` pour envoyer, `-c` pour enregistrer)

-c écrit un cookie jar ; -b le relit. C’est ainsi que vous transportez une session d’une requête à l’autre :

# Se connecter et enregistrer le cookie de session
curl -c jar.txt -d "user=alice&pass=s3cret" https://httpbin.org/cookies/set/session/abc123

# Le réutiliser à l'appel suivant
curl -b jar.txt https://httpbin.org/cookies

Note de sécurité : les tokens et les identifiants n’ont leur place que sur des connexions HTTPS — TLS chiffre les en-têtes, le HTTP simple ne le fait pas. Évitez de mettre des secrets directement sur la ligne de commande, où ils atterrissent dans l’historique de votre shell et dans la sortie de ps. Lisez un en-tête depuis un fichier avec -H @authfile ou récupérez la valeur depuis une variable d’environnement (-H "Authorization: Bearer $TOKEN").

Télécharger et uploader des fichiers

curl a été nommé « client URL » parce que déplacer des fichiers est sa vocation d’origine. Téléchargements et uploads disposent chacun de quelques options qu’il vaut la peine de connaître.

Téléchargement : `-O` face à `-o` face à `-C -`

-O (O majuscule) enregistre le fichier sous son nom distant. -o (o minuscule) vous laisse choisir le nom. -C - reprend un téléchargement partiel là où il s’était arrêté :

# Enregistrer sous le nom de fichier distant : archive.zip
curl -O https://example.com/downloads/archive.zip

# Enregistrer sous un nom que vous choisissez
curl -o backup.zip https://example.com/downloads/archive.zip

# Reprendre un téléchargement interrompu
curl -C - -O https://example.com/downloads/archive.zip

# Suivre les redirections vers le vrai fichier (fréquent avec les CDN)
curl -OL https://example.com/latest/archive.zip

Pour télécharger avec curl un contenu situé derrière une redirection, ajoutez -L — les pages de release et les liens de CDN redirigent presque toujours.

Upload : `-T` face à `-F`

-T uploade un fichier avec PUT, en envoyant les octets bruts comme corps (courant pour le stockage d’objets et les endpoints REST de fichiers). -F envoie une requête multipart/form-data, le même format qu’un navigateur utilise pour les champs de type fichier :

# PUT d'octets bruts
curl -T report.pdf https://api.example.com/files/report.pdf

# Upload multipart/form-data (notez le préfixe @)
curl -F "file=@report.pdf" -F "title=Q2 report" https://httpbin.org/post

Le préfixe @ indique à curl de lire le contenu du fichier. Sans lui, -F "file=report.pdf" envoie la chaîne littérale report.pdf, pas le fichier.

`--data-urlencode` et le pourcentage-encodage

Lorsqu’une valeur contient des espaces, des &, des = ou des caractères non-ASCII, -d l’envoie telle quelle et casse votre requête. --data-urlencode l’encode correctement :

# Faux : le & scinde le corps, l'espace est invalide
curl -d "q=hello world&filter=a&b" https://httpbin.org/post

# Correct : chaque champ est pourcentage-encodé
curl --data-urlencode "q=hello world" \
  --data-urlencode "filter=a&b" \
  https://httpbin.org/post

Si vous avez besoin de comprendre ce que signifient ces séquences %20 et %26 — ou de déboguer une valeur doublement encodée — collez-la dans le Décodeur et Encodeur URL ou lisez l’explication octet par octet dans le guide Encodage et décodage d’URL.

Tests d’API et inspection des réponses

curl est à son aise dans les scripts et la CI : -w expose tout ce qui concerne le transfert et les codes de sortie rendent les échecs détectables.

Code de statut uniquement

Pour récupérer uniquement le statut HTTP, jetez le corps avec -o /dev/null et affichez le code avec -w :

curl -s -o /dev/null -w "%{http_code}\n" https://httpbin.org/status/204
# → 204

C’est le cœur de toute vérification d’état pour les tests d’API avec curl. Pour interpréter le nombre obtenu, l’aide-mémoire des codes HTTP couvre chaque plage.

Décomposition du temps

-w expose des variables de chronométrage, ce qui vous permet de voir où le temps passe — DNS, connexion TCP, TLS, ou le serveur lui-même :

curl -s -o /dev/null \
  -w "dns=%{time_namelookup}s connect=%{time_connect}s tls=%{time_appconnect}s total=%{time_total}s\n" \
  https://example.com
# → dns=0.004s connect=0.021s tls=0.058s total=0.142s

Un time_appconnect élevé pointe vers TLS, un time_starttransfer élevé pointe vers un backend lent.

Silencieux mais montrant les erreurs

-s masque la barre de progression, mais il masque aussi les messages d’erreur — un piège dans les scripts. Associez-le à -S pour que curl reste discret en cas de succès tout en signalant les échecs :

curl -sS https://api.example.com/health

curl en CI / dans les scripts : échouer sur les erreurs HTTP

Par défaut, curl renvoie le code de sortie 0 même sur un 404 ou un 500, parce que le transfert lui-même a réussi. Dans une vérification d’état, c’est l’opposé de ce que vous voulez. -f (fail) fait sortir curl avec un code non nul sur les erreurs HTTP, pour que votre pipeline les détecte :

# Fait échouer le build si l'endpoint renvoie 4xx/5xx
curl -fsS https://api.example.com/health || exit 1

-fsS (fail, silent, show-errors) est la combinaison canonique pour une vérification d’état. Pour des diagnostics plus riches, --fail-with-body (curl 7.76+) affiche encore la réponse d’erreur avant de sortir.

Délais d’attente et tentatives

Un health check qui reste bloqué indéfiniment est pire qu’un échec rapide. Bornez chaque requête scriptée avec --max-time (plafond sur tout le transfert) et --connect-timeout (plafond sur la seule connexion) :

# Abandon après 5 s de connexion, 10 s au total
curl --connect-timeout 5 --max-time 10 -fsS https://api.example.com/health

Sur un réseau instable, --retry relance un transfert échoué avec un backoff exponentiel. Par défaut, il ne réessaie que les échecs transitoires (délais dépassés, 5xx) ; ajoutez --retry-all-errors pour réessayer aussi les connexions refusées :

# Jusqu'à 3 tentatives, avec une pause croissante
curl --retry 3 --retry-all-errors --max-time 30 -fsS https://api.example.com/health

Quand un script télécharge un gros fichier sans vouloir saturer le lien, --limit-rate plafonne la bande passante : --limit-rate 2M la limite à 2 Mo/s.

HTTP/1.1, HTTP/2 et HTTP/3 avec curl

curl négocie la version HTTP par-dessus TLS via ALPN. Vous pouvez forcer une version lorsque vous devez tester un chemin de protocole spécifique.

`--http2` et `--http3`

# Demander HTTP/2 (repli sur 1.1 si indisponible)
curl --http2 https://example.com

# Demander HTTP/3 par-dessus QUIC
curl --http3 https://example.com

HTTP/3 fonctionne par-dessus QUIC et nécessite TLS 1.3. Il ne fonctionne que si votre curl a été compilé avec un backend compatible HTTP/3 et que le serveur l’annonce via un en-tête Alt-Svc. Exécutez curl --version pour confirmer que HTTP3 apparaît dans la ligne des fonctionnalités ; si ce n’est pas le cas, --http3 renverra une erreur.

Infos verbeuses sur TLS / ALPN

-v affiche le protocole négocié et le handshake TLS, ce qui vous permet de confirmer qu’une version a bien pris effet :

curl -v --http2 https://example.com 2>&1 | grep -i "ALPN\|HTTP/2"
# → * ALPN: server accepted h2
# → > GET / HTTP/2

Cherchez ALPN: server accepted h2 (HTTP/2) ou h3 (HTTP/3) dans la sortie du handshake.

8 pièges courants de curl (et comment les corriger)

Ces huit-là finissent par piéger tout le monde un jour ou l’autre.

Guillemets simples ou doubles. Les guillemets doubles laissent le shell développer les $VARS ; les guillemets simples passent tout littéralement. Utilisez des guillemets simples pour les corps JSON afin que $ et ! ne soient pas interprétés : curl --json '{"price":"$5"}'. Utilisez des guillemets doubles quand vous voulez le développement : -H "Authorization: Bearer $TOKEN".
-d n’effectue pas de URL-encodage. Un espace ou un & dans une valeur -d corrompt le corps. Passez à --data-urlencode pour toute valeur qui n’est pas déjà encodée.
-X POST redondant avec -d. -d implique déjà POST. Écrire -X POST -d ... est inoffensif mais redondant ; pire, -X GET -d ... envoie un corps avec un GET, ce qui surprend certains serveurs. Laissez l’option du corps définir la méthode.
Oublier le @ lors de la lecture depuis un fichier. -d @body.json lit le fichier ; -d body.json envoie le texte littéral body.json. Même piège avec -F "file=@upload.png" face à -F "file=upload.png".
Recourir à -k sur les erreurs de certificat. -k désactive la vérification TLS et masque de vrais problèmes (certificats expirés, mauvais nom d’hôte, intermédiaire manquant). Corrigez la cause racine : installez la CA avec --cacert ca.pem, ou mettez à jour le magasin de confiance de votre système. Gardez -k pour un serveur de dev auto-signé que vous contrôlez entièrement.
-s qui avale les erreurs. Le mode silencieux masque les échecs dans les scripts. Utilisez toujours -sS pour que les erreurs remontent quand même.
[ ] { } dans les URL soumis au globbing. curl interprète [1-5] et {a,b} comme des plages/listes d’URL. Une URL avec des crochets littéraux (fréquent dans les paramètres de requête de type tableau comme arr[]=1) se retrouve déformée. Désactivez le globbing avec -g : curl -g "https://api.example.com/items?id[]=1&id[]=2".
Casse et doublons des en-têtes. Les noms d’en-têtes HTTP sont insensibles à la casse, mais envoyer le même en-tête deux fois envoie généralement les deux — certains serveurs prennent le premier, d’autres le dernier, d’autres le rejettent. Si vous surchargez un en-tête par défaut comme User-Agent, définissez-le une seule fois avec -H plutôt que de vous fier à l’ordre.

curl, wget ou HTTPie : lequel utiliser

Tous trois récupèrent des données par-dessus HTTP, mais ils sont optimisés pour des tâches différentes. Voici le choix entre curl et wget (avec HTTPie) en un coup d’œil :

Tâche	curl	wget	HTTPie
Appel d’API rapide / débogage	Excellent	Limité	Excellent
Corps JSON	Bon (`--json`)	Malaisé	Excellent (natif)
Téléchargement récursif / miroir de site	Non	Excellent (`-r`)	Non
Reprise + nouvelle tentative sur gros téléchargements	Bon (`-C -`)	Excellent (intégré)	Non
Scripting / CI (codes de sortie, `-w`)	Excellent	Bon	Bon
Sortie jolie et colorisée par défaut	Non	Non	Excellent
Préinstallé presque partout	Oui	Souvent	Rarement

La version courte : tournez-vous vers curl pour le débogage d’API et les scripts (il est partout et -w est sans égal), vers HTTPie quand vous voulez une ergonomie JSON lisible sur votre propre machine, et vers wget pour faire le miroir de sites ou télécharger des fichiers par lots avec des nouvelles tentatives automatiques.

Foire aux questions

À quoi sert curl ?

curl est un outil en ligne de commande pour transférer des données vers et depuis un serveur via HTTP, HTTPS, FTP et bien d’autres protocoles. Les développeurs l’utilisent pour appeler et déboguer des API, télécharger et uploader des fichiers, et exécuter des vérifications d’état dans des scripts et des pipelines de CI.

Comment envoyer une requête POST avec curl ?

Utilisez -d pour les données de formulaire ou --json pour le JSON : curl --json '{"name":"alice"}' https://httpbin.org/post. Les deux options définissent automatiquement la méthode sur POST, donc vous n’avez pas besoin de -X POST.

Comment ajouter un en-tête dans curl ?

Utilisez -H "Name: value", et répétez-le pour plusieurs en-têtes : curl -H "Accept: application/json" -H "X-Request-Id: 9f3c1a" https://httpbin.org/headers. Il n’y a aucune limite au nombre de fois où vous pouvez passer -H.

Comment envoyer un token Bearer avec curl ?

Passez un en-tête Authorization : curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com/me, ou utilisez le raccourci --oauth2-bearer YOUR_TOKEN. N’envoyez les tokens que par-dessus HTTPS, et décodez-les avec le Décodeur JWT lors du débogage.

Comment télécharger un fichier avec curl ?

Utilisez -O pour conserver le nom de fichier distant ou -o name pour choisir le vôtre : curl -O https://example.com/archive.zip. Ajoutez -L pour suivre les redirections et -C - pour reprendre un téléchargement interrompu.

Comment voir uniquement le code de statut HTTP avec curl ?

Jetez le corps et affichez le code : curl -s -o /dev/null -w "%{http_code}" https://example.com. C’est le modèle standard pour les vérifications d’état dans les scripts.

Quelle est la différence entre curl et wget ?

curl transfère une seule ressource et écrit sur stdout par défaut, ce qui le rend idéal pour les appels d’API et le scripting. wget se spécialise dans le téléchargement, y compris le miroir récursif et les nouvelles tentatives automatiques. Pour les tests d’API, utilisez curl ; pour les téléchargements de fichiers en masse, utilisez wget.

curl est-il disponible sur Windows ?

Oui. curl est livré avec Windows 10 (build 1803+) et Windows 11, disponible sous le nom curl dans l’invite de commandes et PowerShell. Notez que PowerShell a historiquement créé un alias de curl vers Invoke-WebRequest, donc appelez explicitement curl.exe si les options se comportent de manière inattendue.

Pour conclure

curl récompense un petit effort de mémorisation : le tableau d’options en haut couvre la grande majorité de ce que vous taperez, et le reste consiste à savoir quelles options impliquent une méthode, lesquelles nécessitent des guillemets et lesquelles vous trahissent dans les scripts (oui, -s employé tout seul). Gardez cet aide-mémoire curl ouvert à côté de votre terminal. Si vous préférez composer des commandes de manière interactive, essayez notre générateur de commandes cURL pour les créer visuellement.

La suite d’un workflow d’API découle directement de là. Envoyez la requête avec curl, lisez ce qui revient avec l’aide-mémoire des codes HTTP, puis formatez le JSON dans le Formateur JSON ou découpez-le avec l’Aide-mémoire jq. Pour la liste complète des options, le manuel de curl est exhaustif, et la référence HTTP de MDN explique la sémantique derrière chaque méthode et chaque en-tête.