DEV Community

Preecha
Preecha

Posted on

Bruno Limitations: What It Can't Do (and What to Use Instead)

TL;DR

Bruno is a strong local API client: fast, open source, MIT-licensed, and git-friendly. But it has workflow gaps that matter for teams: no built-in cloud sync, no mock server, no generated API docs, limited collaboration features, weaker scripting than Postman, no enterprise controls, and no web interface.

Try Apidog today

If your workflow is mostly local request testing and your team is comfortable with git, Bruno can work well. If you need API design, mocks, docs, team workspaces, or role-based access, use a broader API platform such as Apidog, Postman, Insomnia, Stoplight, WireMock, MSW, or Prism depending on the use case.

Introduction

Bruno has earned its reputation. It is fast, open source, MIT-licensed, and stores API collections as plain text files that work well with git. For developers who want a local-first HTTP client without heavy cloud dependencies, Bruno is a practical choice.

The trade-off is scope. Bruno intentionally avoids many features that larger API platforms include. Some teams will see that as simplicity. Others will hit blockers when they need collaboration, mocking, documentation, or enterprise controls.

This review focuses on what Bruno does not provide, when those gaps matter, and what you can use instead.

Limitation 1: No Built-In Cloud Sync

What is missing

Bruno does not include built-in sync for collections across machines or teammates. The core workflow is local-first. Bru Cloud has been announced as an optional paid service, but the main product remains centered on local files.

Typical workaround

Use git as the sync layer:

git clone git@github.com:your-org/api-collections.git
cd api-collections

# Make changes in Bruno, then:
git add .
git commit -m "Update auth request"
git push
Enter fullscreen mode Exit fullscreen mode

Teammates then pull the latest collection:

git pull
Enter fullscreen mode Exit fullscreen mode

This works well when everyone understands git and follows the same branching/review process.

When it becomes painful

This setup breaks down when:

  • QA engineers, PMs, or support teams need access but do not use git regularly
  • You want a quick request change to appear for teammates immediately
  • You switch between multiple machines and expect automatic sync
  • You need to share a request without asking someone to clone a repo
  • Merge conflicts appear in collection files during active API development

What to use instead

If git-based sync is enough, Bruno is fine for developer-only teams.

If you need automatic team sync, use a tool with workspace-based collaboration. Apidog provides optional cloud sync so API collections can stay updated without relying on every user to commit and pull changes manually.

Limitation 2: Git Is the Only Collaboration Model

What is missing

Bruno does not provide:

  • Shared project dashboards
  • Workspace-level roles
  • Request comments
  • Review workflows inside the app
  • Viewer-only access for non-developers
  • Fine-grained access controls for environments or credentials

The collaboration model is essentially:

Bruno collection files → git repository → pull requests / commits
Enter fullscreen mode Exit fullscreen mode

That is useful, but it is not the same as a team workspace.

When it becomes painful

This matters when:

  • Someone changes a shared request and breaks a QA workflow
  • You need to know why a request changed, not just what changed
  • Product managers or technical writers need read-only access
  • Clients need to view API examples without getting repo access
  • Production credentials should be editable only by specific users

What Bruno does well

Git history is a real strength. You get:

  • Author information
  • Commit messages
  • Diffs
  • Branching
  • Pull requests
  • Rollbacks

For engineering teams already reviewing API collection changes through git, this can be a good model.

What to use instead

For team workspaces, viewer roles, and RBAC, use a platform designed for API collaboration. Apidog supports shared workspaces and role-based access, which is useful when non-developers need API visibility without modifying collections.

Limitation 3: No Built-In Mock Server

What is missing

Bruno cannot act as a mock API server. You cannot define a request and tell Bruno to serve a matching mock response.

For example, Bruno can send this request:

GET /users/123
Enter fullscreen mode Exit fullscreen mode

But it cannot host a mock endpoint like:

GET http://localhost:3000/users/123
Enter fullscreen mode Exit fullscreen mode

and return:

