HTTPie Desktop docs

HTTPie Web

HTTPie’s Web app is equivalent to the desktop app, except for certain limitations.

• Go to httpie.io/app
• Or use the short & sweet alias req.new

HTTPie Desktop

HTTPie's desktop app lets you work locally and has a distraction-free interface.

Request method

You need a method to indicate the desired action of your request. You can choose a variety of conventional methods (GET, POST, HEAD, PUT, PATCH, DELETE, OPTIONS).

Default methods

When starting a new request, HTTPie defaults GET and auto-switches to POST as soon as you add a body.

Custom methods

When testing APIs that use unconventional HTTP methods, you can supplement the default list with a method of your choosing.

Select the last option in the method drop-down and type away.

Request URL

You need a URL to indicate the address your request will go to. HTTPie highlights its path granularly for readability.

You can also use the URL for inserting query parameters directly.

Params

If you find yourself manually constructing URLs with querystring parameters on the app, you may appreciate the parameters form for appending them to the URL.

Check the preview to debug the final results.

Default headers

There are a couple of default headers that HTTPie sets.

• Content-Length
• Content-Type
• Host: pie.dev
• User-Agent: HTTPie

These can be overwritten when you manually insert another header with the same name.

Headers auto-complete

HTTPie auto-completes the header names you start typing. Choose the right one from the suggestions, and you're set.

Same-name headers

If you define multiple headers with the same name, HTTPie will merge their values into a single comma-separated header.

Basic auth

Bearer auth

API key auth

For when you need to authenticate requests using API key as a header or a URL parameter.

It's incredibly convenient because it allows you to specify your auth at the collection level and have HTTPie add it to the headers or URL automatically.

Text requests

Any text should be comfortably editable directly in HTTPie, no matter how big. That's why HTTPie accepts any raw text, but also includes built-in support for three leading languages:

• JSON - the lingua franca of modern web services, and also the implicit body text type HTTPie uses by default
• XML
• YAML

Check also the ability to search & replace. It might come in handy.

Form requests

HTTPie takes two form types:

• URL-encoded - for text or text-files only
• Multipart - accepts any file

You can easily switch from one to the other while keeping its content.

File uploads

GraphQL requests

HTTPie has built-in support for crafting GraphQL requests. ← Check the dedicated doc section.

Multi-body

You can specify multiple body types and quickly toggle between them. This feature is useful when a specific API endpoint accepts both JSON and form data, for example.

There's an indicator in the switcher for each body type that has some data specified.

Prettify

To ensure the body of your request is humanly readable and navigable, use the prettify feature. It will automatically format your code so that your brain’s free to do other things.

Look for the wand icon at the bottom of the code editor. Currently available for JSON and GraphQL requests.

GraphQL requests

Under the hood, GraphQL requests are regular POST requests. But HTTPie has built-in support for crafting GraphQL requests to improve your experience when talking to GraphQL APIs.

Choose “GraphQL” as the body type, then specify your GraphQL query and JSON variables separately. You get syntax highlighting and other features specific to each language.

GraphQL schema

HTTPie auto-fetches the schema from the server. That means the app is aware of all the available queries, mutations, and the hierarchy of types, which allows us to boost your productivity with auto-complete and validation.

See auto-complete suggestions as you type, and to invoke the menu manually, press ⌃Space.

Schema auto-fetch

HTTPie auto-fetches the schema using the current request’s URL and authentication. To refresh the schema, select “Update from server” from the new “Schema” menu. And to turn off schema for a particular tab, uncheck “Auto-apply schema.”

Code generation

The preview is very useful for debugging and analyzing HTTP. But also for exploring other languages. Look for the switcher at the bottom left.

Export cURL

You can export code and commands for many other languages and tools, including cURL, HAR, JavaScript, Node, Java, PHP, Objective-C, Swift, Python, Ruby, C#, Go, OCaml, and more.

Export HTTPie CLI

HTTPie for Terminal is still our most beloved child, and we want it to go hand in hand with Web & Desktop. You can generate HTTPie commands in the app:

Open the preview and select the HTTPie option. Check the generated command, and copy it to your terminal or share it with a CLI-first colleague.

cURL import

You can import cURL commands as requests into HTTPie:

This lets you quickly import cURL calls from scripts or import requests from Chrome DevTools. Find the “Import…” option under the + menu in your space library.

cURL import supports for ANSI-C quoting shell syntax (e.g., $'string'). This syntax is used by Chrome DevTools when exporting a request that includes a body as cURL, among others.

cURL shortcut

There’s also a quick hidden shortcut for importing cURL. Just paste a cURL command into the URL field and see what happens.

