HTTPie : Tutoriel débutant pour l’alternative à cURL

HTTPie est devenu l’un des outils préférés des développeurs pour tester une API REST directement depuis le terminal. Plus simple à lire que cURL, rapide à utiliser et pensé pour les humains, il permet d’envoyer des requêtes HTTP sans se perdre dans des commandes interminables. Même si vous débutez totalement avec les API ou la ligne de commande, vous allez voir qu’il est possible de comprendre son fonctionnement très rapidement.

Dans ce tutoriel complet sur HTTPie, vous apprendrez à installer cet outil, envoyer vos premières requêtes HTTP, manipuler du JSON, tester une API REST et comprendre les réponses du serveur étape par étape. Le tout avec des exemples simples, concrets et accessibles aux débutants.

• Comment fonctionnent les requêtes HTTP et les API REST sans se perdre dans un jargon technique compliqué.
• Gagner du temps pour tester un serveur, envoyer du JSON ou vérifier une API directement depuis le terminal avec des commandes simples et lisibles.
• Éviter les erreurs les plus fréquentes avec HTTPie grâce à des exemples concrets et des explications pensées pour les débutants.

Quand on commence à travailler avec des API, des requêtes HTTP ou des outils en ligne de commande, on tombe très vite sur des noms comme cURL, Postman… et désormais HTTPie. Il a justement été créé pour rendre tout cela plus simple, plus lisible et beaucoup plus agréable à utiliser.

L’objectif ici n’est pas de copier des commandes, mais surtout de comprendre ce que vous faites. Et vous verrez qu’après quelques essais, HTTPie devient rapidement un outil dont on ne peut plus se passer.

Qu’est-ce que HTTPie et pourquoi l’utiliser ?

HTTPie est un outil en ligne de commande permettant d’envoyer des requêtes HTTP facilement.

Dit comme ça, cela peut sembler très technique. Pourtant, derrière cette phrase un peu intimidante se cache quelque chose de très concret : HTTPie sert à communiquer avec des serveurs web.

Par exemple, lorsque vous ouvrez un site internet, votre navigateur envoie des requêtes HTTP au serveur distant. HTTPie permet de faire exactement la même chose… mais directement depuis le terminal.

L’outil est open source, moderne et pensé pour être beaucoup plus lisible que certains outils historiques comme cURL.

Voici un exemple très simple :

http https://jsonplaceholder.typicode.com/posts/1

Cette commande récupère les informations d’un article fictif depuis une API de test.

Et le résultat affiché est généralement très propre :

{
    "id": 1,
    "title": "Mon article",
    "body": "Contenu de démonstration"
}

Pas besoin de passer dix minutes à déchiffrer une sortie incompréhensible. HTTPie mise avant tout sur la simplicité.

À quoi sert HTTPie concrètement ?

HTTPie peut servir dans énormément de situations.

Par exemple, vous pouvez :

• tester une API REST,
• vérifier qu’un serveur répond correctement,
• envoyer des données JSON,
• tester une authentification,
• déboguer une application web,
• automatiser certaines tâches,
• travailler avec vos propres projets backend.

C’est un outil très apprécié des développeurs web, mais aussi des administrateurs système, des étudiants et même des débutants qui veulent comprendre comment fonctionnent les échanges entre un client et un serveur.

HTTPie n’est ni un outil spécifiquement conçu pour le pentest, ni pour l’OSINT, mais il est utile dans les deux domaines.

C’est avant tout un client HTTP en ligne de commande moderne et ergonomique, utilisé pour interagir avec des API et des serveurs web.

• En Pentest : Il sert à tester manuellement des points de terminaison (endpoints), envoyer des payloads personnalisés ou analyser les en-têtes de réponse.
• En OSINT : Il permet d’interroger des API de services tiers (Shodan, Hunter.io, etc.) pour collecter des données de manière scriptée et lisible.

• C’est un outil de test et de requêtage HTTP qui remplace avantageusement curl pour sa lisibilité.

Différences entre HTTPie, cURL et Postman

Lorsque l’on débute, on compare souvent HTTPie à cURL ou Postman.

cURL est extrêmement puissant, mais sa syntaxe peut devenir rapidement difficile à lire.

Exemple avec cURL :

curl -X POST -H "Content-Type: application/json" \
-d '{"name":"Jean"}' https://api.test.com/users

Avec HTTPie, la même commande devient :

http POST https://api.test.com/users name=Jean

C’est beaucoup plus lisible.

