Posting is an HTTP client for REST APIs that runs as a terminal user interface, built for developers who want to craft, store, and run requests without leaving the command line or an SSH session.
What it is
Posting is a terminal-based API client written in Python and built with Textual, giving it a full interactive TUI rather than a plain command-line wrapper. It covers the everyday work of an HTTP client — composing requests, organizing them, adding environments and variables, and inspecting responses — while keeping everything keyboard-driven, which means it remains fully usable when the only access you have is a shell over SSH.
The concrete problem it addresses is that traditional API clients are heavyweight desktop applications whose collections are locked into proprietary storage. Posting stores your requests as simple local YAML files instead, so they are plain text, easy to read, and straightforward to keep under version control alongside the code they exercise. It replaces Postman and Insomnia for teams that would rather manage their request definitions through the same review and commit workflow they already use for source code, and it removes the need to leave the terminal to reach for a GUI client.
Key capabilities
- "Jump mode" navigation for moving quickly through the interface without reaching for arrow keys or the mouse.
- Environments and variables, so the same request can target different hosts and credentials by switching context.
- Syntax highlighting powered by tree-sitter, plus autocompletion while you write requests.
- Vim keys and customizable keybindings, alongside a command palette for reaching functionality quickly.
- Running Python code both before and after requests, allowing scripting around request construction and response handling.
- Two-way curl interoperability: paste a curl command into the URL bar to import it, and export any request as a cURL command.
- Importing existing collections from Postman and from OpenAPI specs, plus user-defined themes and opening requests in
$EDITOR/$PAGER.
Who uses it and how
- Developers working on remote machines who need an API client they can drive entirely over SSH, where a desktop GUI client cannot run.
- Teams that keep their request collections in the same repository as their services, reviewing and diffing changes to YAML request files through ordinary pull requests.
- Engineers migrating an existing workflow, importing their collections from Postman or their service definitions from OpenAPI specs rather than starting over.
- Terminal-oriented developers who prefer Vim keybindings and keyboard-centric navigation, and who want to drop into their own editor or pager for long-form editing of a request.
Getting started
Install it with uv tool install --python 3.13 posting (the uv installer itself is a single curl command on macOS and Linux), or use pipx install posting if you prefer, and then launch it with the posting command.
How it compares
Posting occupies the same niche as Postman and Insomnia but delivers it as a TUI rather than a desktop application, which is what makes it usable over SSH and inside purely keyboard-driven workflows. It is Apache-2.0 licensed and keeps every request in a readable local YAML file, so the collection belongs to you and lives wherever your repository lives instead of inside a vendor's storage format.
When to use it — and when not
There is little operational burden to self-hosting it: it runs locally, stores requests as plain YAML files, and requires no database, object storage, or mail server of its own. It is not the right choice if you need an officially supported Homebrew or NixOS package, since neither is supported at the moment, and you should expect some rough edges — the project carries 76 open issues and asks for Python 3.13 at install time, so a team standardising on an older Python runtime or a packaged distribution may want to wait.
project readme (upstream, from github) — read inline
Posting
A powerful HTTP client that lives in your terminal.
Posting is an HTTP client, not unlike Postman and Insomnia. As a TUI application, it can be used over SSH and enables efficient keyboard-centric workflows. Your requests are stored locally in simple YAML files, so they're easy to read and version control.

Some notable features include:
- "jump mode" navigation
- environments/variables
- autocompletion
- syntax highlighting using tree-sitter
- Vim keys
- customizable keybindings
- user-defined themes
- run Python code before and after requests
- extensive configuration
- open in $EDITOR/$PAGER
- import curl commands by pasting them into the URL bar
- export requests as cURL commands
- import from Postman and OpenAPI specs
- a command palette for quickly accessing functionality
Visit the website for more information, the roadmap, and the user guide.
Installation
Posting can be installed via uv on MacOS, Linux, and Windows.
# quickly install uv on MacOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# install Posting (will also quickly install Python 3.13 if needed)
uv tool install --python 3.13 posting
Now you can run Posting via the command line:
posting
Homebrew and NixOS are not officially supported at the moment.
Prefer pipx?
If you'd prefer to use pipx, that works too: pipx install posting.
Contributing
Contributions are welcome! See CONTRIBUTING.md for guidelines, information on setting up your development environment, and running tests.
Learn More
Learn more about Posting at https://posting.sh.
Posting was built with Textual.