cURL input mode

Similar to AI-assisted request prompts, you can also manually type a cURL command into the URL field to switch it to cURL mode and import the resulting request:

Postman and Insomnia import

You can import entire collections, environments, and data dump zips from Postman and Insomnia.

1. Export your data from Postman or from Insomnia.
2. Open the import dialog (Library → “+” → “Import…”).
3. Drag & drop the exported file and click “Next…”.
4. Select the target space and click “Import.”
5. Done! Welcome to HTTPie!

Tip: Create a new space during the import to keep things tidy.

Cancel requests

When you send a request and then change your mind, you can still cancel the in-progress transaction.

Request stats

For metadata on your request, check out the time and size info at the bottom of the response panel.

When you hover over it, you get more granular time & size stats.

Copy and download messages

To export messages, copy them using the three-dot menu at the bottom right for a standard format.

Copy the entire message, copy just the headers, or copy only the body.

You can also save a body as a file directly from the client.

Rendered response body

When the server sends back a response type for which there’s a human-friendly preview mode, HTTPie renders the response as if you were in a browser to make it easier to digest.

It’s especially helpful when you’re debugging APIs and get back rich error pages, need to get through a CAPTCHA, etc.

The preview mode is currently available for HTML responses. You can switch back to the source view by toggling it off.

URL options

Clickable links have a subtle underline. When you spot one, control-click (⌘-click on macOS) or right-click it to get a menu with the URL options.

All links allow you to copy and open the URL in the browser. Links in the response additionally offer several shortcuts for creating a new request using the given URL:

• “Create new draft” creates a fresh new draft with that URL.
• “Duplicate as draft” creates a new draft that is a complete copy of the current request (i.e., with all your headers, request body, auth, etc.) while using the new URL.
• “Duplicate in collection” makes a copy of the current request with the new URL next to the original; only available if the current request belongs to a collection.

Relative URLs

Besides complete URLs, HTTPie also makes relative ones (like /api/users) interactive by prefixing the request’s base URL.

Search & replace

In editable code editors, like when editing the request body text, you can additionally perform search & replace. Use the buttons inside the second field to either “Replace” matching occurrences one by one or “All” at once.

RegExp search

Regular expressions (aka RegExps) are a powerful tool for searching for patterns in text, and you can use them for text matching in HTTPie as well.

When searching & replacing using a RegExp, reference matching groups in the replace field using the dollar-group-number syntax, where $0 references the whole match, $1 is the first group, etc.

Filter vs Search

Data filtering and text searching are independent features. You can, for example, filter a massive JSON response and still search inside the filtered output. To do that, simply open both the filter field (⇧⌘F) and the text search field (⌘F).

Multiple spaces

Your journey starts with a single space. But you can sign up and create as many spaces as you need.

When you have multiple spaces, you can easily switch from one to another.

Sidebar library

The sidebar is the home of the space library with all collections, saved requests and drafts.

The versatile ➕ button allows you to create any space content from one place conveniently.

To make it more accessible, you can also invoke a similar menu through a right-click anywhere in the empty space in the sidebar.

Tab system

Tabs have been around almost since GUIs became a thing. For a good reason: they’re great for organization and juggling multiple things simultaneously. HTTPie has them, too.

Use them to have several requests open in a single window.

Spaces and collections also have their tabs. You can manage their nested content and inheritable values.

Just hit the space or collection name in the sidebar, and it opens up.

Saved requests

Saved requests is what HTTPie calls requests nested inside collections, as opposed to drafts.

Moving collections and requests

You can quickly move requests around from one collection to another, either with the intuitive drag-and-drop or through the request’s context menu.

Collections can be moved to a different space as well – no worries if you started at the wrong place. Nested requests will move, too.

Save drafts

To keep a request around permanently and organized, move it to a collection.

Clear all drafts

If you don't need a draft anymore, you're free to delete it. Or clean all drafts at once if you need a fresh start.

Collection auth

If you use collections to group requests to the same API and that API has an authorization process, you only need to set the authentication credentials once and relax from then on.

Set auth at the collection level in the collection tab, and it’ll auto-apply to every request that belongs to it.

If you go to a nested request, you’ll verify the inherited auth and be able to override it if needed.

Space variables and environments

Variables and environments are at the space level in HTTPie. You can use them inside of its nested items.

Defining variables

Define variables inside the current space tab.

Referencing variables

You can use the defined variables from any request or collection within the space using the {{VARIABLE_NAME}} syntax.

Secret variables

Mark a variable as secret, and HTTPie masks its values in the variable list so you don’t accidentally share them on a Zoom call, for example.

