Posting: a terminal HTTP client mid-rewrite, from Python and Textual to a Go binary

Requests live in plain YAML files next to your code

Posting fills the same role as Postman and Insomnia, but as a terminal UI. The design choice that sets it apart is storage: requests are saved locally as simple YAML files rather than in an account or a database. That makes a collection something you can read in a diff, review in a pull request and keep in the same repository as the API it exercises.

Because it is a TUI, it also works over SSH, so you can send requests from a remote machine without forwarding a GUI. Environments and variables are layered, with a dedicated variables screen and autocompletion of variable names in the editor, and `.env` files are part of the configuration it reads. Every request also gets timing information, and responses are kept in a persistent history, so you can go back to what a call returned earlier without re-sending it.

Posting 3 is a Go rewrite on Terma, and it is still beta

The current major version is a different program under the hood. Posting 2 was built in Python on Textual; Posting 3 is a single binary written in Go and built on Terma, the author's own terminal UI library. The go.mod module path is github.com/darrenburns/posting/v3 and requires Go 1.25.5.

Posting 3 is in beta. The two most recent releases are v3.0.0-beta.0 and v3.0.0-beta.1, both published on 2026-10-15, and the Homebrew formula carries the beta in its name:

brew install darrenburns/homebrew/posting@beta

The alternatives are a prebuilt archive for macOS, Linux or Windows from the GitHub releases page, or building with Go 1.25.5 or newer:

go install github.com/darrenburns/posting/v3/cmd/posting@latest

Either way you then start it with `posting`. The consequence of the beta label is practical: if your workflow cannot tolerate rough edges, you are choosing between a beta binary and the older Python release, not between two finished versions.

Posting 3 reads Posting 2 collections, config and .env files

The rewrite does not force a data migration. Posting 3 reads the same collections, configuration and `.env` files as Posting 2, so a directory of YAML requests built with the Python version opens in the Go binary. What changed between the two is covered in the Coming from Posting 2 guide at posting.sh/guide/migrating.

That compatibility matters most for teams that commit collections to a repository. One person can try the beta without breaking the files everyone else uses. It does not mean the two versions behave identically, so anyone relying on a specific interaction should read the migration page before switching, rather than assume every keybinding or screen carried over.

HTTP, GraphQL, gRPC streaming and SSE in one client

Posting covers more than plain HTTP. It sends GraphQL queries and works with gRPC services, including interactive streaming; the Go module depends on google.golang.org/grpc v1.84.0 and bufbuild/protocompile v0.14.1. The repository includes an example gRPC server and collection under examples/grpc with a walkthrough of interactive bidirectional streaming, which is the quickest way to see that feature without your own service.

Server-sent events get a live event log with inspection of JSON payloads. For responses in general, you can search the response text, explore JSON as a collapsible tree and filter it with JSONPath. The 2.11.2 release, published on 2026-10-05, was titled Client certificate fixes, which shows client certificate support was being worked on in the Python line shortly before the v3 beta.

posting remote hands your open session to a coding agent

One feature is aimed at working alongside AI tools. `posting remote` lets coding agents such as Claude Code and Codex send requests through the Posting instance you already have open, while you watch them arrive in the interface.

The effect is that an agent exercising an API does so in a client you can see, with the same collection and environment loaded, instead of firing requests from a shell you are not watching. The repository itself carries .agents/, .codex/ and skills/ directories alongside the source. The limit is that this is a remote-control channel into a running UI: it is useful when you are present to observe, and it assumes you have Posting open at the time the agent needs it.

Posting 2 pins httpx and Textual to exact versions

The Python release, version 2.11.2 in pyproject.toml, requires Python 3.11 or newer and lists exact pins for several dependencies. httpx with the brotli extra is fixed at 0.28.1, and a comment in pyproject.toml explains why: the project monkeypatches httpx's _main.py. textual with the syntax extra is pinned to 6.1.0 and textual-autocomplete to 4.0.6. The console entry point is `posting = posting.__main__:cli`.

The consequence is that Posting 2 does not coexist well with other packages in a shared Python environment that need different versions of httpx or Textual. Installing it into its own isolated environment avoids resolver conflicts. Posting 3, as a single Go binary, does not have this problem at all, which is one concrete reason to try the beta.

Jump mode, a command palette and curl round-tripping

The interface is built for the keyboard. Jump mode lets you press a shortcut, type a label and move straight to any part of the screen. A command palette exposes functionality without memorizing bindings, and keybindings are customizable. Request tabs let you work on several requests at once, and there is header autocompletion and collection search. The mouse is supported too: click, scroll, select text and drag to resize panels.

Getting requests in and out is handled from the URL bar. Pasting a curl command imports it, and any request can be exported as a curl command. Collections can also be imported from OpenAPI, Postman and Bruno. For longer edits, requests and responses can be opened in $EDITOR or $PAGER. Appearance is configurable as well, with 37 built-in themes and support for user-defined ones.

One repository, two codebases to build and test

Contributors work in a tree that holds both versions. The Go side lives in cmd/ and internal/ with go.mod and go.work, and builds and tests with two commands:

go build ./cmd/posting
go test ./...

The Python side lives in src/ and tests/ with pyproject.toml and uv.lock. Its Makefile runs pytest in two passes, first the tests not marked serial with `-n 24`, then the serial tests, and a `test-snapshot-update` target reruns both with `--snapshot-update`. Other targets re-record the README demo through demo/record.sh and regenerate the docs homepage screens with a Go test. The repository was last pushed on 2026-10-16, a day after the second v3 beta, and contributions are welcome under CONTRIBUTING.md. Releases are configured through .goreleaser.yaml.

Editorial conclusion

Posting suits developers who want a Postman-style client inside the terminal or over SSH, with requests kept as YAML in their own repository and support for gRPC streaming and SSE. Anyone who needs a settled release should weigh that Posting 3 is still beta while 2.11.2 is the stable Python line with pinned dependencies. Before switching a team over, check the Coming from Posting 2 guide on posting.sh and confirm which major version each person installs.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. Release notes