HTTPie, el cliente HTTP para terminal que habla como un humano

Siempre he sido de los que usaban curl para todo. Para hacer peticiones a APIs, para descargar archivos, para debuggear endpoints. Y no me quejo, curl es una bestia, corre en cualquier sitio, lo tienes preinstalado hasta en una Raspberry Pi olvidada en un cajón. Pero después de años usándolo, un día me topé con HTTPie y me di cuenta de que había una forma más humana de hacer lo mismo. Literalmente más humana, porque el lema de HTTPie es “curl para humanos”. Y no es marketing barato. La primera vez que ejecuté http https://api.github.com/users/atareao y vi la respuesta con colores, formateada y con los headers claramente separados del body, me pregunté por qué no había probado esto antes. Así que hoy te voy a contar todo lo que he aprendido sobre HTTPie, desde sus orígenes hasta las últimas novedades de la versión 3.x, pasando por trucos que te van a ahorrar horas de depuración.

El veredicto rápido: HTTPie es para ti si trabajas con APIs REST, haces debugging de servicios web, o simplemente quieres una forma más legible de hacer peticiones HTTP desde el terminal. No es para ti si solo necesitas descargar archivos de vez en cuando o si trabajas en entornos mínimos donde no puedes instalar Python. Para esos casos, curl sigue siendo el rey.

¿Qué es HTTPie y por qué debería importarte?

HTTPie (se pronuncia “aitch-ty-dee-pie”, aunque todo el mundo lo llama “httpie” a secas) es un cliente HTTP para terminal escrito en Python. Su creador, Jakub Roztocil, lo lanzó en 2012 con una idea muy clara: hacer que las peticiones HTTP desde la línea de comandos fueran intuitivas, legibles y agradables a la vista.

Hoy, en julio de 2026, HTTPie está en su versión 3.2.4 (noviembre de 2024), acumula más de 38.300 estrellas en GitHub y tiene una comunidad bastante activa. Eso sí, el equipo detrás del proyecto, HTTPie, Inc. con sede en San Francisco, ha puesto mucho foco en su producto comercial HTTPie for Web & Desktop, una aplicación gráfica con AI-assisted, espacios de trabajo y sincronización en la nube. Pero el CLI sigue siendo 100% open source bajo licencia BSD-3-Clause, y no tiene pinta de que vayan a cerrarlo.

La historia de HTTPie es curiosa. Jakub Roztocil lo creó en 2012 porque estaba frustrado con las herramientas existentes para hacer peticiones HTTP desde el terminal. En su blog original explicaba que quería algo que fuera tan intuitivo como hablar con un servidor en lenguaje natural. Y lo consiguió. La primera versión era un script Python de unas pocas líneas, pero el concepto era tan sólido que en pocos meses ya tenía cientos de estrellas en GitHub y contribuciones de toda la comunidad.

Desde entonces, HTTPie ha pasado por varias fases. La versión 1.0 llegó en 2016 con soporte de sesiones, la 2.0 en 2020 eliminó Python 2.7 y añadió type annotations, y la 3.0 en 2022 fue un salto importante con nested JSON, gestor de plugins y Bearer auth nativa. La evolución ha sido constante, aunque el ritmo se ha ralentizado desde que el equipo se centró en el producto comercial.

Ficha técnica

Especificación	Valor
Versión actual	3.2.4 (noviembre 2024)
Repositorio	github.com/httpie/cli
Estrellas	~38.3k
Licencia	BSD-3-Clause
Lenguaje	Python (92.4%)
Python mínimo	3.7+
Creador	Jakub Roztocil
Producto comercial	HTTPie for Web & Desktop

Si trabajas con APIs REST, haces debugging de servicios web, o simplemente necesitas hacer peticiones HTTP desde el terminal de vez en cuando, HTTPie te va a hacer la vida más fácil. No es un sustituto de curl para todos los casos (de eso hablamos luego), pero para el día a día con APIs es otra historia.

Cómo funciona HTTPie: la sintaxis que te cambia la vida

La idea detrás de HTTPie es que puedas expresar una petición HTTP de forma natural, sin tener que acordarte de mil flags crípticos. La sintaxis general es esta:

