Postman's Free plan now covers one user. The next seat means the Team plan at $19 per user per month, billed annually, and that change has a lot of small teams asking the same question on forums this year: what do we move to?

The usual answer is "something that keeps collections as files in git". That answer is out of date. Postman ships native Git on its Free plan. Bruno keeps collections as files and is moving to OpenCollection YAML. Yaak writes one YAML file per request. Baton has been plain YAML in your repository from the start. The files-versus-cloud argument that most "Postman alternative" pages are still fighting has been settled, and all four tools settled it the same way.

So the question worth asking in 2026 is a different one: once the files are in git, where does the work run, and what can you run it on? That's where these four still disagree.

We make Baton, so read this knowing that. The places where Bruno, Yaak and Postman are the better pick come first, not last.

Competitor facts below were checked against their own pages on 16 November 2026 and are linked. They will drift.

The short version

Baton Bruno Yaak Postman
Collections in git plain YAML, your repo files in your repo one YAML file per request native Git, Free plan
Protocols REST, GraphQL, WebSocket REST, GraphQL, gRPC, WebSocket, SOAP REST, GraphQL, gRPC, WebSocket, SSE REST, GraphQL, gRPC, WebSocket
Desktop macOS, Windows, Linux macOS, Windows, Linux macOS, Windows, Linux macOS, Windows, Linux
Phone iOS, Android no no no
Browser yes no no yes
Open source no yes yes (MIT) no
Scheduled runs a worker you host CLI in your own CI CLI in your own CI monitoring on paid plans
Mock servers from saved responses, via the MCP server yes not listed yes
Account needed no no no yes
Free tier personal use full open-source client personal use one user

Two more free clients belong in the conversation and get their own section below: ATAC and Pororoca.

Where Bruno is the better choice

If you need gRPC, use Bruno or Yaak. Baton does REST, GraphQL and WebSocket, and that's it. If your services speak gRPC and you want one client for all of it, we're not the answer today. Bruno supports it, so does Yaak, and Yaak adds server-sent events. On protocol coverage Baton is last of the four.

If open source is a requirement, use Bruno. A requirement, the kind that comes from a policy or from having been burned by a tool that changed its licence. Bruno's client is open source and ours isn't.

Bruno's pricing gets misread, so it's worth a line. Paid tiers start at $6 per user per month for Pro, then $11 and $18. What they add is more of the Git UI inside the app (pushing, branching, merge-conflict resolution), unlimited OpenAPI syncs, more workspaces, SSO and support. The files are on your disk either way, and git in a terminal is free. A team comfortable on the command line can run Bruno's free tier indefinitely.

Bruno also covers two things that used to be Postman's argument. It has mock servers, including mocks built from response examples, and it documents working with coding agents such as Claude, Cursor and Codex directly on the collection files. They raised $3M and it shows in the release pace.

Where Yaak is the better choice

Yaak is the one most people comparing this category haven't tried yet.

If you want the widest protocol coverage in a local-first client, use Yaak. REST, GraphQL, gRPC, WebSocket and SSE in one workspace, offline, no account. A strict superset of what Baton does.

If you're wiring an API client into coding agents, look at Yaak first. It ships an agent-friendly CLI and an MCP server plugin for Claude, Cursor and others, and changes the agent makes through the CLI show up in the app. That's a deliberate bet on a workflow, and it's well executed.

It's MIT-licensed, imports from Postman, Insomnia, Bruno, OpenAPI and curl, stores secrets encrypted with keys in the OS keychain, and sends no telemetry. Pricing: free for personal use, $79 a year or $349 once for an individual commercial licence, $149 per user per year for business.

Where it stops is where Bruno stops: desktop only, macOS, Windows and Linux, with no phone or browser build, and a CLI rather than a scheduler.

Two more that are free

If budget is the constraint, start here.

ATAC is a terminal client written in Rust, MIT-licensed. Its stated philosophy is "free, account-less, and offline for now and forever", and there's no paid tier. Collections are your own committable JSON or YAML files. If you live in a terminal, this is probably the tool you want. What it lacks: GraphQL and gRPC are not there yet, so if GraphQL is in your stack today, it's out for now.

Pororoca is a desktop client for Windows, macOS and Linux, free and open source. It supports HTTP/2 and HTTP/3, which nothing else on this page advertises, so if you're testing a QUIC endpoint, it's the obvious choice. Its Postman collection and environment compatibility also makes it a cheap way to get a large Postman workspace onto your own disk and look at what's in it.

Both are desktop or terminal only, and neither ships a scheduler.

On that note, Baton's worker has no setting for HTTP/2 or HTTP/3, and the workspace format has no transport-version field. If the endpoint you need to test on a schedule is HTTP/2-only or QUIC, Baton isn't the tool.

Where Postman is the better choice

If you want the ecosystem, stay on Postman. Spec Hub, the API catalogue, SDK generation, Flows, monitoring, SSO and SCIM. We have none of that and aren't building it. For an organisation that governs hundreds of APIs across dozens of teams, that machinery is the product.

For one person, the Free plan is still generous: native Git, mock servers, unlimited Collection Runner runs, $0. Solo is $9 a month. The bill arrives with the second person: Team is $19 per user per month, Enterprise is a sales conversation, and scheduled monitoring sits on the paid plans.

The thing to weigh is not only price. Your workspace lives in Postman's account system. If "where does this data sit, and who can revoke access to it" is a question your security people ask, that's the conversation, and a bigger plan doesn't change it.

Where Baton is different