Postman, de son côté, est une interface graphique. Très pratique également, mais parfois plus lourde pour des tests rapides.

HTTPie se situe un peu entre les deux : rapide comme cURL, mais agréable comme Postman.

👉 Pour aller plus loin : Maîtriser cURL depuis le terminal, tutoriel complet

Comment installer HTTPie

Installer HTTPie avec pip

La méthode la plus universelle consiste à utiliser Python et pip. (Pip, Pip3 et Pipx : Gérer vos paquets)

Si Python est déjà installé sur votre machine, ouvrez simplement votre terminal puis tapez :

pip install httpie

Sur certains systèmes, vous devrez peut-être utiliser :

pip3 install httpie

Une fois l’installation terminée, vérifiez que tout fonctionne correctement :

http --version

Si un numéro de version apparaît, c’est gagné.

Petit moment de satisfaction personnelle : vous venez d’installer votre premier client HTTP moderne.

Installer HTTPie sur macOS

Si vous utilisez macOS avec Homebrew (HomeBrew, le guide complet) :

brew install httpie

C’est généralement la méthode la plus simple.

Installer HTTPie sur Linux

Sous Ubuntu ou Debian :

sudo apt install httpie

Sur Fedora :

sudo dnf install httpie

Et avec Snap :

sudo snap install httpie

Le fonctionnement des requêtes HTTP

Avant d’utiliser HTTPie sérieusement, il faut comprendre ce qu’est une requête HTTP. Et rassurez-vous, ce n’est pas aussi compliqué qu’on pourrait le croire.

Lorsqu’un client contacte un serveur web, il envoie une requête. Cette requête contient notamment :

• une méthode HTTP,
• une URL,
• parfois des données,
• parfois des en-têtes HTTP.

Le serveur répond ensuite avec :

• un code de statut,
• des données,
• des informations supplémentaires.

C’est exactement ce qu’il se passe lorsque vous visitez un site internet.

Les méthodes HTTP essentielles

GET sert à récupérer des données :

http GET https://jsonplaceholder.typicode.com/posts/1

POST sert à envoyer des données :

http POST https://jsonplaceholder.typicode.com/posts \
title="Bonjour" body="Mon contenu"

PUT et PATCH servent à modifier des données existantes.

http PATCH https://jsonplaceholder.typicode.com/posts/1 \
title="Titre modifié"

DELETE permet de supprimer une ressource.

http DELETE https://jsonplaceholder.typicode.com/posts/1

Un peu brutal comme méthode… mais parfois nécessaire.

Premiers pas avec HTTPie

Commençons par quelque chose de simple, faire une requête GET simple :

http https://jsonplaceholder.typicode.com/users

HTTPie comprend automatiquement qu’il s’agit d’une requête GET.

Vous verrez apparaître une réponse JSON proprement formatée.

Lire une réponse JSON

Le format JSON est très utilisé dans les API.

Voici un exemple :

{
    "name": "Jean",
    "email": "jean@test.com"
}

• Chaque paire clé/valeur représente une information.

Avec HTTPie, les couleurs et l’indentation rendent la lecture beaucoup plus agréable. Et quand on débute, cela change vraiment tout.

Ajouter des paramètres dans l’URL

Vous pouvez ajouter des paramètres directement dans l’URL :

http https://jsonplaceholder.typicode.com/comments?postId=1

Cela permet de filtrer certaines données.

Envoyer des données avec HTTPie

HTTPie simplifie énormément l’envoi de données JSON.

Par exemple :

http POST https://jsonplaceholder.typicode.com/posts \
title="Article test" \
body="Contenu du test" \
userId:=1

Petit détail important :

• = envoie une chaîne de caractères,
• := envoie une vraie valeur JSON.

Ainsi :

userId:=1

• Envoie un nombre.

Alors que :

userId="1"

• Envoie du texte.

Cette nuance peut sembler minuscule… jusqu’au jour où votre API refuse tout ce que vous envoyez.

Envoyer un formulaire HTML

Certaines API attendent des données de formulaire.

Dans ce cas :

http --form POST https://httpbin.org/post \
name=Jean email=test@test.com

L’option --form change le format d’envoi.

Envoyer un fichier

HTTPie permet également d’envoyer des fichiers.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

http --form POST https://httpbin.org/post \
file@image.jpg

Le symbole @ indique qu’il s’agit d’un fichier local.

Utiliser les en-têtes HTTP

Vous pouvez ajouter des headers personnalisés. Les headers servent à transmettre des informations supplémentaires :

