HTTPie Web

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

• Go tohttpie.io/app
• Or use the short & sweet aliasreq.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 defaultsGET and auto-switches toPOST 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.

Query parameters

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 thepreview to debug the final results.

Path parameters

HTTPie supports path parameters, allowing you to parametrize URL path segments. To introduce a path parameter, use the/:param syntax inside the URL. The “Params” request tab then splits into two sections, one for query params and the other for path params, which is already showing the newly added one.

Rename params directly from the URL or in the “Path params” table. Remove it from the URL to get rid of it. As with variables, you canescape path params with a backslash.

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

Use the Bearer token auth for OAuth 2.0 and other token-based authentication schemes via the request headerAuthorization: Bearer my-token

If you need a different prefix thanBearer, you can achieve that by using the genericAPI key auth instead.

API key auth

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

Text body type

The text request body has these subtypes:

• Raw: Any textual content withtext/plain as the default content type.
• JSON: JSON-specific text editor andapplication/json as the default content type.
• XML: XML-specific text editor andapplication/xml as the default content type.
• YAML: YAML-specific editor andtext/yaml as the default content type.

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

Form body type

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 upload body type

GraphQL body type

HTTPie has built-in support for craftingGraphQL requests.

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 thebody 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.”

Export a space

Invoke "Export…" from a space context menu, optionally customize the selection, and save the data as a JSON file or copy it to the clipboard.

You can open a space's context menu by right-clicking its name in the sidebar or the space tab title. You can also use the three-dot menu inside the space tab.

Export private items

Drafts and local-only environments are not included in space exports by default. These items are always private, so their inclusion in a space export requires an explicit opt-in. To include private items, check the "Show private items" option to reveal them in the space export dialog so you can manually add them.

Export a collection

Similar to exporting a workspace, right-click any collection, select "Export…", optionally customize, save or copy to complete the export.

Export a request

When exporting a request that uses inherited authentication, you'll see an option to embed the authentication in the exported request. Similarly, if the request references variables, you may substitute them by embedding their values.

The JSON format represents requests as full documents. For example, if you've specified a JSON body and switched to a form body, the exported data will contain the inactive JSON body (unless you delete it). Treating the data as adocument instead ofcode means that the request doesn't need to be valid to be exportable in this format, unlike other formats.

Export code snippet

You can also export individual requests as code snippets in many languages using thePreview panel. Available languages include "HTTPie Desktop" format, which provides a real-time preview of how a request is serialized as JSON. This can be helpful when developing tools that are interoperable with HTTPie through the JSON format.

Export cURL

You can export a request as a cURL command using by selecting the cURL option in thepreview or bycopying it from the request context menu.

See alsocURL import.

Export HTTPie CLI

You can export a request as anHTTPie CLI command using by selecting the “HTTPie CLI” option in thepreview or bycopying it from the request context menu.

Copy as command

You can quickly copy requests as cURL and HTTPie CLI commands and access allcode snippet export options directly from a request context menu.

Export an environment

Use the three-dot menu to export individual environments:

Clipboard export

For efficiency, you can copy and paste text instead of dealing with files. Each export dialog offers a "Copy as JSON" action through the copy icon located to the left of the save button.Switch to the "Text" tab inside the import dialog when importing from the clipboard.

This method allows you to easily copy/paste simple exports such as JSON from/to communication platforms instead of downloading and sending files. The text mode import also works for all other import sources, from Postman to cURL.

Selective export

When exporting or importing a space, collection, or environment, you can browse the object hierarchy using the expander buttons to review what is included. For spaces and collections, you can additionally customize the selection. This allows you to export or import a space while excluding specific collections/requests/environments by unchecking them.

Export JSON format

The format is versioned and comes with a JSON schema and TypeScript types. It's designed as a robust solution for backup, simple sharing, interoperability across tools and platforms, and publishing. You can find the schema and types on GitHub:https://github.com/httpie/schema

Import target

You can choose whether to import into a new space or use an existing one. This applies to all import types. Additionally, when importing a whole space into an existing one, you can update some or all of the existing space’s metadata with the ones included in the export (name, icon, and color).

HTTPie Desktop import

You can import JSON files with spaces, collections, requests, and environmentsexported from HTTPie.

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 yourspace 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.

See alsocURL export.

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 toAI-assisted request prompts, you can also manually type a cURL command into the URL field to switch it tocURL 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 datafrom Postman orfrom 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

Toexport 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 newdraft with that URL.
• “Duplicate as draft” creates a newdraft 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 acollection.

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 (akaRegExps) 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 cansign 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 allcollections,saved requests anddrafts.

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 andcollections also have their tabs. You can manage theirnested content andinheritable values.

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