http [flags] [METHOD] URL [ITEM [ITEM]]

Donde ITEM puede ser de varios tipos, y aquí está la clave de todo. HTTPie usa operadores que son intuitivos:

Operador	Qué hace	Ejemplo
`:`	Header HTTP	`X-API-Token:123`
`==`	Query parameter	`q==httpie`
`=`	Data field (JSON)	`name=John`
`:=`	Raw JSON field	`age:=29`
`@`	File upload	`cv@~/resume.pdf`
`=@`	Embed file content	`description=@file.txt`
`:=@`	Embed JSON file	`data:=@data.json`

Fíjate en la diferencia: con = el valor se trata como string, con := se interpreta como JSON crudo. Esto te permite hacer cosas como:

http POST https://api.example.com/users \ name=Jose \ age:=29 \ active:=true \ tags:='["admin", "user"]'

Sin tener que construir el JSON a mano. Sin tener que escaparlo. Sin errores tontos de sintaxis.

El incidente de las 54.000 estrellas

Una curiosidad que no puedo dejar de contar. En 2022, Jakub Roztocil, el creador, hizo accidentalmente privado el repositorio de HTTPie durante unos 30 segundos pensando que estaba en otro repo. Parece una tontería, pero GitHub tiene una política curiosa: cuando un repo pasa a privado, pierde todas las estrellas. Y no las recupera al volver a público. Así que HTTPie perdió 54.000 estrellas de golpe. GitHub se negó a restaurarlas, aunque lo habían hecho para otros proyectos. La historia se hizo viral en Hacker News, y al final el equipo recuperó unas 23.000 estrellas. Pero las otras 31.000 se fueron para siempre. GitHub, por cierto, mejoró el diálogo de confirmación después de la polémica. Así que, de alguna manera, HTTPie hizo internet un poco más segura para todos los mantenedores de proyectos open source 😅

Cómo funciona HTTPie por dentro

Aunque no necesitas saber esto para usarlo, a mí me gusta entender qué hay debajo. HTTPie está escrito en Python y usa la librería requests internamente, que es el estándar de facto para hacer peticiones HTTP en Python.

Cuando ejecutas http GET https://api.example.com, lo que pasa es esto:

HTTPie parsea tu comando y separa los flags, el método, la URL y los items (headers, datos, queries)
Construye un diccionario Python con los datos que has pasado, aplicando los operadores (= para string, := para JSON, @ para archivos)
Crea un objeto requests.Request con toda la información
Envía la petición y captura la respuesta
Aplica formateo y coloreado a la salida usando la librería Pygments (sí, la misma que usa para resaltar código en blogs y documentación)
Te muestra el resultado con colores, indentación y separación entre headers y body

El formateo de la salida es lo que realmente marca la diferencia. HTTPie no solo colorea, sino que ordena las claves JSON alfabéticamente, indenta correctamente, y separa los headers de respuesta del body con una línea clara. Si la respuesta es XML, también lo formatea. Todo esto hace que leer respuestas de APIs sea mucho más agradable.

Y aquí viene otra cosa que me encanta: si no especificas un método HTTP, HTTPie lo deduce. Si envías datos, asume POST. Si no, asume GET. Así que:

http https://api.github.com/users/atareao/repos

Es equivalente a un GET. Y:

http https://api.example.com/users name=Jose email=jose@example.com

Es un POST. Si quieres forzar un método, lo pones delante:

http DELETE https://api.example.com/users/42 http PUT https://api.example.com/users/42 name=Manuel

La salida es una obra de arte

Lo primero que notas cuando ejecutas HTTPie es que la salida está coloreada y formateada. Los headers aparecen en un color, el body en otro, las claves JSON en otro, y todo está indentado. No es solo postureo: cuando estás debuggeando una API y necesitas localizar rápidamente un campo en una respuesta de 200 líneas, el color te ahorra segundos preciosos.

Además, puedes controlar exactamente qué quieres ver:

# Solo headers http -h https://api.example.com # Solo body http -b https://api.example.com # Todo (verbose) http -v https://api.example.com # Personalizado http -p HBody https://api.example.com # H = headers de response, B = body de response # h = headers de request, b = body de request