http GET https://api.test.com \
Authorization:"Bearer TOKEN123"

Ici, on ajoute un token d’authentification.

Authentification Basic

HTTPie simplifie aussi l’authentification Basic :

http -a utilisateur:motdepasse GET https://api.test.com

Pas besoin de générer manuellement les en-têtes.

Et franchement, quand on débute, ce genre de raccourci fait gagner beaucoup de temps.

Tester une API REST facilement

Les API REST utilisent énormément le format JSON et les requêtes HTTP classiques.

HTTPie est donc parfaitement adapté.

Vous pouvez rapidement :

• créer des données,
• récupérer des ressources,
• modifier des contenus,
• supprimer des éléments,
• tester les réponses du serveur.

Le tout directement dans le terminal.

👉 Pour aller plus loin :

• Coder une API REST en PHP
• Une API REST avec Node.js

Tester une API publique

Utilisons l’API JSONPlaceholder.

Créer une ressource :

http POST https://jsonplaceholder.typicode.com/posts \
title="Mon article" \
body="Contenu exemple"

Récupérer les données :

http GET https://jsonplaceholder.typicode.com/posts/1

Modifier :

http PATCH https://jsonplaceholder.typicode.com/posts/1 \
title="Titre modifié"

Supprimer :

http DELETE https://jsonplaceholder.typicode.com/posts/1

Vous venez déjà d’effectuer les principales opérations d’une API REST.

Les options HTTPie les plus utiles

Pour afficher plus de détails, l’option -v active le mode verbeux :

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

Vous verrez :

• la requête envoyée,
• les headers,
• la réponse complète.

Très utile pour comprendre ce qu’il se passe réellement.

Télécharger un fichier

http --download https://site.com/fichier.zip

HTTPie télécharge automatiquement le fichier.

Suivre les redirections

http --follow https://google.com

Sans cette option, certaines redirections ne seront pas suivies.

Désactiver la vérification SSL

En développement uniquement :

http --verify=no https://localhost

Attention : ne faites pas cela sur des projets sensibles en production.

Sinon, votre futur vous viendra probablement vous hanter.

Comprendre les erreurs fréquentes

Erreur de syntaxe : L’erreur la plus fréquente chez les débutants concerne les espaces et les symboles. Par exemple :

title = "Bonjour"

est incorrect.

La bonne syntaxe :

title="Bonjour"

Le terminal est très strict. Parfois un simple espace suffit à provoquer une erreur. Et oui… cela arrive même aux développeurs expérimentés. Souvent. Très souvent.

Erreurs HTTP courantes

• Erreur 404 : La ressource n’existe pas.
• Erreur 401 : Authentification requise.
• Erreur 403 : Accès interdit.
• Erreur 500 : Erreur côté serveur.

Dans ce cas, le problème vient généralement du backend et non de votre commande.

Même si, soyons honnêtes, on vérifie quand même sa commande trois fois avant d’oser accuser le serveur.

👉 Tout savoir sur : Les codes de statut HTTP.

Bonnes pratiques avec HTTPie

Utiliser des variables d’environnement : Évitez d’écrire vos tokens directement dans les commandes.

Préférez :

export API_TOKEN="mon_token"

Puis :

http GET https://api.test.com \
Authorization:"Bearer $API_TOKEN"

C’est beaucoup plus sécurisé.

👉 Pour ceux qui débutent : Le guide complet sur les variables d’environnement

Organiser ses tests

Lorsque vous travaillez sur une API importante, créez un fichier texte regroupant vos commandes utiles.

• Cela évite de retaper les mêmes requêtes en boucle.

HTTPie Desktop : la version graphique

HTTPie existe également en version graphique. Elle ressemble davantage à Postman.

Vous pouvez :

• enregistrer des requêtes,
• organiser vos projets,
• tester des API visuellement,
• partager des collections.

Cependant, la version terminal reste souvent plus rapide pour les développeurs qui aiment travailler directement en ligne de commande.

Mini projet : tester une API complète

Passons maintenant à un petit exercice concret. Imaginez que vous développez une application de gestion d’articles.

Vous voulez tester votre API.

Créer un article

http POST https://jsonplaceholder.typicode.com/posts \
title="Mon premier article" \
body="Bienvenue sur mon API"

Lire l’article

http GET https://jsonplaceholder.typicode.com/posts/1

Modifier l’article

http PATCH https://jsonplaceholder.typicode.com/posts/1 \
title="Article mis à jour"

