ShellYard vs Bruno

Bruno fixed Postman's Cloud problem.
ShellYard fixes the rest of the stack.

Bruno is excellent if you want plain-text API collections committed alongside your code. ShellYard adds what Bruno deliberately doesn't: a 6-engine database inspector, 40+ network tools, SSH-tunneled requests, a vault with KMS, and an AI assistant — in the same window. Most teams run both.

Download free for macOS, Windows, Linux

Free forever · Postman v2.1 import (works for Bruno exports) · No account on Free

Bruno · ~/code/myapp

project files

myapp/
├ src/
├ tests/
└ api-tests/
├ users.bru
├ orders.bru
├ health.bru
└ environments/
└ .git/

git: main

opened health.bru

meta {
  name: health
  type: http
}

get {
  url: https://api.example.com/v1/health
  body: none
  auth: bearer
}

auth:bearer {
  token: {{API_TOKEN}}
}

plain text · diffs in PRs · branches with code

ShellYard · Workspace

sidebar

Connections
└ ssh-bastion-prod
Folders
└ health
Vault
Documents
Databases
Network tools

request health

GET

https://api.lab.internal/v1/health

Tunnel via bastion-prod

200 OK 84 ms

{ "status": "ok" }

next to SSH · DB · vault · docs

Same request. Bruno keeps it in Git. ShellYard keeps it next to the SSH session.

Two tools, two scopes

The honest verdict: use both.

Bruno solves a real problem ShellYard doesn't. ShellYard adds a workspace Bruno deliberately doesn't.

Stay on Bruno (or use it alongside) if

Your API collections must live in Git, diff in PRs, and branch with your code.
You contribute to — or strongly value — open-source tooling.
You only need an API client, nothing else in the same window.
You're a solo dev or contractor — no team workspace concerns.

Add ShellYard to your stack if

You SSH to a bastion to reach internal APIs and you're tired of ssh -L.
You query databases alongside testing APIs and want both in one window.
You want one window for the whole workflow — SSH, HTTP, SQL, network tools.
Your team needs Shared Spaces with RBAC and audit.

Feature-by-feature

The HTTP-client surface you're used to in Bruno, plus the workspace layer Bruno deliberately doesn't have — and the places Bruno still does it better.

ShellYard advantage Bruno advantage Parity

Feature	Bruno	ShellYard
REST (GET/POST/PUT/PATCH/DELETE/…)
GraphQL client
WebSocket
Server-Sent Events (SSE)
Body editor (raw / form / multipart / GraphQL / binary)
Environments + {{variable}} substitution
OAuth2 / Bearer / Basic / API-key auth
Request collections	✓ .bru files	✓ app-managed
Postman v2.1 collection import	✓ (also exports)	✓ (imports Bruno exports)
Works without an account		✓ Free tier, no account ever
Open source	✓ "Fair Source" license (post-2024)	— paid commercial
Git-versioned collections as source of truth	✓ .bru files diff in PRs	— app-managed only
CLI runner for CI/CD	✓ `bru` CLI	— desktop only
Pre-request + post-response scripting	✓ full JS runtime	✓ basic scripts
Self-host the entire tool	✓ — fork it, run it
SSH-tunnel routing per request		✓ Tunnel-via on request / env / collection
SSH / RDP / VNC / Serial / SSM in the same window
Multi-engine database inspector		✓ Postgres, MySQL, SQL Server, Redis, Mongo, SQLite
40+ network diagnostic tools		✓ MTR, packet capture, TLS, SNMP, DNS, syslog…
Local credential vault		✓ AES-256-GCM (Free), KMS-wrapped DynamoDB (Pro+)
AI on responses (BYO key)		✓ Magellan — Anthropic / OpenAI / Gemini / Ollama
Shared Spaces / RBAC for teams		✓ Team+ — read/write/admin roles
Documents / runbooks beside the request		✓ Team+
Pricing	Free, open source	Free / $24 / $49 / $99 — annual prices, locked

Reflects publicly documented Bruno capability at time of comparison.

Where Bruno still wins

If these are load-bearing, keep Bruno.

01

Open source ("Fair Source" post-2024)

You can read every line of code. ShellYard is paid commercial — closed source. If reading the source matters to you, Bruno wins.
02

.bru plain-text format

Collections live in Git. They diff in PRs. They branch with your code. They get code-reviewed. ShellYard's collections are app-managed.
03

bru CLI is first-class

Built for CI/CD pipelines and developer scripting. ShellYard is desktop-only — no equivalent CLI for GitHub Actions.
04