Nested JSON: lo que esperabas desde el principio (v3.0.0)

Esta es para mí la funcionalidad más importante que llegó en la versión 3.0.0. Antes, si querías enviar un JSON anidado, tenías que usar := con un string JSON, que era engorroso:

# Antes de v3.0.0. Horrible http POST https://api.example.com \ data:='{"user":{"name":"Jose","age":29}}'

Desde la v3.0.0, puedes hacer esto:

http POST https://httpbin.org/post \ platform[name]=HTTPie \ platform[apps][]=Terminal \ platform[apps][]=Desktop \ address[city]=SanFrancisco \ address[coordinates][lat]:=37.7749 \ address[coordinates][lng]:=-122.4194

Y HTTPie construye el JSON por ti:

{ "platform": { "name": "HTTPie", "apps": ["Terminal", "Desktop"] }, "address": { "city": "SanFrancisco", "coordinates": { "lat": 37.7749, "lng": -122.4194 } } }

Fíjate en el detalle de [] para arrays. Esto es endiabladamente útil cuando trabajas con APIs que esperan estructuras complejas. Y lo mejor es que puedes mezclar [] con subíndices numéricos si necesitas controlar el orden, pero la mayoría de las veces con [] te sobra.

Instalación: todos los caminos llevan a HTTPie

HTTPie se puede instalar de muchas formas. Te pongo las más útiles:

Con pip (universal)

python -m pip install httpie

Esta es la vía universal, funciona en cualquier sistema con Python. Si usas pipx mejor, porque aísla la instalación:

pipx install httpie

Ubuntu/Debian (repo oficial)

HTTPie tiene su propio repositorio APT, que es la forma que recomiendo porque las actualizaciones llegan antes que por los repos oficiales de Ubuntu:

curl -SsL https://packages.httpie.io/deb/KEY.gpg | sudo gpg --dearmor -o /usr/share/keyrings/httpie.gpg echo "deb [arch=amd64 signed-by=/usr/share/keyrings/httpie.gpg] https://packages.httpie.io/deb ./" | sudo tee /etc/apt/sources.list.d/httpie.list sudo apt update && sudo apt install httpie

Otras distribuciones y plataformas

# macOS brew install httpie # Arch Linux pacman -Syu httpie # Windows (con Chocolatey) choco install httpie # Windows (con Scoop) scoop install httpie # Windows (con Winget) winget install httpie # Binario standalone (sin dependencias, Linux) curl -L packages.httpie.io/binaries/linux/http-latest -o http && chmod +x http

El binario standalone es interesante para entornos donde no tienes Python o no quieres instalarlo. Lo descargas, le das permisos y ya tienes HTTPie funcionando. Es una opción que uso a menudo en servidores donde no quiero instalar paquetes Python.

Con Docker

Si prefieres tenerlo aislado o no quieres instalarlo directamente, puedes usar la imagen oficial de Docker:

docker run --rm -it httpie/cli http https://api.example.com

O si quieres una experiencia más cómoda, crea un alias:

alias http='docker run --rm -it -v ~/.httpie:/root/.httpie httpie/cli http'

Con pipx (recomendado para escritorio)

Para equipos de desarrollo, pipx es la opción que más me gusta:

pipx install httpie

pipx aísla HTTPie en su propio entorno, no contamina el Python del sistema, y te permite tener varias versiones si hiciera falta.

Verificar instalación

http --version # Debería mostrar algo como 3.2.4

Casos de uso reales

Hasta aquí la teoría. Vamos a ensuciarnos las manos con ejemplos que te vas a encontrar en el día a día.

1. APIs REST: el pan de cada día

Este es el caso de uso principal. Trabajar con una API REST con HTTPie es una gozada:

# GET con query params http GET https://api.github.com/search/repositories q==httpie sort==stars # POST con datos http POST https://jsonplaceholder.typicode.com/posts \ title="Mi primer post" \ body="Esto es HTTPie" \ userId:=1 # PUT para actualizar http PUT https://jsonplaceholder.typicode.com/posts/1 \ title="Título actualizado" \ body="Cuerpo actualizado" # PATCH para actualización parcial http PATCH https://jsonplaceholder.typicode.com/posts/1 \ title="Solo el título" # DELETE http DELETE https://jsonplaceholder.typicode.com/posts/1