Supprimer l’article

http DELETE https://jsonplaceholder.typicode.com/posts/1

Vous venez de reproduire un cycle CRUD complet :

• Create,
• Read,
• Update,
• Delete.

C’est la base de nombreuses applications web modernes.

Récupérer la météo avec HTTPie

Voici un exemple simple et pratique pour récupérer la météo de Paris avec HTTPie. Grâce à une API météo publique, vous pouvez envoyer une requête HTTP directement depuis votre terminal et obtenir une réponse JSON contenant les informations météorologiques actuelles.

http GET "https://wttr.in/Paris?format=j1"

Cette commande interroge le service météo wttr.in et retourne les données météo de Paris au format JSON. Vous pourrez notamment consulter la température, l’humidité, les conditions météo ou encore la vitesse du vent directement dans votre terminal.

Si vous souhaitez afficher uniquement la météo de Paris sur une seule ligne, HTTPie peut interroger directement wttr.inavec un format simplifié très pratique dans le terminal :

http GET "https://wttr.in/Paris?format=3"

Le résultat affichera simplement une ligne du type :

Paris: 🌦 +9°C

C’est idéal pour obtenir rapidement la météo actuelle sans afficher une longue réponse JSON.

Tableau récapitulatif des commandes de HTTPie

Commande HTTPie	Utilité	Exemple
http URL	Effectuer une requête GET simple	http https://api.test.com/users
http GET URL	Récupérer des données	http GET https://api.test.com/users/1
http POST URL	Envoyer des données	http POST https://api.test.com/users name=Jean
http PUT URL	Remplacer une ressource	http PUT https://api.test.com/users/1 name=Paul
http PATCH URL	Modifier partiellement une ressource	http PATCH https://api.test.com/users/1 age:=30
http DELETE URL	Supprimer une ressource	http DELETE https://api.test.com/users/1
clé=valeur	Envoyer une chaîne de caractères	title="Bonjour"
clé:=valeur	Envoyer une vraie valeur JSON	age:=25
Header:Valeur	Ajouter un header HTTP	Authorization:"Bearer TOKEN"
-a user:pass	Authentification Basic	http -a admin:1234 GET URL
--form	Envoyer un formulaire HTML	http --form POST URL nom=Jean
fichier@nom.ext	Envoyer un fichier	http --form POST URL file@image.jpg
-v	Afficher les détails complets de la requête	http -v GET URL
--download	Télécharger un fichier	http --download URL
--follow	Suivre les redirections	http --follow URL
--verify=no	Désactiver la vérification SSL	http --verify=no https://localhost
http --help	Afficher l’aide HTTPie	http --help
http --version	Afficher la version installée	http --version
http OPTIONS URL	Afficher les méthodes HTTP autorisées	http OPTIONS URL
http HEAD URL	Récupérer uniquement les headers	http HEAD URL
http URL param==valeur	Ajouter des paramètres GET	http URL search==test
http URL < fichier.json	Envoyer un fichier JSON	http POST URL < data.json
http GET "https://wttr.in/Paris?format=3"	Afficher la météo sur une ligne	http GET "https://wttr.in/Paris?format=3"

Aller plus loin avec HTTPie

Une fois à l’aise avec les commandes de base, vous pourrez explorer des usages plus avancés.

Par exemple :

• automatiser des scripts Bash,
• tester des API sécurisées,
• travailler avec Docker,
• intégrer HTTPie dans des workflows DevOps,
• créer des outils de débogage rapides.

HTTPie devient alors un véritable couteau suisse pour le développement web. Et le plus intéressant dans tout cela, c’est qu’il reste agréable à utiliser même après des années.

C’est probablement sa plus grande force.

---

FAQ HTTPie

---

HTTPie est l’un de ces outils qui donnent envie de mieux comprendre le web.

Au début, envoyer des requêtes HTTP dans un terminal peut sembler étrange, voire un peu intimidant. Pourtant, après quelques essais, tout devient rapidement plus logique. On comprend mieux comment communiquent les applications, comment fonctionnent les API et pourquoi les développeurs utilisent autant ce type d’outils.

Le plus important maintenant, ce n’est pas de mémoriser toutes les commandes vues dans ce tutoriel. C’est surtout de pratiquer.

Testez des API publiques, expérimentez différentes méthodes HTTP, provoquez volontairement des erreurs pour comprendre les réponses du serveur. C’est souvent comme cela qu’on apprend le plus vite.