Free, unlimited, no account

No collection caps, no telemetry consent, no email signup. ShellYard's Free tier is generous but capped (1 collection / 25 requests on the HTTP surface).
05

First-class scripting

Pre-request and post-response with a full JavaScript runtime. Heavy scripting workflows live more naturally in Bruno.
06

Self-host the entire tool

Fork it. Run it. Audit it. ShellYard is a hosted-on-your-laptop desktop app, but you can't self-host the source or modify the build.

Plenty of teams run both — Bruno owning the Git-versioned API collections and CI tests, ShellYard owning the SSH-tunneled debugging sessions, the DB queries, and the network workspace.

The verdict: use both

Bruno owns the repo. ShellYard owns the workspace.

1

Keep your .bru collections in your repo.

Bruno owns that surface. Diff in PRs, branch with your code, run them in CI with bru run. Don't change a thing.
2

When you need to hit an internal API behind a bastion — export and import.

In Bruno: Export → Postman v2.1 JSON. In ShellYard: Import → Postman Collection. Folders, requests, auth, and {{variables}} all land intact. Then click the Tunnel-via pill and pick your bastion.
3

Or: open a fresh ShellYard request, pick the Tunnel-via, fire.

For one-off SSH-tunneled debugging that doesn't need to be Git-versioned, skip the import entirely. Save it locally next to the SSH session and the DB query you ran to triage the same incident.

Before you install

The questions a Bruno user asks.

Is ShellYard open source?

No — ShellYard is a paid commercial desktop app. The Free tier is free forever and the source is closed. Bruno wins on this dimension, full stop. If "I can read every line of code" is non-negotiable for your API client, keep Bruno. ShellYard's value sits in the workspace around the request — SSH, DB, vault, network tools — not in the HTTP client itself.

Can I import `.bru` files directly?

Not directly. Bruno can export collections to Postman v2.1 JSON, and ShellYard imports that format natively — folders, requests, auth presets, and {{variables}} all land intact. So the path is: Bruno → Export → Postman v2.1 → ShellYard Import. Two clicks; takes seconds. Direct `.bru` import is on the roadmap but not a near-term priority because the round-trip through v2.1 is lossless for the request surface.

Does ShellYard work without an account?

Free tier: yes, fully — no account ever, no telemetry consent screen, no email collection. Pro and above require a ShellYard account for cloud sync across machines, but the desktop app itself still runs and works without ever signing in. The full SSH / HTTP / network / DB stack runs on Free without any login.

Does ShellYard see my requests?

No. Requests go from your machine, through whatever tunnel you picked (or directly), to the destination API. There is no ShellYard server in the request path. Cloud sync on Pro+ encrypts the collection metadata with AWS KMS in our account — so to be precise, it is not zero-knowledge (we hold the KMS keys) — but the actual HTTP request traffic never transits our infrastructure. On Free, nothing leaves the machine.

CLI runner like `bru` for CI/CD?

No. ShellYard is desktop-only — there is no `shellyard run collection.json` equivalent. If your CI pipeline calls `bru run` on every PR, keep Bruno for that. We don't plan to compete on the CI surface; that's a deliberate scope decision. Most teams running both end up with Bruno owning CI tests and ShellYard owning the interactive debugging sessions.

Pricing — Bruno is free and open source. Why pay for ShellYard?

Bruno: free, open source. ShellYard Free: $0. ShellYard Pro: $24/mo annual. The product scope is different — Bruno is an excellent API client, ShellYard is a workspace that includes an API client. You're not paying for the API client; you're paying for the SSH-tunneled requests, the DB inspector, the vault, the 40+ network tools, and Magellan AI sharing the same window as the HTTP request. Pricing ladder ($0 / $24 / $49 / $99) is locked through launch.

Can I keep my Git-versioned collections in ShellYard?

Not natively. ShellYard collections are app-managed — they live in the app's storage (and on Pro+, sync via cloud). If Git-as-source-of-truth for your collections is non-negotiable — collections diff in PRs, branch with your code, get code-reviewed — that's Bruno's lane and we're not trying to take it. Many teams keep both: Bruno for the canonical .bru files in the repo, ShellYard for one-off SSH-tunneled debugging that doesn't need to be versioned.

Keep Bruno for Git. Get ShellYard for the SSH tunnel.

Install ShellYard. Export one Bruno collection to Postman v2.1. Import. Click Tunnel via, pick your bastion. If it doesn't add something Bruno doesn't, uninstall — no account required on Free.