There's a workflow I've repeated so many times it hurts to think about it. I'm working on a backend service, I've got a decent OpenAPI spec, and I just want to quickly poke at a few endpoints. So I open Swagger UI.

And then I remember why I hate Swagger UI.

The layout is a wall of accordions. There's no way to filter endpoints. You fill in your auth header, send a request, navigate somewhere else, come back — everything is gone. Every. Single. Time. It's like it was designed for demoing APIs to non-developers, not actually using them.

The obvious alternatives are Postman and Insomnia. Both are great tools! But they're also full GUI applications that take several seconds to launch, sit in your taskbar, and quietly consume a few hundred megabytes of RAM. If you're context-switching between terminal and browser all day, opening a whole separate app just to fire off a quick API call starts to feel like a lot.

One afternoon I got annoyed enough to actually do something about it.

Introducing radar

radar is a terminal API explorer for OpenAPI 3.x and Swagger 2.0 specs. You point it at a spec URL (or a local file), and it launches a Bubble Tea TUI where you can browse endpoints, fill in params and body fields, fire requests, and inspect responses — without ever leaving your terminal.

Why a TUI specifically?

I spend most of my day in a terminal anyway. A TUI is just another tab — it starts instantly, uses almost no memory, and disappears the moment you close the tab. I don't need to alt-tab to a separate app window or wait for Electron to boot up. It's just there.

Plus, if you already have a well-documented OpenAPI spec (and you should), you don't actually need anything beyond what the spec gives you. radar reads the spec and builds the whole interface from it automatically.

What it can do

Browse and filter endpoints. All endpoints are grouped by tag with collapsible sections. Hit / to filter as you type — super handy when you're working with a spec that has 80+ endpoints and you just want the POST /users one.

Edit everything. Path params, query params, headers, cookies, and request body are all editable fields. The body editor supports both raw JSON and structured field mode — toggle between them with Ctrl+T.

Send and inspect. Ctrl+S fires the request. The response viewer shows status code, headers (toggle with H), and pretty-printed JSON.

Persistent sessions, encrypted. This was the big one for me. Every request you make is auto-saved to ~/.config/radar/sessions/ as an age-encrypted file. Next time you open the same endpoint, everything is pre-filled exactly as you left it. Set RADAR_PASSPHRASE in your environment and you won't even see a prompt.

Cookie jar. Non-HttpOnly cookies from Set-Cookie responses are captured automatically and sent on subsequent requests to the same host. HttpOnly cookies prompt you to confirm. You can view and edit the jar from the endpoint list with K.

Global Authorization header. Set it once in the cookie manager and it gets injected into every request that doesn't already have one. No more re-typing your Bearer token.

Saved spec picker. Run radar with no arguments and you get a picker of your saved specs. Add one with a, rename with r, delete with d. Useful when you're bouncing between a few different services throughout the day.

Getting started

One-liner install for macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/shayan-shojaei/radar/main/install.sh | bash

Or if you prefer:

go install github.com/shayan-shojaei/radar@latest

Pre-built binaries are also on the releases page if you'd rather not build from source.

Then just run it:

# Point it at a spec URL
radar --url https://petstore3.swagger.io/api/v3/openapi.json

# Or a local file
radar ./openapi.yaml

# No args → opens your saved spec picker
radar

Key bindings cheat sheet

A few of the ones you'll use most:

Full keybinding reference is in the README.

Under the hood (briefly)

It's written in Go, using Bubble Tea for the TUI layer and filippo.io/age for session encryption. The architecture is pretty clean — one top-level model owns the state and delegates to sub-models for each view (endpoint list, request editor, response viewer). All I/O happens inside tea.Cmd closures so nothing ever blocks the update loop.

I wanted the codebase to stay readable and hackable, so if you're curious about how a Bubble Tea app gets structured at this scale, it might be a decent reference.

Try it out, break it, tell me about it

radar is at github.com/shayan-shojaei/radar and it's fully open source.

If you use it and find a bug, please open an issue. Specific reproduction steps + the spec URL you were using goes a long way. If there's a feature you'd want — better response formatting, auth flow support, something else entirely — open an issue for that too. I'd genuinely like to know what people want out of a tool like this.

And if you want to contribute, the contributing section of the README has everything you need to get a local build running. The codebase is pretty approachable — make run url=<spec> gets you going in under a minute.

If you find it useful, a ⭐ on GitHub means a lot and helps other developers find it.

Built with Go, Bubble Tea, and a healthy amount of frustration with Swagger UI.