# Restish v2: A CLI for REST APIs and OpenAPI Workflows > Restish is a Go-based command-line client for making HTTP requests, discovering OpenAPI descriptions, generating API-aware commands, handling authentication, filtering responses, following pagination, and running plugins. It is most useful for developers and technical users who want repeatable terminal workflows without maintaining a separate script for every API. **rest-sh/restish** — Restish is a CLI for interacting with REST-ish HTTP APIs with some nice features built-in - Repository: https://github.com/rest-sh/restish - Website: https://rest.sh/ - Stars: 1,387 · Forks: 108 - Language: Go - License: MIT - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/rest-sh-restish ## Restish v2 targets terminal-first API work Restish solves a practical problem: making useful HTTP calls from a terminal without repeatedly assembling headers, content types, pagination logic, output formatting, and authentication commands. Its scope includes generic requests to REST-ish APIs, not only APIs built around a particular framework. The README describes default handling for headers, content types, retries, caching, TLS, and output, which makes it relevant to ad hoc requests as well as repeatable scripts. The intended users are developers, operators, and technical teams who interact with APIs from shell sessions. Restish can generate API-aware commands after discovering an OpenAPI description, then attach help, profiles, authentication, and shell completion to that API. It also supports response normalization and filtering, so a user can inspect selected fields without building a separate parser each time. The project is broader than a curl wrapper, but it is narrower than an API development platform. It does not create or host an API. It also does not replace a client library inside a production application. Its value is at the command line, where API interaction needs to be quick, readable, and repeatable. ## How Restish moves from HTTP requests to API commands Restish has two related modes. The direct mode sends a request to a URL and lets the CLI handle common HTTP and presentation concerns. The OpenAPI-aware mode discovers an API description and generates commands based on the operations and schemas that description exposes. The README does not document the full discovery algorithm, so the exact endpoint negotiation and specification handling cannot be confirmed from it. After a response arrives, Restish can normalize structured data and pass it through filters. Its documented output formats include JSON, YAML, tables, CSV, NDJSON, lines, gron, images, and raw downloads. This separation between requesting data and shaping its output is useful when the same endpoint must be read by a person, a spreadsheet, or a later command. Pagination is handled as an API concern rather than a user-written loop. The README states that Restish follows pagination links and can stream API data. Profiles and authentication are also part of the API workflow, which matters because repeated manual requests often fail when credentials, headers, or request bodies are not kept consistent. ## Installing Restish and making a first request The README gives three installation paths. On macOS, Homebrew is presented as the simplest managed install. Users who prefer mise can install the latest release through its global package management. For source-based installation, the documented Go module path targets the v2 command and requires Go 1.25.3, as declared in `go.mod`. On macOS with Homebrew, install the CLI and check the version: ```bash brew install restish restish --version ``` The version output should confirm that the Restish CLI is available. The README links to a separate install guide for shell setup, upgrades, and platform notes, so Homebrew is not presented as the only supported installation method. For a source installation using Go, run: ```bash go install github.com/rest-sh/restish/v2/cmd/restish@latest restish --help ``` This command installs the latest tagged v2 release named by the README. The user should confirm that `restish --help` opens the command help rather than receiving a missing executable error. Restish v2 is the active release line, while the README points legacy v1 users to `rest-sh/tap/restish@1` and a v1 upgrade guide. That distinction matters for existing automation because v1 and v2 are not presented as interchangeable release lines. ## Formatting and filtering API responses A first useful request does not require API setup. The README gives `api.rest.sh` as a direct example. A plain request returns the endpoint data directly: ```bash restish api.rest.sh/types ``` For a table containing selected fields, use the documented output and column options: ```bash restish api.rest.sh/images -o table --rsh-columns name,format,self ``` The README's example output presents columns named `name`, `format`, and `self`, with image links in the last column. This is a human-readable view rather than a replacement for the original response. Filtering uses the `-f` option and a shorthand expression. The documented example selects nested fields from the response body: ```bash restish api.rest.sh/example -f 'body.basics.{name, label, profiles}' ``` The README also states that Restish can use jq for filtering. That gives users a choice between its shorthand syntax and the broader jq expression model. The exact normalization rules for every content type are not fully described in the README, so the predictable path is to inspect the endpoint response before relying on a field path in automation. ## OpenAPI discovery, profiles, authentication, and pagination For an API with an OpenAPI description, Restish can turn the specification into API-aware commands. The generated surface includes help, profiles, authentication, and shell completion. This is the main reason to prefer Restish over issuing raw URLs manually. It gives the terminal session a command model that reflects the API rather than only the current endpoint. Profiles address recurring connection and authentication settings. Authentication is treated as a first-class CLI feature, with project topics and source directories including `auth`, `auth0`, `oauth2`, `config`, and OpenAPI-related code. The README links to dedicated authentication documentation, so it does not claim that every OAuth or Auth0 flow is configured by the same mechanism. Users should consult that guide for provider-specific setup rather than infer credentials from the example request. Pagination links can be followed automatically, and API data can be streamed. This reduces repeated shell logic when a service returns a next-page link. The trade-off is dependence on the API's pagination convention. If a service uses an undocumented cursor format, returns no usable next link, or exposes only through a non-HTTP interface, Restish's documented pagination feature may not remove the need for custom code. ## Plugins extend Restish beyond ordinary requests Restish has a plugin system for workflows that do not fit the core CLI. The README names bundled use cases including bulk operations, CSV, MCP, TLS signing, and custom API behavior. Plugins are separate commands in the repository and can be built alongside the main binary. From the repository root, the documented development commands are: ```bash go build ./cmd/restish-bulk go build ./cmd/restish-csv go build ./cmd/restish-mcp go build ./cmd/restish-pkcs11 ``` These commands produce plugin binaries in the current development context, but the README does not specify their installation paths or runtime discovery details in this excerpt. The documentation points to the plugin install and quickstart guides for that part of the workflow. This is a real limitation for evaluating an unfamiliar plugin: the repository identifies the commands, but deployment behavior depends on external documentation. Plugins are useful when a request workflow needs repeated transformations, bulk handling, signing, or protocol-specific behavior. They also add another compatibility surface. A plugin may track the main CLI or an API SDK differently, so adopting one means checking its documented prerequisites and maintenance expectations. ## Restish has boundaries for API debugging and production clients Restish is not the right tool for every HTTP task. Its focus is invoking and organizing REST-ish APIs. A browser-oriented debugging proxy, a network packet inspector, or a specialized client for a long-lived streaming protocol may be a better fit. The README does not claim packet capture, browser integration, or general non-HTTP protocol support. There is also a workflow boundary around OpenAPI generation. If a target service has no usable OpenAPI description, the API-aware command layer may not provide the expected commands. Restish can still make generic HTTP requests, but generated help, schemas, completion, and profile behavior should not be assumed without a description the tool can consume. Another boundary is runtime ownership. A shell command that follows pages and filters output is well suited to inspection and automation. It is not necessarily the place to implement a production data pipeline with custom retry semantics, durable state, or application-level error handling. The README lists retries and caching among built-in defaults, but it does not define every retry policy or failure mode. Those details need verification before Restish becomes part of a critical unattended job. The repository is not archived, and the last push was on 2026-09-29. The listed releases include `v2.3.0` on 2026-06-30, `v2.2.0` on 2026-06-06, and `v2.1.2` on 2026-06-03. That indicates a recent v2 release line, although upgrade impact still depends on configuration, plugin, and authentication changes. The project is released under the MIT License. Review `LICENSE.md` for the repository's license text and verify how your organization handles distribution and dependencies. ## Conclusion Adopt Restish v2 when your work involves repeated interaction with REST-ish services, especially APIs that publish OpenAPI descriptions or return structured, paginated data. Do not choose it as a replacement for a general-purpose HTTP debugging proxy, a full API lifecycle tool, or a platform-specific client whose generated commands do not match your workflow. Verify first that Go 1.25.3 is available for source installs, decide whether Homebrew or mise fits your environment, and confirm that the target API exposes usable OpenAPI metadata if you expect generated commands. ## FAQ ### How do I install Restish v2? The README documents Homebrew installation with `brew install restish`, mise installation with `mise use -g restish@latest`, and source installation with `go install github.com/rest-sh/restish/v2/cmd/restish@latest`. After installation, run `restish --version` or `restish --help` to confirm that the CLI is available. ### What can Restish do with an OpenAPI description? According to the README, Restish can discover OpenAPI descriptions and generate API-aware commands. The generated workflow can include help, profiles, authentication, and shell completion. ### Does Restish support pagination and response formatting? Yes. The README states that Restish follows pagination links, streams API data, filters normalized responses, and renders JSON, YAML, tables, CSV, NDJSON, lines, gron, images, and raw downloads. ## Sources - [License: MIT](https://github.com/rest-sh/restish/blob/main/LICENSE) - [Project website](https://rest.sh/) - [README](https://github.com/rest-sh/restish/blob/main/README.md) - [Releases](https://github.com/rest-sh/restish/releases) - [rest-sh/restish on GitHub](https://github.com/rest-sh/restish) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rest-sh-restish