See local-only environments below for other advanced ways to deal with sensitive variables.

Debugging variables

It is often helpful to review the full HTTP request with variables already substituted before sending it. To do that, keep the preview panel open.

Undefined variables

If you reference a variable that doesn’t exist, HTTPie marks the reference red and prevents the request from being sent until the variable is declared. This way, you never have to deal with confusing results.

Recursive variables

You can reference a variable from another variable’s value. HTTPie resolves variables recursively to help you keep your spaces DRY.

Environment structure

An environment is a named set of variable values. In the environments table, rows represent variables, columns represent environments, and inner cells are specific values for a variable in a specific environment. So once you declare a variable, it exists in every environment in the space (possibly with differing or empty values).

Defaults environment

Every space starts with an empty environment called “Defaults.” It works as a regular environment, and you can use it exclusively for simple use cases.

When you create additional environments, they use values from Defaults for variables where you don’t explicitly specify a custom value. If you don’t need a default value for a variable, you can simply leave its value in Defaults empty.

Local-only environments

If you want to prevent some data from syncing to the HTTPie cloud and across your devices, you can store it as values in a local-only environment.

When creating an environment, select the option to create a local-only one, and its values will never leave your device.

No environment

In some situations, you might want to temporarily prevent requests from accessing your variables altogether. By selecting the “No environment” option, you can achieve just that:

Currently, this option is most useful for debugging your requests. But, because variables can contain sensitive data, the importance of this feature will grow as HTTPie continues to add various import and sharing mechanisms.

Duplicate requests

You can duplicate requests inside their collection as well as open them as a new draft for some ad-hoc testing.

Duplicate collections

You can also duplicate whole collections for fast reuse.

Duplicate environments

Environments are duplicable as well, as local or synced.

Incognito

You can use HTTPie for Web & Desktop without an account. When you are not logged in—when you’re incognito—you still have access to most features apart from sync, creating new spaces, etc.

The incognito mode works with local storage. When you decide to log in or sign up, we sync your incognito space into your account, and you can continue to work uninterrupted.

Account

You can create an HTTPie account to unlock various benefits like:

• Unlimited spaces
• Secure cloud backup of your data
• Real-time sync across your devices
• AI assistance

Real-time sync

As long as you have an account and you're connected to the Web, your data is backed up to our secure cloud and synchronized across your devices.

When you change something, it’s instantly updated on your other clients. Start working in the Web app, switch to the Desktop app, and check some request details on your phone later.

Data security

All synced data is encrypted at transit between the HTTPie cloud and clients (SSL) and at rest in a backed-up AWS RDS storage with redundancy (AES).

All sensitive data—your requests, auth credentials, variables, etc.—are additionally encrypted at the server-side before storage and decrypted on client access (AES).

Offline

You might be wondering, can I still test my local API on a plane trip if I need to? Sure thing! HTTPie works offline first.

You can continue to work as usual when your computer is offline (or our cloud is temporarily down). HTTPie simply continues to persist your data in local storage and resumes syncing once the connection is restored.

Auto-save

You don’t have to worry about hitting save because HTTPie continuously auto-saves your work.

Auto-updates

The desktop app downloads new versions automatically, even though you don’t have to install them right away.

You can check for updates and see the app update status straight in the profile menu. This makes it easy for you to have the greatest and latest version of HTTPie always installed.

Check for updates

Select "Check for updates…" in the profile menu.

See your app version

Select "Check for updates…" in the profile menu. Given you are up-to-date, your current version will be displayed.

Required updates

The auto-update system is integrated with sync, and the update status in the profile menu will tell you when an update is required to maintain compatibility with the HTTPie cloud.

Redirect behavior

Auto redirects is the most common behavior in graphical HTTP clients (from browsers to API testing tools). HTTPie has adopted them as well: when you make a request to http://httpie.io/hello, for example, HTTPie for Web & Desktop will now follow the redirect to https://httpie.io/hello.

Suppose that’s not something you want, and you prefer the default no-follow behavior from HTTPie for Terminal instead. No worries, you can disable this option.

SSL validation

By default, HTTPie verifies the server SSL certificate and rejects self-signed, expired, and non-matching certificates. Still, you can disable this validation:

When you run into an SSL error and wish to allow invalid certificates temporarily, you can do that straight from the response view:

Turn it on again from the settings when you’re finished.

Mobile and touch support

The app is 100% responsive (both Web and Desktop), and you can use all features on touch devices as well.

Mobile-friendliness is one of those features that you don’t need most of the time. But when you need it, you really need it. And with HTTPie, you can get work done comfortably from anywhere, anytime.

Global keyboard shortcuts

