Générateur & Constructeur de commande cURL

Qu'est-ce qu'une commande curl ?

# Plain GET — curl defaults to GET
curl https://api.example.com/users

# GET with a Bearer token (auth is just a header)
curl https://api.example.com/me \
  -H 'Authorization: Bearer YOUR_TOKEN'

# POST a JSON body — note the Content-Type header
curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada","role":"admin"}'

# Multipart file upload — '@' reads the file from disk
curl -X POST https://api.example.com/upload \
  -F 'file=@report.pdf' \
  -F 'title=Q3 report'

Fonctionnalités clés

Alternatives à curl & clients HTTP

Exemples de commandes curl

curl https://api.example.com/users

curl https://api.example.com/me \
  -H 'Authorization: Bearer YOUR_TOKEN'

curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada","role":"admin"}'

curl -X POST https://api.example.com/login \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'username=ada&password=s3cret'

curl -X POST https://api.example.com/upload \
  -F 'file=@report.pdf' \
  -F 'title=Q3 report'

curl -L -o archive.zip \
  https://example.com/files/archive.zip

curl -u ada:s3cret \
  https://api.example.com/private

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

Comment construire une commande curl

1. 1

   Choisissez la méthode HTTP

   Sélectionnez GET, POST, PUT, PATCH, DELETE, HEAD ou OPTIONS. curl utilise GET par défaut ; choisir POST ou un autre verbe ajoute `-X METHOD` à la commande générée. Ou appuyez sur une puce de préréglage pour définir la méthode et un corps correspondant en un clic.

2. 2

   Saisissez l'URL et les paramètres de requête

   Saisissez l'URL de la requête (ex. `https://api.example.com/users`). Ajoutez des paramètres de requête sous forme de paires clé/valeur et l'outil les encode en URL et ajoute `?key=value&…` à l'URL automatiquement — aucun encodage manuel nécessaire.

3. 3

   Ajoutez les en-têtes et l'authentification

   Ajoutez les en-têtes de requête sous forme de paires clé/valeur, puis choisissez un schéma d'authentification : Aucun, jeton Bearer, Basic (nom d'utilisateur/mot de passe), ou un en-tête de clé API personnalisé. Le bon en-tête `Authorization` ou personnalisé est généré dans le format exact attendu par le serveur.