Three things, and they're narrower than a marketing page would claim.

It runs on a phone and in a browser

Baton runs on macOS, Windows, Linux, iOS, Android and in the browser. Bruno and Yaak are desktop plus CLI. Postman has a real browser client. None of the other three lists a phone app.

This is the one line in the table where Baton is alone. It earns its keep in specific cases: checking a staging endpoint from a phone away from a desk, handing a contractor a browser link instead of an install, an on-call engineer poking one endpoint at 2am from whatever device is nearest. If none of that has been your problem, it's worth nothing to you.

Scheduled runs on a box you own, and the scheduler ships with it

The optional Baton Worker is a small Node service you run yourself. It clones your collections repository, re-checks it every five minutes, and runs collections on a schedule while your laptop is shut.

Bruno and Yaak both have a CLI, and a CLI in GitHub Actions is a perfectly good answer here. For a lot of teams it's the better one, because they already have CI. The difference is who builds the plumbing: with a CLI you write the workflow, the scheduling, the secret injection and the failure reporting. With Baton the worker is what ships, and the schedule is a field in the YAML.

It refuses to start without BATON_WORKER_TOKEN; there's no unauthenticated "local dev" mode.

And the part most comparison pages would leave out: the worker is not free software. It's on npm under a proprietary licence with a small-entity grant. Commercial use is free only while your organisation is under all three of: USD 250,000 ever raised, a USD 250,000 valuation, and USD 1,000,000 annual gross revenue. Over any one of them, commercial use of the worker or the MCP server needs a paid licence. If you're a typical company reading this page, assume you're over the line and price it in.

An agent can edit your requests, and it can't paste a credential into the obvious places

@dudko.dev/baton-mcp is a stdio MCP server that gives a coding agent eighteen tools over a Baton workspace (twenty when the desktop app is open): list, read, create, move and delete requests, edit collections, environments and scripts, stand up a mock from saved responses, and, if you let it, run them. The workspace is plain YAML in your repo, so whatever the agent changes arrives as a diff you review.

Yaak has an MCP plugin too, so this isn't unique any more. Two design choices are what we'd point at.

Execution is off by default. run_request and run_collection refuse until the server is started with --allow-run, and the refusal says so: "runs are disabled: start baton-mcp with --allow-run to let agents execute requests." An agent editing files can't quietly fire live traffic at production.

A literal credential is refused in the three main auth fields. A bearer token of sk-live-… in auth.bearer.token comes back as an error ("auth.bearer.token looks like a literal credential; store it as a secret and reference it as {{name}}") and nothing is written. auth.basic.password and auth.apiKey.value refuse the same way. The check is on the field, not on the shape of the value: hunter2 is refused exactly like sk-live-…, so a credential that doesn't look like one can't slip past.

Now the limit, because "rejected at the boundary" would overstate it. Measured on 0.2.0 today:

auth field literal credential
auth.bearer.token refused
auth.basic.password refused
auth.apiKey.value refused
auth.digest.password written
auth.awsSigV4.secretKey written
auth.awsSigV4.sessionToken written
auth.oauth2.clientSecret written

Outside the auth block nothing is checked: the same literal in a query string, a header value or a JSON body goes to disk. Environment files hold secret names while the values stay in the OS keychain, and responses handed back to the agent mask Authorization, Cookie, Set-Cookie and X-API-Key by value. So the guard closes the fields an agent reaches for first. It is not a promise that the server can't be talked into writing a key down.

The mock server works end to end. Save a response as an example, write a short mocks/<name>.yaml naming a port and collections, and start_mock returns a URL:

GET http://127.0.0.1:8731/one -> 200 {"ok":true,"from":"baton-mock"} GET http://127.0.0.1:8731/two -> 404 {"error":"no example answers GET /two", "known":["GET /one"]} 

That 404 lists what it can answer, which saves ten minutes of guessing.

Fair warning on maturity: it's a 0.2 and it shows. The upsert_request schema describes the request as an opaque bag of keys, so an agent has to discover the twelve fields it needs by trial. Leave any one of them out and you get a TypeError: Cannot read properties of undefined that doesn't name the missing key. An unknown key is dropped silently rather than reported. And a request written outside collections/ is saved but never listed. None of that is dangerous; all of it costs an agent retries.

Secrets and the licence key

Values live in your OS keychain, never in the repo. That's not a difference: Bruno encrypts secrets locally with OS-level encryption or AES256, and Yaak keeps its keys in the OS keychain too.

What is a difference from Postman: Baton needs no account. Registration is free, the key is valid for 180 days, and it's verified offline; the app never calls home. Bruno and Yaak need no account either.

How to decide

Skip the feature table. A few questions settle it.

Does anything in your stack speak gRPC, or do you need SSE? Bruno or Yaak. We don't do either.

Do you need spec governance, SSO, an API catalogue or hosted monitoring for a large org? Postman, and the seat price is the cost of that machinery.

Is open source a hard requirement? Bruno, Yaak, ATAC or Pororoca.

Are you a small team leaving Postman's Free plan over the one-user limit? Every client here keeps your requests in git for free. Pick on the next question.

Do you need it on a phone or in a browser, or would you rather run a small worker than maintain a CI workflow? Yes to either, try Baton. No to both, Bruno and Yaak are both excellent and free for personal use, and you should use one of them.

There's a demo workspace in the browser at baton.dudko.dev, nothing to install. If you read all this and Bruno or Yaak is the right call, use it.

Originally published at https://baton.dudko.dev/blog/baton-vs-bruno-vs-postman.