La respuesta la ves al instante, formateada y con colores. Si la respuesta tiene muchos campos, puedes filtrar con jq:

http https://api.github.com/users/atareao | jq '.name, .location, .public_repos'

2. Autenticación: de Basic a Bearer

HTTPie soporta varios métodos de autenticación. Desde la versión 3.0.0, el soporte para Bearer token es nativo:

# Basic auth http -a usuario:contraseña https://api.example.com/protected # Bearer token (v3.0.0+) http -A bearer -a mi-token-secreto https://api.example.com/protected # Si prefieres ponerlo en el header manualmente http https://api.example.com/protected Authorization:"Bearer mi-token-secreto"

La opción -A bearer es equivalente a hacer -A bearer -a token, pero puedes combinarlo. Si tu API usa un esquema de autenticación menos común, siempre puedes añadir el header manualmente con :.

3. Subida y descarga de archivos

Subir archivos con HTTPie es trivial:

# Subir un archivo http POST https://api.example.com/upload cv@~/documentos/cv.pdf # Subir múltiples archivos http POST https://api.example.com/upload \ cv@~/documentos/cv.pdf \ foto@~/imagenes/perfil.jpg # Formulario multipart http -f POST https://api.example.com/upload \ cv@~/cv.pdf \ name=John

Para descargar, el flag --download es tu amigo:

# Descarga normal http --download https://example.com/archivo.zip # Con nombre personalizado http --download --output mi-archivo.zip https://example.com/archivo.zip # Reanudar descarga parcial http --download --continue https://example.com/archivo-grande.zip

4. Sesiones persistentes

Este es de esos trucos que cuando los descubres no sabes cómo has podido vivir sin ellos. HTTPie te permite guardar sesiones para no tener que repetir autenticación, headers o cookies en cada petición:

# Crear una sesión (se guarda en ~/.httpie/sessions/) http --session=mi-api POST https://api.example.com/login \ email=admin@example.com \ password=secreta # Reutilizar la sesión http --session=mi-api GET https://api.example.com/users # Sesión de solo lectura (no guarda cambios) http --session-read-only=mi-api GET https://api.example.com/profile

Las sesiones son persistentes entre ejecuciones. Esto es brutal para trabajar con APIs que requieren login primero y luego múltiples llamadas autenticadas. Te ahorras tener que pasar el token en cada comando.

5. Plugins: extiende HTTPie (v3.0.0+)

Desde la v3.0.0, HTTPie incluye un gestor de plugins integrado. Ya no necesitas instalar paquetes Python manualmente:

# Buscar plugins disponibles httpie cli plugins search httpie # Instalar un plugin httpie cli plugins install httpie-edgegrid # Instalar desde GitHub httpie cli plugins install httpie-jwt-auth # Listar plugins instalados httpie cli plugins list # Desinstalar httpie cli plugins uninstall httpie-edgegrid

Hay plugins para todo: autenticación JWT, Akamai EdgeGrid, AWS Signature V4, formatos de salida personalizados… Si trabajas con un servicio que tiene un esquema de autenticación raro, busca primero si hay un plugin para HTTPie.

6. Scraping ligero

Aunque HTTPie no es una herramienta de scraping como tal, puedes combinarlo con otras herramientas para hacer cositas:

# Obtener la IP pública http https://httpbin.org/ip | jq '.origin' # Comprobar el tiempo de respuesta http --timeout 10 https://api.example.com # Seguir redirecciones manualmente http --follow --max-redirects 5 https://example.com

7. Debugging de APIs con `--offline` y `--raw`

A veces necesitas ver qué petición se va a enviar antes de enviarla de verdad. Para eso está --offline:

http --offline POST https://api.example.com/users \ name=Test \ email:=null

Esto te muestra la petición completa (headers, body, método, URL) sin enviarla. Es perfecto para depurar antes de lanzar algo a producción.

Y --raw te permite enviar un body crudo sin procesar:

http --raw '{"custom":"formato"}' POST https://api.example.com/data