4. 4

   Définissez le corps de la requête

   Pour POST/PUT/PATCH, choisissez un type de corps : collez du JSON brut (l'en-tête `Content-Type` est ajouté pour vous), construisez des champs de formulaire urlencoded, ou assemblez un envoi multipart et basculez n'importe quel champ en fichier avec le préfixe `@`.

5. 5

   Activez les options

   Activez les indicateurs dont vous avez besoin — suivre les redirections (`-L`), TLS non sécurisé (`-k`), verbeux (`-v`), inclure les en-têtes (`-i`), compressé (`--compressed`), sortie vers fichier (`-o`), un délai de connexion, ou un proxy (`-x`). Chaque activation met la commande à jour en temps réel.

6. 6

   Copier, exporter ou réinitialiser

   Copiez la commande terminée, Exportez .sh pour la télécharger comme script, ou Réinitialisez pour effacer le formulaire. Utilisez le bouton Multi-ligne pour basculer entre sortie sur une ligne et avec continuation avant de copier.

Erreurs curl courantes

# Voulait un PATCH, mais -d seul implique POST
curl -d '{"role":"admin"}' \
  https://api.example.com/users/7

# Définissez le verbe explicitement
curl -X PATCH -d '{"role":"admin"}' \
  -H 'Content-Type: application/json' \
  https://api.example.com/users/7

# Le serveur voit urlencoded, pas JSON — 400/415
curl -X POST https://api.example.com/users \
  -d '{"name":"Ada"}'

# Déclarez le type de contenu JSON
curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada"}'

# $name est développé par le shell en chaîne vide
curl -d "{\"user\":\"$name\"}" \
  https://api.example.com/users

# Les guillemets simples envoient le corps littéralement
curl -d '{"user":"$name"}' \
  https://api.example.com/users

# -d rend ceci un POST, pas un GET
curl -d 'page=2&limit=50' \
  https://api.example.com/users

# La chaîne de requête dans l'URL le garde en GET
curl 'https://api.example.com/users?page=2&limit=50'

:: cmd.exe — la barre oblique inverse n'est pas un caractère de continuation
curl -X POST https://api.example.com/users \
  -d '{"name":"Ada"}'

:: cmd.exe — une ligne, ou utilisez ^ pour continuer
curl -X POST https://api.example.com/users -d "{\"name\":\"Ada\"}"

# L'espace divise l'argument — curl voit deux args
curl https://api.example.com/search?q=hello world

# Encodez l'espace (ou mettez toute l'URL entre guillemets)
curl 'https://api.example.com/search?q=hello%20world'

Cas d'usage courants

Test d'API REST

Construisez et envoyez des requêtes à un endpoint REST sans quitter le terminal : définissez la méthode, collez un jeton Bearer, envoyez un corps JSON, et lisez la réponse. Le moyen le plus rapide de confirmer qu'une API fonctionne avant d'écrire le code client.

Reproduction d'une requête depuis la documentation

La documentation API montre les endpoints et les paramètres mais rarement une commande complète prête à copier. Remplissez ici la méthode, l'URL, les en-têtes et l'authentification pour obtenir une commande curl qui s'exécute telle quelle — sans lutte avec les guillemets ou les en-têtes `Content-Type` manquants.

Scripts de test de fumée CI/CD

Générez une commande curl pour un bilan de santé ou un test de fumée post-déploiement, puis Exportez .sh pour la déposer dans un pipeline. Ajoutez `--connect-timeout` et `--max-time` pour qu'un endpoint bloqué ne puisse pas bloquer le build, et vérifiez les codes de statut avec `-w`.

Envoi & téléchargement de fichiers

Assemblez un envoi `multipart/form-data` avec `-F field=@file`, ou construisez un téléchargement `-L -o filename` qui suit les redirections vers un CDN. Encodez d'abord les noms de fichiers ou valeurs de requête délicats avec notre encodeur URL.

Débogage de webhooks

Rejouez une charge utile de webhook en POSTant le même corps JSON que le fournisseur envoie, avec les bons en-têtes de signature et `Content-Type`. Reproduisez la requête exacte localement pour déboguer pourquoi votre gestionnaire l'a rejetée.

Rapports de bugs reproductibles

Collez une seule commande curl autonome dans un rapport de bug ou une PR pour que chacun puisse reproduire la requête exacte — méthode, en-têtes, placeholder d'authentification et corps. Bien plus clair que de décrire la requête en prose.

Apprendre les indicateurs curl

Voyez comment chaque choix de formulaire correspond à un vrai indicateur — choisissez l'auth Basic et regardez `-u` apparaître, ajoutez un corps JSON et regardez l'en-tête `Content-Type` s'attacher. Une façon pratique d'apprendre la syntaxe, associée à notre aide-mémoire curl.

Préparer une requête à convertir en code

Construisez et vérifiez d'abord la requête en curl, puis traduisez-la dans le client HTTP de votre application. L'onglet Convertir à venir transformera une commande curl collée en fetch, requests, Go, PHP, Ruby et Node.js — commencez depuis une commande curl que vous savez fonctionnelle.

Indicateurs curl & référence de syntaxe

Guillemets & échappement shell

L'outil enveloppe les valeurs dans des guillemets simples, la forme la plus sûre dans les shells POSIX car rien à l'intérieur d'une chaîne entre guillemets simples n'est développé. Un guillemet simple littéral dans une valeur est émis sous la forme `'\''` (fermeture de guillemet, guillemet échappé, réouverture de guillemet). Sur `cmd.exe`, passez aux guillemets doubles ; Git Bash et WSL exécutent les commandes à guillemets simples générées sans modification.

-d vs --data-raw vs --data-binary

`-d`/`--data` supprime les sauts de ligne et les retours chariot du corps — convient pour les paires `key=value`, avec perte pour le contenu multi-ligne. `--data-raw` est identique mais ne traitera pas un `@` en tête comme un nom de fichier. `--data-binary` envoie les octets exactement tels qu'ils sont donnés (utilisez `@file` pour envoyer le contenu brut d'un fichier). Les trois impliquent POST sauf si la méthode est remplacée.

Multipart (-F) vs URL-encodé (-d)

`-F field=value` produit `multipart/form-data` avec une limite générée — requis pour les envois de fichiers (`-F file=@path`) et les formulaires mixtes fichier/texte. `-d field=value` produit `application/x-www-form-urlencoded`, une seule chaîne jointe par `&`. Ne définissez jamais `Content-Type` manuellement pour le multipart ; curl calcule la limite et définit l'en-tête lui-même.

Encodage de l'en-tête d'authentification

L'authentification Bearer envoie `Authorization: Bearer ` mot pour mot (RFC 6750). L'authentification Basic depuis `-u user:pass` est encodée en Base64 dans `Authorization: Basic ` sur le réseau — encodage, pas chiffrement, donc utilisez HTTPS. Une clé API est l'en-tête personnalisé requis par le service, ex. `X-API-Key: `.

Encodage de la chaîne de requête

Les paramètres de requête ajoutés dans le constructeur sont encodés en pourcentage et ajoutés sous la forme `?key=value&key2=value2`. Les caractères réservés (espaces, `&`, `=`, `#`) sont échappés pour que l'URL soit valide. Pour les champs de corps qui doivent être encodés, `--data-urlencode` de curl gère l'encodage au moment de la requête.

Comportement des redirections (-L)

Sans `-L`, curl affiche une réponse 301/302 et s'arrête. Avec `-L`, il suit l'en-tête `Location` jusqu'à l'URL finale. Notez que curl supprime l'en-tête `Authorization` quand une redirection passe à un hôte différent (une valeur de sécurité par défaut) ; utilisez `--location-trusted` seulement quand vous comprenez les implications.

Réponses compressées

`--compressed` ajoute un en-tête `Accept-Encoding` annonçant la prise en charge de gzip/deflate/brotli et décompresse la réponse de façon transparente, économisant de la bande passante. Le corps décodé est identique à une requête non compressée — purement une optimisation de transfert, sûre à activer sur la plupart des appels API.

Sortie : -o vs -O

`-o filename` écrit le corps de la réponse dans un fichier que vous nommez ; `-O` le sauvegarde sous le nom de fichier distant depuis le chemin de l'URL. Les deux suppriment le dump normal vers stdout. Combinez avec `-L` pour que les redirections se résolvent vers la vraie ressource avant que le fichier soit écrit.

Bonnes pratiques pour les requêtes curl

Ne jamais coder en dur des secrets dans des commandes partagées

Une commande curl que vous collez dans une PR, un ticket ou un chat sera lue par d'autres et indexée par des outils. Remplacez les jetons et mots de passe par un placeholder (`YOUR_TOKEN`) ou référencez une variable d'environnement (`-H "Authorization: Bearer $API_TOKEN"`). Pour les longs identifiants, curl peut lire un en-tête depuis un fichier avec `-H @headerfile` pour que le secret n'apparaisse jamais dans l'historique shell.

Préférer --data-binary @file pour les charges utiles binaires

Quand le corps est un fichier dont les octets importent — une image, une charge utile signée, du JSON où les espaces sont significatifs — utilisez `--data-binary @file` plutôt que `-d @file`. Le `-d` simple supprime les sauts de ligne et les retours chariot, corrompant silencieusement le contenu binaire et multi-ligne. `--data-binary` envoie le fichier exactement tel qu'il est sur le disque.

Mettre entre guillemets les valeurs d'en-tête

Enveloppez toujours les valeurs `-H` entre guillemets : `-H 'Content-Type: application/json'`. Sans guillemets, l'espace après les deux-points divise l'argument et curl voit un en-tête malformé. Les guillemets simples empêchent également le shell de développer `$`, `*` et d'autres caractères spéciaux dans la valeur — exactement ce que cet outil émet par défaut.

Utiliser --compressed pour économiser de la bande passante

Ajoutez `--compressed` sur les appels API et les téléchargements pour demander l'encodage gzip/brotli et que curl décompresse de façon transparente. Pour les APIs à forte teneur en JSON, cela peut réduire la taille des transferts de 70 à 90 % sans aucun changement dans la réponse que vous voyez — un gain gratuit dans les scripts qui interrogent régulièrement des endpoints.

Fixer des délais d'expiration dans les scripts

Dans tout contexte automatisé, ajoutez `--connect-timeout` et `--max-time` pour qu'un endpoint lent ou bloqué ne puisse pas bloquer un pipeline indéfiniment. Un bilan de santé avec `--max-time 10` échoue rapidement et permet à votre CI de continuer. Associez avec `--retry N` pour absorber les perturbations réseau transitoires sans abandonner immédiatement.

Vérifier avec -v avant d'automatiser

Avant d'intégrer une commande curl dans un script ou un cron job, exécutez-la une fois avec `-v` pour voir la ligne de requête exacte, les en-têtes et la poignée de main TLS. C'est le moyen le plus rapide de détecter une mauvaise méthode, un `Content-Type` manquant, ou un en-tête d'authentification qui n'a pas été attaché — déboguez interactivement, puis retirez `-v` pour la production.

Questions fréquentes