Running Bruno?

Bruno collection broken or Git diff a mess? We sort it out.

Bruno is a refreshing change if you have been fighting Postman's cloud, and it comes with its own learning curve. Environment variables that leak because the scope was set at the wrong level, .bru files that produce enormous diffs, scripts that break between releases without a changelog nobody reads. We bring the collection into a shape your team can actually version control.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

bruno-collection.log

noisy

What it is

Bruno at a glance

Bruno is an open-source API client that stores requests as plain text .bru files on your filesystem rather than in a proprietary cloud. It was created in 2023 by Anoop M D in response to Postman's move away from local collections, and it has grown into a credible alternative with REST, GraphQL and gRPC support, scripting, assertions and a CLI runner for CI pipelines.

The core is MIT licensed and fully usable offline. The project funds itself through an optional paid tier that adds enterprise features, but the main appeal is that collections live in a Git repository alongside your code, so reviews, diffs and rollbacks work the way engineers already expect.

Type
Local-first open-source API client
First released
2023
License
MIT core, paid tier for enterprise features
Maintained by
Bruno team and open-source contributors
Typically used for
REST, GraphQL and gRPC testing, API collections in Git, CI pipelines for API contract checks

The honest version

Bruno pros and cons

No technology is all upside. This is where Bruno earns its place and where it tends to cause trouble.

Where Bruno is strong

  • Git-native by defaultCollections are plain .bru files on disk, which means pull requests, blame, branches and diffs work exactly like your code repository.
  • Offline friendlyNo account, no cloud, no login screen. You open the app, point it at a folder and get to work, which is a relief after a login-wall experience.
  • CLI runner for CIThe bru CLI runs collections in a pipeline with assertions and JSON reporters, which makes contract tests a normal part of CI rather than an aftermarket add-on.
  • Fast and lightStartup time and memory footprint are lower than Electron-heavy competitors, which matters on older laptops and in long-running sessions.
  • Honest open-source coreThe core is MIT licensed and the paid tier is additive rather than a feature-ectomy. Teams can self-host nothing and still get real value.

Where Bruno bites

  • Ecosystem is youngFewer plugins, fewer examples, fewer Stack Overflow answers. Niche auth schemes or unusual protocols are where this shows most.
  • Environment scope needs careful setupVariables can be set at collection, environment and request level. If scope is not thought through, staging values bleed into dev tests and the same request behaves differently per engineer.
  • Scripting sandbox is restrictedYou cannot require arbitrary Node modules in a pre-request script. For teams coming from Postman's looser sandbox this is a surprise, and some shared helpers do not port cleanly.
  • .bru format is newDiffs are readable once you are used to them, but engineers who open a PR with hundreds of .bru changes have to learn to read the format. Tooling is catching up.
  • Breaking changes between versionsMinor releases have changed script signatures and assertion syntax more than once. A team on auto-update can wake up to a broken CI run on a Monday morning.
  • Team collaboration is Git, not realtimeThere is no live cursor or shared workspace. You coordinate through pull requests, which is a feature for developers and a step backward for non-technical teammates.

Sound familiar?

Common Bruno problems we fix

The Bruno problems that bring people to us, and what you have once each one is fixed.

Environment variable {{apiKey}} not resolved

Environment variables leak or go missing

A variable set at the collection level is overridden by an empty variable at the request level, or a secret is stored in the collection file where every engineer can see it in Git history.

Scope and secrets handled properly

pre-request script threw ReferenceError

Scripts fail after a Bruno upgrade

A script that used to work now throws because the test or req global shape changed in a minor version, or a helper that lived in a previous release was dropped without a loud note.

Scripts aligned with the current API

Git commit staged 42 modified .bru files

Diffs are too noisy to review

Reordering a request, opening a request, or running it with an auto-save on produces changes to the .bru files that look like real edits. Reviewers stop reading the diff.

Collections that diff like code

OAuth 2.0: redirect URI mismatch

OAuth flows fail against IdP

The redirect URI configured in the IdP points at a Postman-style callback, or Bruno's local listener port is blocked by a corporate firewall, so the authorization code never arrives.

OAuth working through Bruno's listener

Bruno CLI: assertion failed in test 'returns 200'

CLI runner fails in CI with no obvious cause

A test that passes locally fails in CI because of a different environment file, a secret missing from the pipeline, or a response shape that only reproduces against production. We make the runs reproducible.

CLI runs that mean what they say

Script sandbox: require('fs') is not allowed

Shared helpers from Postman will not port

A helper script that used Node modules in a Postman environment runs into Bruno's stricter sandbox. Teams that tried to port with search and replace hit this fast.

Helpers re-written for the sandbox

Response size 42MB exceeds max configured 10MB

Large responses truncate without warning

A reporting endpoint returns a large payload, Bruno truncates it to the configured cap, and the assertions on the tail fields go green against truncated content. A quiet failure mode.

Response caps that fit the API

What we do

Bruno help, from setup to upkeep

Call us for one broken OAuth flow, or let us take the Bruno workspace and leave it in a shape your team can review in PRs.

Rescue
Scripts broken after an upgrade, CI assertions red, or secrets committed to Git. We fix the blocker first and clean the history second.
Workspace structure
Collections organised by service, environments scoped so dev, staging and production stay apart, and secrets moved out of .bru files into a proper store.
Git workflow
Diff-friendly file layout, pre-commit hooks that catch secrets, and a review template so PRs for API changes are actually reviewable.
CI runner
Bruno CLI wired into GitHub Actions or your CI of choice, with environment injection, retry handling and reporters that your engineers will look at.
Managed Tech
Ongoing watch on version drift, upgrade reviews before they land in your pipeline, workspace structure kept tidy as new services come online, and a person to call when a flow breaks.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Bruno alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Bruno questions

Something else? Call+1 737 727 7327

Should we use Bruno, Postman or Insomnia?

Each has its angle. Bruno stores collections as plain files in Git, which fits a developer workflow best. Postman has the largest community and cloud collaboration. Insomnia sits in between, with Git sync and a wider protocol surface. If your team already lives in pull requests and does not need a live cursor, Bruno is the strongest fit. We give an honest view based on how your team collaborates, rather than the tool we last deployed.

How do we migrate from Postman to Bruno?

Bruno has an import for Postman collections, and the mechanical move is quick. The real work is scripts, which do not port cleanly because the sandbox is stricter, and environments, which need to be re-scoped because Postman's model is looser. We handle the import, rewrite the scripts and set up a Git workflow in one pass.

Can Bruno run in CI?

Yes, through the bru CLI. You commit the collection and the environment file alongside your code, inject secrets from the CI's secret store, and run against a staging target. The reporter emits JSON that most CI systems can display, and failing assertions break the build the way a unit test would.

Why are our Bruno diffs so noisy?

Usually auto-save is writing cosmetic changes every time a request is opened, or the UI is reordering keys in the .bru file. Turning off auto-save, agreeing a convention for test ordering, and running a formatter pre-commit all reduce the noise. The goal is that a diff only contains real intent.

How do we handle secrets in Bruno?

Keep them out of the .bru files entirely. Use a .env file that is gitignored, or an external secret store with a variable that only resolves at runtime. We add a pre-commit hook that rejects any file with a plausible secret string, so a slip never makes it to the repo.

How much does Bruno help cost?

The estimate does not cost anything. Describe your API surface, the workspace size and how your team collaborates, and we return a figure before any work starts.

Free estimate

Bruno workspace giving you trouble?

Share the collection, the CI config and where the diff turns noisy. A real person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.