8. Response metadata con `-vv` (v3.0.0+)

Si necesitas información detallada de la respuesta (tiempos, códigos de estado, cabeceras de respuesta), el flag -vv te da metadatos adicionales:

http -vv https://api.example.com

Esto muestra información extra que no ves con -v normal, como el tiempo total de la petición, el tamaño de la respuesta, etc.

9. Integración en scripts y CI/CD

HTTPie no es solo para uso interactivo. También funciona muy bien en scripts y pipelines de CI/CD. El flag --quiet o -q suprime la salida coloreada y los mensajes informativos, dejando solo el contenido útil:

# En un script status=$(http --quiet --check-status --timeout 5 \ https://api.example.com/health 2>&1) echo "API status: $status"

El flag --check-status es clave aquí: hace que HTTPie devuelva un código de error distinto según el código de respuesta HTTP, lo que permite usarlo condicionalmente en scripts.

Para un pipeline de CI/CD que verifique que una API devuelve 200:

#!/bin/bash if http --check-status --timeout 10 GET https://api.example.com/health > /dev/null 2>&1; then echo "API responde correctamente" else echo "API caída o timeout" >&2 exit 1 fi

HTTPie for Web & Desktop: el producto comercial

HTTPie no es solo el CLI. El equipo detrás del proyecto ha creado HTTPie for Web & Desktop, una aplicación gráfica que lleva la filosofía de HTTPie a una interfaz visual. Está disponible para Linux, macOS y Windows.

La aplicación incluye: – Spaces y collections: organiza tus peticiones como en Postman – Variables y entornos: cambia entre desarrollo, staging y producción – AI asistido: genera peticiones a partir de descripciones en lenguaje natural – Sincronización en tiempo real entre dispositivos – Modo offline sin necesidad de cuenta

Es un producto SaaS con modelo freemium. La versión gratuita tiene limitaciones, y las funcionalidades avanzadas (AI, sincronización en equipo, collections ilimitadas) requieren suscripción.

¿Mata esto el CLI? Para nada. Son herramientas complementarias. El CLI sigue siendo 100% open source y gratuito. La versión Desktop es para quienes prefieren interfaz gráfica o trabajan en equipo.

Pros y contras: la honestidad brutal

No voy a venderte HTTPie como la solución definitiva a todos tus problemas. Cada herramienta tiene su sitio.

Lo bueno

Legibilidad. La sintaxis natural es una maravilla. Cuando vuelves a un script que escribiste hace meses, entender qué hace es inmediato.
JSON nativo. Manejar JSON sin tener que construir strings manualmente es un acierto.
Colores y formateo. No es superfluo. Cuando estás debuggeando, el color acelera la lectura.
Sesiones. Una funcionalidad que curl no tiene de serie y que es muy útil.
Plugins. Extensible, y con gestor integrado desde v3.0.0.
Nested JSON. La sintaxis key[sub][subsub]=value es adictiva una vez que la pruebas.

Lo malo

Velocidad. HTTPie está escrito en Python, curl en C. Para una petición es irrelevante, pero para scripting con miles de peticiones, curl es más rápido.
No está preinstalado. En cualquier servidor Linux tienes curl. HTTPie tienes que instalarlo.
Dependencia de Python. Aunque el binario standalone soluciona esto, la instalación normal requiere Python 3.7+.
El equipo está centrado en el producto comercial. Las releases del CLI se han ralentizado. La última estable es de noviembre de 2024.
curl + jq le ha comido terreno. Para consultas rápidas donde solo quieres un campo de una respuesta, curl url | jq '.campo' es igual de rápido y no requiere instalar nada.

Comparativa rápida

Aspecto	HTTPie	curl
Legibilidad	Excelente	Aceptable
JSON nativo	Sí	No
Velocidad	Buena (Python)	Excelente (C)
Preinstalado	No	Sí
Sesiones	Sí	No (hay que hacerlo manual)
Plugins	Sí	No
Colores	Sí	No (con terceros)
Ideal para	Testing APIs, debugging	Scripting, descargas, servidores

Alternativas

Si HTTPie no te convence o buscas algo diferente, tienes opciones. Y algunas son muy interesantes.

