Bruno: An Offline-First API Client That Stores Collections in Plain Text

The Problem: Cloud-Dependent API Clients

Postman and Insomnia have dominated API testing, but they push cloud sync and account sign-up. For teams that work on offline networks or that want version-controlled collections, that model is a poor fit. Bruno addresses this by being offline-only and storing collections as plain text files. This matters for engineers who need to audit every change to an API collection, or who work in air-gapped environments. The README states plainly: "Bruno is offline-only. There are no plans to add cloud-sync to Bruno, ever." That is a deliberate boundary, not a missing feature.

How Bruno Stores Data: The Bru Markup

Bruno's core mechanism is the Bru markup language. Each request is saved as a .bru file in a folder that represents your collection. This is not a proprietary binary format or a database. It is plain text, so you can read it, diff it, and edit it with any tool. The README says: "We use a plain text markup language, Bru, to save information about API requests." Because collections live in a folder, you can put them under Git or any version control system. This design makes collaboration a matter of merging files, not exporting and importing. The trade-off is that Bruno has no built-in server-side collaboration features. Everything happens through your existing version control workflow.

Getting Started: Installation and First Run

Bruno is distributed as a binary for Mac, Windows, and Linux, and through package managers. On macOS, you run `brew install bruno`. On Windows, `choco install bruno` or `scoop install bruno` works. For Linux, the README lists snap, flatpak, and apt options. There is also an AUR package for Arch. After installation, you create a collection folder and add .bru files. The CLI, installed via `npm install -g @usebruno/cli`, lets you run collections from the command line. The basic command is `bru run` to execute every request in the current directory. You can target a single file with `bru run request.bru` or a folder with a specific environment using `bru run folder --env Local`. These commands are straightforward and match the file-based model.

The CLI and Docker: CI/CD Without a GUI

Bruno's CLI is a separate npm package, and official Docker images are published on Docker Hub and GitHub Container Registry. The README shows `docker pull usebruno/cli:latest` and a run command that mounts the current directory: `docker run -v $(pwd):/bruno usebruno/cli run`. This is useful for CI/CD pipelines because you do not need Node.js or npm on the host. The images come in alpine and debian variants for linux/amd64 and linux/arm64. That covers most CI runners. The CLI is the same engine as the GUI, so tests written in the IDE run identically in a pipeline. This is a strong point for teams that want to move from manual testing to automated regression checks.

Limitations and Wrong Use Cases

Bruno's offline-only stance is a limitation if your team expects real-time shared collections or a hosted dashboard. There is no cloud sync, so two developers must commit and pull changes manually. That is fine for Git-savvy teams, but it is a barrier for non-technical testers. Another limitation is that the README does not specify which API protocols are supported beyond the general idea of API requests. If you need GraphQL, WebSocket, or gRPC support, you must check the documentation. The Bru markup language is simple, but it may not cover every advanced feature that Postman offers, such as dynamic variables or complex scripting. The README mentions paid versions, so some features may not be in the open source edition. You should verify which features are free before committing.

Alternatives: Postman and Insomnia

The obvious alternatives are Postman and Insomnia, which are also API clients. Postman offers cloud sync, team workspaces, and a large ecosystem of integrations. Insomnia is a lighter desktop client, but it also has cloud features. The key difference is that Bruno is file-based and offline-only. Postman and Insomnia centralize your collections on their servers, which makes collaboration easier but raises privacy and version control issues. Bruno's approach is closer to how developers manage code: everything is in Git. If you need a hosted service with role-based access control, choose Postman. If you want a self-contained client that respects your filesystem, Bruno is the better fit.

Maintenance and License

Bruno is written in JavaScript and licensed under MIT, which is permissive. You can modify and redistribute it, subject to the trademark on the name. The repository is active, with releases in 2026 and a default branch that is not archived. The README includes a contributing guide, so the project is open to external contributions. However, the README also mentions paid versions, which means the open source edition may not include every feature. The trademark is held by the founder, so you cannot call your derivative "Bruno" without permission. The logo is from OpenMoji under CC BY-SA 4.0, which is a separate license. For maintenance, the CLI and Docker images are released on every CLI release, so you can expect regular updates. The cost of upgrading is low if you use the file format, but you should monitor breaking changes in the Bru markup.

Editorial conclusion

Adopt Bruno if you need an offline API client with Git-based collaboration and value data privacy over cloud convenience. Avoid it if your team relies on cloud sync, shared workspaces, or server-side features. Before adopting, verify that the Bru markup covers your request types (GraphQL, WebSocket, etc.) and that the CLI's test runner meets your CI needs. Confirm the MIT license fits your distribution plans and check the paid version's feature boundaries.

Official sources

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