These shortcuts are available on the desktop today, and we’ll bring a version of them to the Web over time.

Request keyboard shortcuts

You can use these shortcuts when a request tab is open.

Code editor shortcuts

These shortcuts are available in the body editor and the preview, request, and response panels when the textarea or search field has focus.

AI assisted requests

HTTPie AI assistant uses artificial intelligence to allow you to create requests using human language.

You can type your prompt directly in HTTPie’s URL field. It’s similar to typing a search query in your browser’s address bar instead of the exact URL.

Alternatively, you can open the HTTPie AI dialog from the “+” menu in the library. In the desktop app, you can also use ⌘I. There’s a difference in that when you start in the URL field, accepting the generated request will update the one in the current tab instead of creating a new one.

Then hit “Generate” to get a suggestion.

If you like the request, save it. The saved request automatically gets a short name generated by the AI. If you don’t like it, you can hit “Generate” again, which often produces a different result. You can also try editing the prompt. If the request includes any placeholders or obvious errors, you can modify it straight from the dialog before saving it (or you can do that after).

There are two strategies for writing HTTPie prompts: describing the request and describing the intent.

Describing the request

You can ask the AI to generate an HTTP request by describing its low-level components like the URL, headers, and body:

Generate an array of 3 blog posts with title, author, and summary and post it to localhost 3000 api as user agent HTTPie AI

Describing the intent

For actions involving public APIs of popular services, you can describe the high-level tasks you want to accomplish:

List GitHub users

Here is another example where the model picks up that we mean a GitHub repo:

Fetch last release details of httpie/desktop

App theme

Regarding user interfaces, one of the never-ending debates is about dark theme vs. light theme. Whatever side you are on, you can feel right at home in HTTPie.

Find the theme switcher in the settings, where you can stay with the default dark theme, switch to the light one, or have the app automatically adjust to fit your system theme.

Layout customizations

HTTPie's panel system is constantly growing more customizable.

You can choose to show or hide the library sidebar.

You can turn on or off the preview panel on the button at the right of the request form tabs. Depending on your window size, it will be open before the response panel; otherwise, it will open on top.

You can expand and collapse collections and drafts in the library sidebar as you wish. (However, HTTPie automatically expands the collection when you activate the request's tab.)

Furthermore, you can choose your preferred panels' width by clicking and dragging the panel dividers to make them wider or narrower—the same for the sidebar.

Reordering

HTTPie orders each item by the creation time by default. But you should fully own your organization, right?

In addition to moving requests between collections, you can drag-and-drop them to reorder them. And you can reorder collections as well.

Also, drag-and-drop tabs and place them in your preferred order.

And do the same to reorder any form or table item.

Except for environment reordering, where you can use the shift left/right menu items.

Naming

Part of keeping a space organized is naming each item; it helps to recall and differentiate them.

With a double click, you can rename an item through its tab or the sidebar library. Simple!

But then comes the complicated part: picking a good name. Here are two tips:

• HTTPie shows the HTTP method next to the request name. The <method> <name> pair works nicely as a <verb> <noun> sentence.
• An emoji can be worth a thousand words 😜.
• If you choose not to name a request, the URL will be used dynamically to identify it.

Icons

A picture is worth a thousand words. You can use icons to give your projects a personal touch and help you orient in your workspace at a glance without taking up much screen real estate.

Customize a space or collection with an icon and color when creating or editing a space or collection.

Unified code style

We designed the new HTTPie brand with the incredibly talented team at Koto. Part of the brand is an extended product palette, which we—as a developer tools company—designed with beautiful code syntax highlighting in mind.

Below is a page from our style guide and an example of how it cascades down through a Tailwind CSS config to our design system and to the product:

This way, you’ll have a consistent experience across all HTTPie apps.

Refined cursor system

We like to simplify things, a lot. For example, let's look at the cursor system.

Pointer cursors were invented to indicate links on the Web. It is tempting to adopt them for all active elements in apps that use web technologies, like we initially did. However, after a thorough research, we decided to say goodbye to pointer cursors.

We continue to use them for elements that are actual web links. But just like modern native apps, you’ll now see subtle hover effects and regular cursors for all other active UI elements instead. This makes the UI feel quieter and the experience more pleasant.

Contextual dialogs

When you’re in the flow, you do things somewhat automatically. That’s great; HTTPie users should be fast and productive. Some sensitive actions, though, need special attention and care – e.g., deleting something.

That’s why the confirmation modals are contextually informative, to make you fully aware of what you are doing and ensure that’s what you want to do.

Tooltips

There are tooltips all around to help you understand the interface, provide help, and let you peek at the content inside a hidden element.