Vayu vs Bruno - two local-first API clients, one with a load engine¶
If you are comparing Vayu and Bruno, the usual dividing lines do not apply. Both are open source, both run entirely on your machine, both refuse to make you sign in, and both keep your work where you can see it. Choosing between them is not a privacy question - it is a question of what you want the tool to do after the request comes back green.
| Vayu | Bruno | |
|---|---|---|
| Execution engine | C++ (native) | Node.js / Electron |
| API client + load test | Both, one app | Client only |
| Load test throughput | Tens of thousands of req/s | Limited by the JS runtime |
| Privacy / offline | 100% local, no account | 100% local |
| Storage | Local SQLite database | Plain-text .bru files in your repo |
| Scripting | QuickJS (pm.* syntax) |
JavaScript (ES6) |
| MCP / agent control | Built in, local, drives the load engine | Official server, wraps the CLI |
| SSE streaming | Live Events view, scriptable, load-tested | Connects, no event UI |
| Mock servers | Collection mock + OAuth issuer + webhook inbox | No |
| Data-driven runs | CSV / TSV / JSON / JSONL | CSV / JSON |
| Proxy / custom CA / client certs | In Settings - four proxy modes, additive CAs, per-host certs* | In Preferences - proxy and CA file; certs per collection |
| Postman collection import | Yes (v2.0 + v2.1) | Yes (via converter) |
| OpenAPI import | Yes (3.1 / 3.0 / 2.0) | No |
| Open source | Yes (dual-license) | Yes (MIT) |
* One asterisk that row has earned. system proxy mode resolves a PAC
script once, against a probe URL, applying that one answer engine-wide
rather than per URL; a headless engine with nothing resolved falls back to
environment-variable pickup rather than to no proxy. Client certificates carry
no qualification any more - they are proven on a wire on all three platforms,
in both PEM-pair and PKCS#12 form. Detail:
proxy settings,
TLS trust and
client certificates.
The native load engine is the difference¶
Bruno's collection runner executes your requests in sequence on a Node.js
runtime - correct for a functional suite, and not built to be a load generator.
Vayu's engine is a separate C++23 process driving a multi-worker libcurl event
loop, which is why a single laptop reaches tens of thousands of req/s and why
the interface stays smooth while it does: the renderer never shares a thread with
the request load. On a loopback target the engine measured 56,880 req/s,
matching wrk (54,280 in the same session) and edging past vegeta - full
methodology and reproduction here. You get that from
the request you already built, not from a rewritten script in a second tool.
Server surfaces, not just a client¶
Vayu also stands things up rather than only calling them. Saved response examples can be served as a live mock of a collection, a mock OAuth issuer covers the auth flows you would otherwise stub by hand, and a webhook inbox captures inbound calls so you can assert on what a third party actually sent you. SSE is a first-class request type with a live Events view, a Stop control, scripts that assert on the buffered events, and event lists restored from history - and streams stay bounded under load rather than buffering without limit.
Both have MCP; they hand the agent different things¶
Bruno ships an official MCP server that wraps its bru CLI, so an agent can run
your collections. Vayu's MCP server runs inside the app on 127.0.0.1:9877 and
exposes 69 typed tools covering inspection, execution, load runs, and
writes over collections, requests and environments. The distinction worth caring
about is the load engine: an agent can start a capped load run and read the
report back. It is gated accordingly - an allowlist that starts empty, caps on
RPS, concurrency and duration, and a write toggle that ships off. See the
MCP reference.
When to choose Bruno¶
Bruno is a good tool, and two of its design choices are genuinely better for some teams:
- You want your API collection in git, as text. Bruno's
.brufiles are plain text in your repository, so requests diff and review like code. Vayu stores the workspace in a local SQLite database and moves it by export - if reviewable-in-a-PR collections are the point, Bruno is built for it and Vayu is not. - You only need a client, and want the smallest one. If load testing, mocks and agent-driven runs are not on your list, Bruno does the client job well without the engine alongside it.
- You are standardising on its CLI in CI.
bruis mature and widely scripted. Vayu's command line drives the engine, but it has no headless CI gate - a parked decision rather than a pending one, since #473 was closed unimplemented. - You prefer an ES6 scripting model to a
pm.*-compatible one, or you are not coming from Postman at all.
Try it¶
Windows:
macOS and Linux: