Httpie : qu'est-ce que c'est, un client HTTP pour la ligne de commande

Qu'est-ce que Httpie et en quoi diffère-t-il de cURL

Httpie (ou HTTPie) est un utilitaire de ligne de commande écrit en Python qui simplifie l'envoi de requêtes HTTP par rapport à cURL. La principale différence est une syntaxe proche du langage naturel : les arguments sont séparés par des espaces, les en-têtes sont indiqués par un deux-points et les données JSON par un signe égal sans échapper les guillemets.

Comparaison entre cURL et Httpie

La même requête POST dans cURL exige au moins trois drapeaux (-X, -H, -d) et un échappement manuel du JSON. Httpie fait de même avec trois mots et sans drapeaux, en définissant automatiquement Content-Type: application/json et en colorant la sortie. La réponse est formatée avec des indentations et une coloration syntaxique par défaut.

La syntaxe des requêtes dans Httpie

Httpie utilise un format de ligne de commande unique sans drapeaux pour les principaux paramètres. La méthode HTTP est spécifiée comme premier argument (GET, POST, PUT, DELETE, PATCH), l'URL comme second. Si la méthode est omise, Httpie choisit automatiquement GET (pour les requêtes sans corps) ou POST (avec corps).

Types d'arguments

• Header:Value — en-têtes de requête avec deux-points, sans espace après le deux-points : Authorization:"Bearer token".
• key=value — champs de l'objet JSON dans le corps de la requête : name=John age=30.
• key:=value — valeurs JSON non-chaîne (nombres, booléens, tableaux) : active:=true tags:=["dev","test"].
• key@file — chargement d'une valeur depuis un fichier : avatar@~/photo.jpg.

Httpie détermine automatiquement le type de données : si key=value est transmis, le corps est envoyé au format JSON. Si un texte brut est transmis via --raw, il est envoyé en texte brut. Le format form-data est activé avec le drapeau -f.

# Requête POST avec des données JSON et un en-tête
http POST https://api.example.com/users \
    name="John Doe" \
    email="john@example.com" \
    role:="admin" \
    Authorization:"Bearer test123"

# Réponse avec coloration et Pretty-print
HTTP/1.1 201 Created
Content-Type: application/json
{
    "id": 42,
    "name": "John Doe"
}

Travailler avec JSON et les fichiers

La sérialisation JSON dans Httpie fonctionne automatiquement : une valeur transmise sous forme de key=value devient un champ chaîne du JSON. Pour les nombres et les valeurs booléennes, on utilise key:=value. Les objets imbriqués sont créés avec la notation par points : address.city=Moscow.

Téléversement de fichiers et de données binaires

Httpie prend en charge le format multipart/form-data pour téléverser des fichiers et des données via la syntaxe key@path. Si vous devez envoyer le contenu d'un fichier comme corps brut de la requête, la redirection d'entrée est utilisée : http POST example.com < file.json. Pour télécharger la réponse dans un fichier, on utilise le drapeau -d (download).

# Envoi de JSON depuis un fichier
http POST https://api.example.com/users < user.json

# Téléversement d'un fichier via multipart
http -f POST https://api.example.com/upload \
    photo@~/photo.jpg \
    description="Profile photo"

Gestion des sessions et des cookies

Les sessions dans Httpie conservent l'état entre les requêtes : cookies, en-têtes et paramètres d'authentification. Une session est créée avec le drapeau --session=name. Les données de session sont stockées dans un fichier JSON dans le dossier ~/.httpie/sessions/. Une session avec le suffixe :readonly n'est pas mise à jour après une requête.

Exemple de test avec session

D'abord, une requête POST est envoyée à /auth/login avec les identifiants — le serveur renvoie un cookie de session. Toutes les requêtes suivantes vers des points de terminaison protégés dans la même session envoient automatiquement le cookie enregistré, ce qui simule le comportement d'un navigateur lors du test de l'API d'une application mobile.

# Étape 1 : authentification
http --session=app-test POST https://api.example.com/auth/login \
    username="dev" password="secret"

# Étape 2 : requête avec le cookie de session enregistré
http --session=app-test GET https://api.example.com/users/me

Authentification et en-têtes

Httpie prend en charge tous les principaux types d'authentification via des drapeaux : -a user:pass pour Basic Auth, --auth-type=digest pour Digest, --auth-type=bearer TOKEN pour Bearer Token. Les en-têtes personnalisés sont ajoutés comme HeaderName:value à n'importe quel endroit de la commande.

OAuth 2.0 et Bearer Token

Pour tester une API avec OAuth 2.0, le jeton est transmis via l'en-tête Authorization. Httpie ne gère pas le cycle de vie du jeton au niveau du noyau — c'est un script externe qui le fait. La commande http --auth-type=bearer --auth="$TOKEN" GET https://api.example.com/resource équivaut à spécifier explicitement l'en-tête avec le jeton.

