Resterm
resterm.app- Category
- Developer Tools
- Rank
- No. 383Tools index
- Pricing
- Open Source
- Type
- TOOL
- Use case
- Coding · Software Testing & Quality
- Interfaces
- CLI
- GitHub
- 2.0k stars
- Latest release
- v1.18.1
- Date
About
Resterm is a terminal API client that keeps requests in plain .http files alongside your code. You can send them from a keyboard-driven TUI or run the same files in CI with the resterm run command. It supports HTTP, GraphQL, gRPC, WebSocket and SSE, plus workflows, mock servers and traffic recording.
What it does
An API workbench that treats requests as source code. Each request lives in a plain-text file with comment directives that add loops, conditions, assertions, captured tokens and retries, so a whole login-then-create flow sits in one reviewable file. A terminal interface sends requests and shows responses, diffs, timings and history. The identical files run unattended from the command line or from Go code, and a built-in mock server answers requests locally so a project can be tried without a real backend.
Why it's ranked here
Few terminal API clients carry the same definitions from interactive poking to CI without a rewrite, and this one does it three ways: the interface, a headless command that emits text, JSON or JUnit reports, and a public Go package documented as covered by a compatibility promise through v1. Add Apache 2.0 licensing, no account and no telemetry by default, plus reach into private networks through SSH tunnels and Kubernetes port-forwards, and it is a serious pick for teams that want API checks living next to their code.
What's good
The documentation is unusually precise about failure modes. Redirects to another origin strip credential headers and trim the referrer, and a downgrade from HTTPS to HTTP stops credentials for the rest of the chain. The parser refuses ambiguous input: a duplicated single-value directive is an error, and spaces around an equals sign are rejected so a stray setting cannot flip on by accident. Starting is cheap: one init command writes sample requests plus matching mocks, and a pasted curl command or an OpenAPI spec can be converted into request files.
Tradeoffs
A request file is a program, not a document. The security notes say a file can run shell commands for auth, run JavaScript, read files outside the workspace and write files, and none of that is confined to the project. Script blocks stop after 30 seconds, but script memory has no limit. The directive dialect is large and strict, so a file written for another client may parse with warnings or errors. Prebuilt Linux binaries need a reasonably recent glibc.
How to use it well
Suited to backend developers who already keep API calls in version control and want those same calls to gate a CI job. Start with the init command and the local mock, then tag a smoke set and run it in CI with JUnit output. Go teams can call the headless package straight from their tests instead of shelling out. Treat request files from outside your team like scripts and read them first. It is not a hosted collaboration workspace and has no AI features.
Technical notes+
The binary entry point in cmd/resterm/main.go dispatches subcommands (record, mock, collection, history, init, run) before falling through to the Bubble Tea TUI, and also handles --from-curl and --from-openapi conversion, self-update with a refusal for Homebrew installs, and a SQLite-backed history store whose load failures are logged rather than blocking startup. go.mod pulls in charmbracelet/bubbletea and lipgloss for the UI, dop251/goja as the JavaScript engine, google.golang.org/grpc, coder/websocket, k8s.io/client-go for port-forwards, OpenTelemetry OTLP exporters for @trace, and modernc.org/sqlite (pure Go, no cgo). headless/run.go is a thin wrapper: Run builds a Plan and calls RunPlan, which delegates to internal/runner and converts the result into a public Report. docs/headless.md documents Build/RunPlan reuse, goroutine-safe plans that serialize when persisting state, a 30 second default timeout and 32 MiB response cap. docs/security.md lists what request files can do; docs/request-files.md defines the directive grammar.
Observed
- License
- Apache License 2.0 (LICENSE)
- Language
- Go (go.mod)
- Interfaces
- Terminal UI, CLI subcommands run, mock, record, init, collection and history, and the public Go headless package (cmd/resterm/main.go, docs/headless.md)
- Protocols
- HTTP, GraphQL, gRPC, WebSocket and SSE (README.md)
- Report formats
- Text, JSON and JUnit (docs/headless.md)
- Install surface
- Homebrew, shell and PowerShell install scripts, go install, prebuilt binaries for macOS, Linux and Windows (README.md)
- Import sources
- curl commands and OpenAPI specifications converted to request files (cmd/resterm/main.go)
- Execution scope
- Request files can run commands and JavaScript and read or write files outside the workspace (docs/security.md)
- Account and telemetry
- No account and no telemetry by default; OTLP tracing only when a request opts in (README.md, docs/security.md)
Read from README.md, go.mod, cmd/resterm/main.go, docs/quick-start.md, docs/headless.md, docs/security.md, docs/request-files.md, headless/run.go, _examples/basic.http, LICENSE.
Tags
Tech Stack
Media

Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.