curl + jq: el clásico que nunca falla

Para consultas rápidas y scripting, es difícil de superar. curl está en todos los servidores que te puedas imaginar, desde una máquina recién instalada hasta un contenedor Alpine mínimo. Si le añades jq para procesar JSON, tienes un combo letal. La pega es que la sintaxis es más verbosa y menos intuitiva, sobre todo para peticiones complejas.

xh: el clon en Rust

Este me gusta especialmente. xh (https://github.com/ducaale/xh) es un clon de HTTPie escrito en Rust que mantiene la misma sintaxis pero es muchísimo más rápido. Si trabajas con muchas peticiones y la velocidad de Python te molesta, xh es tu opción. Además, es un binario único, sin dependencias.

httpie-go: el port a Go

Similar a xh pero en Go. Mantiene la compatibilidad con la sintaxis de HTTPie y es rápido. Eso sí, el proyecto no está tan activo como xh.

Postman / Insomnia / Bruno

Si prefieres interfaz gráfica, estas son las opciones. Postman es el más conocido, Insomnia es más ligero, y Bruno es el más reciente y tiene la gracia de que las colecciones se guardan en texto plano (en lugar de en una base de datos propietaria). Eso sí, ninguno funciona en terminal, así que no compiten directamente con HTTPie.

¿Y REST Client de VS Code?

La extensión REST Client para VS Code te permite hacer peticiones HTTP desde el propio editor. Es muy útil si ya estás en VS Code, pero no substituye a un CLI para scripting o automatización.

Alternativa	Tipo	Velocidad	Sintaxis	Para qué
curl + jq	CLI	Excelente (C)	Verbosa	Scripting, universal
xh	CLI	Excelente (Rust)	Como HTTPie	Peticiones rápidas
httpie-go	CLI	Excelente (Go)	Como HTTPie	Binario único
Postman	GUI	N/A	Visual	Equipos, colecciones
Bruno	GUI	N/A	Visual	Colecciones en texto

Conclusión

Llevo usando HTTPie desde 2018 y, aunque no he abandonado curl del todo (para scripts de automatización sigo usando curl), para mi trabajo diario con APIs HTTPie es mi herramienta principal.

¿Qué me ha hecho quedarme con HTTPie todo este tiempo? La combinación de tres cosas: la sintaxis natural que hace que las peticiones se entiendan de un vistazo, el formateo de la salida que acelera la depuración, y las sesiones persistentes que me ahorran tener que autenticarme en cada llamada. La llegada del nested JSON en v3.0.0 fue un punto de inflexión: ahora puedo construir estructuras complejas sin tener que escribir JSON a mano.

Pero no todo es perfecto. La ralentización de las releases del CLI desde que el equipo se centró en el producto comercial es un hecho. La última estable, la 3.2.4, es de noviembre de 2024. Casi dos años sin novedades mayores. ¿Significa esto que el CLI está muerto? No lo creo. El proyecto sigue activo, los issues se resuelven, y el binario standalone sigue funcionando perfectamente. Pero es cierto que el ritmo de innovación ha bajado.

Si el proyecto te preocupa, tienes alternativas. xh en Rust es un clon casi perfecto que mantiene la misma sintaxis. Y si eres de los que prefiere la velocidad y el binario único, te va a gustar. Pero para el día a día, HTTPie sigue siendo mi recomendación.

¿Deberías usarlo? Si trabajas con APIs REST de forma regular, la respuesta es sí. La curva de aprendizaje es mínima: si sabes HTTP, ya sabes HTTPie. La productividad que ganas es inmediata. Si solo haces peticiones HTTP de vez en cuando, quizás no te compense instalarlo, y con curl + jq vas más que servido.

Yo lo tengo instalado en todos mis equipos. En el portátil, en el servidor de casa, y hasta en la Raspberry Pi que uso como homelab. Y cada vez que veo a alguien escribiendo curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' me dan ganas de presentarle a HTTPie. No porque curl esté mal, sino porque hay una forma más humana de hacerlo 😊

Para que tengas una referencia rápida siempre a mano, aquí te dejo mi cheatsheet con los comandos y operadores más útiles:

Más información,