Utilisation de Httpie dans les scripts CI/CD

Httpie est idéal pour les pipelines CI/CD grâce à zéro dépendance (sauf Python) et à une sortie lisible. Les commandes se lisent facilement dans les journaux sans analyse supplémentaire. L'outil s'installe via pip et est disponible dans toutes les images Docker populaires, y compris Alpine, Ubuntu et les images officielles de CI de Jenkins et GitLab. Cela fait de Httpie un choix pratique pour les tests automatisés d'API REST et de microservices.

Vérification du point de terminaison de santé lors du déploiement

Un scénario typique est la vérification du statut de l'API après le déploiement d'une application. Httpie envoie une requête au point de terminaison de santé et se termine avec un code non nul si la réponse ne correspond pas à celle attendue. Le drapeau --check-status renvoie automatiquement une erreur pour les codes de statut >= 300.

# Contrôle de santé dans le script de déploiement
http --check-status GET https://api.staging.example.com/health
    status:="ok" && \
    echo "L'API est saine" || \
    echo "Le contrôle de l'API a échoué"

Fonctionnalités avancées et plugins de Httpie

Httpie prend en charge les plugins via le système Package Index. Les plugins ajoutent de nouveaux types d'authentification, des formats de sérialisation et des transports. L'installation se fait via pip : pip install httpie-plugin-name. Après l'installation, le plugin est activé automatiquement au prochain lancement de Httpie.

Plugins Httpie populaires

• httpie-jwt-auth — obtention et renouvellement automatiques des jetons JWT via le mécanisme de jeton de rafraîchissement.
• httpie-oauth — prise en charge de OAuth 2.0 Client Credentials et du flux Authorization Code avec échange automatique du code contre un jeton.
• httpie-editor — ouvre le corps de la requête dans un éditeur de texte (vim, nano, VS Code) avant l'envoi.
• httpie-image — affiche les images de la réponse directement dans le terminal (nécessite kitty ou iTerm2).

Scripting et analyse de la sortie

Httpie prend en charge un filtrage semblable à jq via l'option --pretty=format et une sortie compatible cURL via --print. Le drapeau --quiet désactive la sortie colorée pour une meilleure lisibilité dans les journaux CI. Pour le traitement programmatique de la réponse, utilisez le drapeau --body, qui affiche uniquement le corps de la réponse sans les en-têtes.

# Extraction d'un champ d'une réponse JSON avec jq
http GET https://api.example.com/users/1 | jq '.name'

# Sortie uniquement du corps de la réponse (sans les en-têtes)
http --body GET https://api.example.com/health

# Envoi par lots avec différentes données depuis un fichier
while read -r line; do
    http POST https://api.example.com/items $line
done < items.txt

Formats de sortie et personnalisation

Httpie prend en charge les formats de sortie via le drapeau --print : H (en-têtes de requête), B (corps de requête), h (en-têtes de réponse), b (corps de réponse). La combinaison --print=hb affiche uniquement les en-têtes et le corps de la réponse. Le drapeau --pretty=all active le formatage coloré avec indentations.

Schémas de couleurs personnalisés

Httpie prend en charge la personnalisation via la variable HTTPIE_COLORS. Configurez les couleurs pour l'URL, les en-têtes, JSON et les codes de statut. Des thèmes intégrés sont disponibles : autumn, borland, fruity, monokai, native, tango pour différents terminaux.

Sortie au format JSON

Pour le traitement programmatique, utilisez --body --pretty=none, qui renvoie le JSON brut. La sortie compacte est utile pour la passer à jq, sed et d'autres analyseurs lors de l'automatisation de tests d'API dans des scripts.

Formats de sortie et personnalisation de l'apparence

Httpie prend en charge plusieurs formats de sortie via le drapeau --print : H (en-têtes de requête), B (corps de requête), h (en-têtes de réponse), b (corps de réponse). La combinaison --print=hb affiche uniquement les en-têtes et le corps de la réponse, en excluant les métadonnées de connexion. Le drapeau --pretty=all active le formatage coloré avec indentations pour une meilleure lisibilité.

Schémas de couleurs personnalisés

Httpie prend en charge la personnalisation des couleurs via la variable d'environnement HTTPIE_COLORS. Vous pouvez configurer les couleurs pour l'URL, les en-têtes, les clés JSON et les codes de statut de la réponse. Des thèmes intégrés sont disponibles : autumn, borland, fruity, monokai, native et tango pour différents types de terminaux et préférences personnelles.

Sortie au format JSON sans formatage

Pour le traitement programmatique de la sortie, utilisez la combinaison de drapeaux --body --pretty=none, qui renvoie le JSON brut sans couleurs ni indentations. La sortie compacte est utile pour la passer à jq, sed et d'autres analyseurs de console lors de l'automatisation de tests d'API REST dans des scripts shell.