{
  "id": 123,
  "name": "Ada Lovelace",
  "role": "admin"
}
Enter fullscreen mode Exit fullscreen mode

When it becomes painful

This is a common blocker when:

  • Frontend development starts before the backend is ready
  • Automated tests need predictable API responses
  • Staging is unstable
  • Service teams need contract testing
  • You want to simulate error states such as 401, 404, or 500

What to use instead

Use a dedicated mocking tool:

  • Apidog Smart Mock for generating mock responses from API specs
  • WireMock for advanced standalone mocking
  • MSW for frontend/browser-level API mocking
  • Prism for OpenAPI-based mocking from the CLI

Example Prism workflow:

npx @stoplight/prism-cli mock openapi.yaml
Enter fullscreen mode Exit fullscreen mode

Then point your frontend or tests at the mock server URL.

The lack of mocking is not hidden or accidental. Bruno focuses on being a local API client, not a full API lifecycle platform.

Limitation 4: No API Documentation Generation

What is missing

Bruno does not generate API documentation from collections. It does not provide:

  • Hosted API docs
  • Public documentation URLs
  • HTML or Markdown documentation export
  • OpenAPI schema generation from collections
  • A docs portal for external developers

When it becomes painful

This matters when:

  • External developers need to integrate with your API
  • Internal onboarding depends on accurate request examples
  • API docs are maintained manually in Notion, Confluence, or Markdown
  • Documentation drifts from the actual API behavior
  • You need a public reference for partners or customers

Practical impact

Without generated docs, teams often duplicate API information:

API request in Bruno
↓
Manual docs in Confluence
↓
Example copied into Slack
↓
Outdated onboarding page
Enter fullscreen mode Exit fullscreen mode

That duplication creates maintenance work and stale documentation.

What to use instead

Use a documentation-focused API tool:

  • Apidog for generating and hosting API docs from specs
  • Stoplight for API design and documentation workflows
  • Redoc or Swagger UI for self-hosted OpenAPI documentation

If your API is already described with OpenAPI, Redoc or Swagger UI can be enough. If you want design, testing, mocking, and docs in one workflow, use a broader platform.

Limitation 5: Scripting Is Weaker Than Postman

What Bruno supports

Bruno supports JavaScript scripts for common automation tasks, including:

  • Pre-request scripts
  • Post-response scripts
  • Variables
  • Request chaining
  • Assertions with Chai
  • Access through the bru namespace

A simple assertion might look like this:

const data = res.getBody();

expect(res.getStatus()).to.equal(200);
expect(data).to.have.property("id");
Enter fullscreen mode Exit fullscreen mode

You can also set variables:

bru.setVar("token", "your-token-value");
Enter fullscreen mode Exit fullscreen mode

What is weaker compared to Postman

Compared with Postman’s scripting environment, Bruno has limitations:

  • Smaller ecosystem of pre-built scripting examples
  • Less extensive documentation around the bru API than Postman’s pm API
  • require() usage is more limited because access to Node built-ins is restricted by default
  • No GUI-based script builder for non-developers
  • Script error messages can be less descriptive

When it becomes painful

This affects teams with:

  • Complex authentication flows
  • Request signing logic
  • Shared testing libraries
  • QA automation built around Postman scripts
  • Non-developers who rely on visual helpers

For example, simple Postman scripts may convert with a namespace change:

// Postman style
pm.environment.set("token", token);
Enter fullscreen mode Exit fullscreen mode 
// Bruno style
bru.setEnvVar("token", token);
Enter fullscreen mode Exit fullscreen mode

But scripts with external dependencies or advanced pm APIs usually need manual rewrites.

Recommended approach

Before migrating a large Postman collection to Bruno:

  1. List all pre-request and test scripts.
  2. Identify scripts using pm.*.
  3. Check for require() usage.
  4. Convert simple variable and assertion scripts first.
  5. Manually rewrite complex authentication helpers.
  6. Run collection-level regression tests after conversion.

Limitation 6: No Enterprise Features