Saved requests

Saved requests is what HTTPie calls requests nested insidecollections, as opposed todrafts.

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 acollection.

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 thecollection 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 andenvironments are at the space level in HTTPie. You can use them inside of its nested items.

Defining variables

Define variables inside theenvironment table in the current space tab. You can also quick-define variables using theautocomplete menu. Just type the new variable name, and choose “Define…”.

When you invoke this action, HTTPie creates the variable and takes you directly to the value input. There, you can quickly provide the value for the currently selected environment.

If you have an existing reference to anundefined variable, you can define it through its context menu.

Variable names

Variables are case-sensitive and may contain only letters, numbers, underscores and dashes.

Referencing variables

Use the{{variableName}} syntax to reference variables from any request or collection within the space. As soon as you start typing a reference, HTTPie shows anautocomplete menu.

You can also quickly copy variable references from the variabletoolbar in the table and then paste them where needed.The same action is also available via the “Copy reference” item in the variable reference contextmenu.

Variable tokens

By default, variable references are presented as interactive tokens that you can interact with as opposed to theirtextual representation:

Variable tokens are implemented keyboard-friendly: You can select one by moving the text cursor with the arrow keys. They can also be copied as text and pasted where needed, etc. Under the hood, they use the existing{{variableName}} syntax that you will still use tocreate variable references.

Variables text mode

You can switch an existingvariable reference token to text mode for editing by double-clicking it or invoking “Edit reference” from the context menu:

Variables autocomplete

As soon as you start typing a new variable reference ({{) or editing an existing one, HTTPie offers suggestions where you can quickly search select an existing variable:

Variables toolbar

In the table with variables, each variable name has a toolbar that allows you tocopy the variable reference,toggle masking, andrefactor the variable name.

Variables menu

The variable reference context menu exposes all your actions on variable references. Invoke it via a right-click (or pressingEnter when a variable reference token is selected):

The menu allows you togo to variable definition,copy variable reference,switch the reference to a textual mode for editing,refactor the variable name,inline the variable value,escape variable reference, and remove the reference with a click.

Go to variable definition

Quickly navigate to the variable definition from a reference using “Go to definition” from thecontext menu.It takes you directly to the value input for the selectedenvironment.

Refactoring variables

You can quickly rename a variable while updating all its usages across all requests and collections in your space. This action is accessible through the variabletoolbar and the variable referencecontext menu:

Inline variable

You can quickly replace a variable reference with its value from the currently selected environment:

Masked variables

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

You can also take a quick peek at a masked variable value using the eye icon from the menu without turning off masking for the variable globally:

Please note that when previewing or exporting a request using thepreview panel, masking is not applied and the full effective request is shown.

See alsolocal-only environments 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 thepreview 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 caused by unexpectedly undefined variables.

Use the “Define” action from the menu to quicklydefine the variable and provide its value.

If you get an undefined variable error while working a string that uses a variable-like syntax but should not be interpreted by HTTPie, you canescape it.

Recursive variables

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

Escaping variables

Use the backslash character (\) to escape strings that look like a{{variable}}, which you don’t want HTTPie to interpret. For example, when you want to pass a Nunjucks-style template as a string in the request body. Simply prefix the variable token with a backslash\{{variable}} or use the “Escape reference” item from the context menu:

If you need to use a literal backslash before a variable, you can escape it with another backslash:\\{{name}} outputs\value.

The special case of outputting\{{name}} cannot be directly supported, but you can work around it by storing the backslash in a variable and using that instead of a raw backslash.

A summary of variable escaping scenarios:

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 duplicaterequests inside their collection as well as open them as a newdraft for some ad-hoc testing.

Duplicate collections

You can also duplicate wholecollections for fast reuse.

Duplicate environments

Environments are duplicable as well, aslocal or synced.

Incognito

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

The incognito mode works withlocal storage. When you decide tolog in orsign up, wesync 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:

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

Real-time sync

As long as you have anaccount 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 theprofile 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 theprofile menu.

See your app version

You can now access the current app version through the help menu. Clicking it copies the version identifier to the clipboard.

You can also see the version when youcheck for updates.

Required updates

The auto-update system is integrated withsync, and the update status in theprofile 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 tohttp://httpie.io/hello, for example, HTTPie for Web & Desktop will now follow the redirect tohttps://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 thelibrary. 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 anddescribing 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 thesettings, 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 thelibrary sidebar.

You can turn on or off thepreview 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 thelibrary 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 tomoving requests between collections, you can drag-and-drop them to reorder them. And you can reordercollections as well.

Also, drag-and-droptabs 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 thesidebar 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 aspace orcollection 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 allHTTPie 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.