Alternatives to Bruno
An API client that saves collections as plain files in a folder, so Git handles the sharing instead of a cloud account. The listings below can replace it for an important use case. Each note says what changes if you switch.
The original
Bruno
An API client that saves collections as plain files in a folder, so Git handles the sharing instead of a cloud account.
Replacements
Listings that take over the same core job as Bruno.
Postman
The most widely used API client, for sending HTTP requests, organising them into collections and sharing them with a team.
Postman is closed source and built around a cloud workspace with an account effectively required, but offers documentation generation, mock servers and a browser version.
Insomnia
An API client for REST, GraphQL and gRPC that can keep everything local or sync through Git instead of a cloud.
Insomnia is Apache-2.0 open source with Local Vault and Git Sync, adds an OpenAPI editor and mocking, though most features expect an account.
Yaak
An offline-first API client for REST, GraphQL, gRPC, WebSockets and SSE, with requests stored as files you can commit to git.
Yaak is also MIT licensed and stores requests as files for git, with no telemetry and secrets kept in the OS keychain.
Hoppscotch
A fast API client that runs in a browser tab, with a self-hostable workspace if you want one.
Hoppscotch runs in a browser tab or self-hosted, is lighter than Electron clients, but has fewer testing and mocking features.
Kreya
Desktop client for gRPC, REST, GraphQL, WebSocket and SSE APIs.
Kreya keeps Git-friendly local project files and has strong gRPC reflection support, but it is not open source and some features need a paid licence.
Thunder Client
Lightweight REST and GraphQL client built into VS Code.
Thunder Client runs inside VS Code and JetBrains editors with repository file storage, but is closed source and supports only REST and GraphQL.
RapidAPI for Mac
Native macOS HTTP client, formerly Paw, with code generation and team sync.
RapidAPI for Mac is a free native macOS application with code generation, but it is macOS only and closed source.
Requestly
An API client for designing and testing APIs, plus a browser HTTP interceptor for modifying requests.
Requestly stores collections as local JSON files for Git, imports from Postman in one click, and adds a browser interceptor, though it is closed source.
Also worth comparing
These listings name Bruno as their own alternative, so the relationship runs both ways.
Altair GraphQL Client
A GraphQL client for writing, sending and debugging queries on desktop, in a browser extension and online.
Bruno supports GraphQL, REST, gRPC and WebSocket as a desktop client storing collections as plain files for Git, with no browser extension or web version.
Apifox
An API platform for designing, debugging, mocking and testing APIs, with desktop and web clients.
Bruno is open source under MIT and keeps collections as plain files shared through Git, offline only, but lacks the built-in design and mocking features of Apifox.
EchoAPI
An API client for designing, debugging, load testing and documenting APIs, compatible with Postman scripts.
Bruno is an MIT-licensed desktop client keeping collections as plain files for Git, with a command line runner, and commits to never adding cloud sync.
Evans
An interactive command-line gRPC client with a REPL mode for exploring and calling services.
Bruno is a graphical desktop client handling gRPC, REST, GraphQL and WebSocket, keeping collections as plain files for Git sharing.
Firecamp
An open-source API client for testing REST, GraphQL, WebSocket and Socket.IO requests in the browser.
Bruno is an open-source MIT desktop client that stores collections as plain files shared through Git, covering REST, GraphQL, gRPC and WebSocket but not Socket.IO.
grpcui
A command-line tool that opens an interactive browser interface for sending requests to gRPC servers.
Bruno is an MIT-licensed desktop client for gRPC, REST, GraphQL and WebSocket, storing collections as plain files so Git handles sharing.
grpcurl
Call gRPC services from the terminal using JSON input.
Bruno is an MIT licensed desktop client with gRPC support and file-based collections, plus a command line runner for continuous integration.
httpYac
A command-line and VS Code client for sending HTTP, GraphQL, SOAP and gRPC requests from files.
Bruno is a graphical desktop client that stores collections as plain files for Git and includes a CLI runner, though its Bru format is Bruno-specific.
Hurl
Write HTTP requests and response checks in plain text files.
Bruno keeps collections as plain files in Git with a desktop GUI and command line runner, though its Bru markup is Bruno specific.
Milkman
An extensible open-source desktop workbench for sending requests and inspecting responses across many protocols.
Bruno is open source under MIT, keeps collections as plain files shared through Git, and covers REST, GraphQL, gRPC and WebSocket, though some team features are paid.
Newman
A command-line runner that executes Postman collections outside the Postman app.
Bruno provides a command line runner for continuous integration, with collections kept as plain files in Git instead of Postman collections, and is open source under MIT.
ReqBin
An online tool for sending REST and SOAP API requests directly from the browser.
Bruno is an MIT-licensed desktop client that saves collections as files for Git and sends requests locally, so private endpoints are easier to reach than from ReqBin servers.
REST Client for VS Code
A Visual Studio Code extension that sends HTTP requests written in .http files and shows responses.
Bruno is a standalone MIT-licensed desktop app that keeps collections as files for Git, adding GraphQL, gRPC and a CLI runner, but uses its own Bru format.
RESTer
A browser extension for Firefox and Chrome for crafting and sending HTTP requests.
Bruno is an open-source desktop client storing collections as plain files shared through Git, adding GraphQL, gRPC and a CLI runner, but it is Electron-based and heavier.
Restfox
A lightweight, offline-first open-source HTTP client that runs in the browser and on the desktop.
Bruno is an MIT-licensed offline desktop client storing collections as files for Git, with a command line runner for CI, but it is heavier as an Electron app.
Scalar API Client
An open-source, OpenAPI-aware API client for sending and testing HTTP requests, from the Scalar API platform.
Bruno is an MIT-licensed offline desktop client saving collections as files for Git, supporting REST, GraphQL, gRPC and WebSocket with a CI runner.
Slumber
A terminal user interface HTTP and REST client that runs requests from collections defined in YAML.
Bruno moves to a graphical MIT-licensed desktop app while still storing collections as plain files in Git, adding GraphQL, gRPC and WebSocket support.
Step CI
An open-source API test automation framework that runs multi-step workflows written in YAML, JSON or JavaScript.
Bruno pairs a desktop client with a command line runner for continuous integration, storing collections as plain files in Git, and is open source under MIT.
Testfully
An API client for building, testing, documenting and monitoring APIs, usable offline or with cloud storage.
Bruno is open source under MIT and offline only, keeping collections as plain files shared through Git rather than offering optional cloud sync or monitoring.
Warthog
A cross-platform desktop GUI client for calling and testing gRPC services.
Bruno is an open-source MIT desktop client covering gRPC plus REST, GraphQL and WebSocket, storing collections as plain files shared through Git.
WebSocket King
A web-based client for connecting to, testing and debugging WebSocket servers.
Bruno is an open-source MIT desktop client supporting WebSocket, REST, GraphQL and gRPC, with collections kept as plain files shared through Git.
Similar software
Related functionality, not a direct replacement.
HTTPie
Human-friendly command line HTTP client with colourised output.
curl
Command-line tool for transferring data with URLs, supporting dozens of protocols.
Swagger UI
Renders an OpenAPI description as interactive, testable documentation.