What is missing

Bruno does not provide typical enterprise controls such as:

  • SSO with SAML or LDAP
  • Central admin console
  • Audit logs
  • Compliance exports
  • Fine-grained workspace permissions
  • Credential access controls beyond git/repo permissions

When it becomes painful

This matters in organizations where:

  • IT requires SSO for all internal tools
  • Security teams need audit trails
  • API credentials must be access-controlled
  • Compliance teams need evidence of who accessed what
  • Large teams need centralized user management
  • Finance, healthcare, or regulated environments require stricter controls

Important context

This is a product direction decision, not necessarily a flaw. Bruno is not trying to be a full enterprise API management platform. It is optimized for local, developer-controlled workflows.

What to use instead

Use a platform aligned with your governance requirements:

  • Apidog for teams that need RBAC and shared workspaces
  • Postman Enterprise for broader enterprise API collaboration and governance
  • Insomnia Enterprise for teams already aligned with the Insomnia ecosystem

Limitation 7: Desktop-Only, No Web Interface

What is missing

Bruno is a desktop app. It does not provide a browser-based interface for opening or running collections.

That means you cannot:

  • Open Bruno in a browser
  • Share a live collection URL
  • Run requests from a web workspace
  • Give someone browser-only access to API examples
  • Use it easily on locked-down devices where installs are blocked

When it becomes painful

This matters when:

  • You use a corporate machine where installing apps is restricted
  • You want to share runnable requests with external collaborators
  • Your team uses Chromebooks or thin clients
  • A stakeholder needs read-only browser access
  • Compliance or IT policies prefer web-based tools

What to use instead

If you need both desktop and browser access, Apidog provides both.

If you specifically want an open source browser-based API client, Hoppscotch is worth considering.

Decision Guide: When Bruno Is a Good Fit

Use Bruno when:

  • You want a local-first API client
  • Your team is developer-heavy
  • Git-based collaboration is acceptable
  • You do not need hosted docs
  • You do not need mock servers
  • You prefer plain text collections
  • You want to avoid mandatory cloud sync

Avoid Bruno as your primary API workflow tool when:

  • Frontend teams need mocks before backend APIs exist
  • Stakeholders need browser-based API docs
  • QA teams need shared workspaces
  • You need RBAC or audit logs
  • You rely heavily on Postman scripts
  • You need generated API documentation
  • You need automatic sync across users and devices

FAQ

Is Bruno still worth using despite these limitations?

Yes. Bruno is a strong choice for solo developers and small engineering teams that want a fast, local, git-friendly API client. The limitations matter most when your workflow expands beyond local request testing.

Will Bruno add cloud sync eventually?

Bru Cloud has been announced as an optional paid tier. The timing and final implementation remain separate from the local-first core app.

Can I use Bruno for API design with OpenAPI?

No. Bruno is primarily an API client. It is not an API design tool for writing and validating OpenAPI specs. Use Apidog, Stoplight, or an editor with OpenAPI tooling for API design.

Does Bruno support WebSocket or gRPC?

WebSocket support is limited. gRPC is not supported in the current stable version. If your team depends heavily on gRPC, Bruno is not the right primary tool.

Are there plans to add a mock server to Bruno?

There is no official roadmap item for a built-in mock server as of 2026. Bruno’s product philosophy favors a focused local client rather than a full API lifecycle suite.

How does Bruno compare to Insomnia for teams?

Insomnia includes cloud sync and paid team features, making it closer to Postman in scope. Bruno is more minimal and local-first. If you need cloud sync but do not want to use Apidog or Postman, Insomnia is worth evaluating.

Final Takeaway

Bruno’s limitations are not bugs. They come from deliberate design choices: local-first storage, git-based workflows, and a narrow focus on API requests.

That makes Bruno excellent for some teams and incomplete for others. Before adopting it across a project, check whether you need sync, mocks, docs, collaboration, browser access, or enterprise controls. If you do, choose a tool that supports those workflows from the start.

Top comments (0)