Bruno: Fast and Git-friendly open-source API client (Postman alternative)

Thank you. As soon as Postman asked for a login I uninstalled it and have been curling from text files ever since. My younger coworkers won't drop Postman though. Maybe this will help them switch.

I find interesting on how on a startup related forum, anything related with not paying is always celebrated.

Can someone explain what Postman or Bruno is for? I know it's something for interacting with apis but why would i use it. I interact with apis a lot with curl or wrapper in my languages but never really needed something else?

Postman story:

Layoff happened, and we didn't yet have our postman software in our list of services to remove employees from. This is not Postman's fault.

One person had "deleted" all his collections and workspaces after the layoff to clear his laptop of all things related to our company. After we got an email from Postman saying our workspaces were deleted, I removed the laid off users. Since I removed the laid off user, the "trash bin" associated with them was also deleted. Postman support restored all the collections but the "environment" was gone. Which was all of our QA test keys, etc...

Our Postman collections are still in shambles after that, and we don't have any employees to manage it anymore. While I totally don't hold Postman accountable - there is definitely a reason why "no-cloud" is a good way to go with these kinds of tools.

Lately Postman suddenly required creating an account to their cloud, to use my five different rest requests from scratchpad. I got annoyed so bad that deleted that piece of cr*p immediately. Never looking back.

Then I found Bruno and fell in love. Thanks for the great work!

Hey everyone, this is Anoop - creator of Bruno. Happy to see Bruno at the top of HN!

I will try to address some common questions in this comment.

Well based on historical experience with Postman and Insomnia most probably Bruno will go the same way once they get enough users hooked in. Especially once a VC gets into the fold.

We will never take VC funding. We received around 10 inbound reach outs from VCs till date and have denied funding from all of them. We will remain independent and I have written about it in detail here https://www.usebruno.com/blog/bootstrapping

I didn't stick with Bruno. I think it was due to not having an equivalent to Postman's pre-request scripts.

Bruno has come a long way, we support pre-request scripts and a lot more

But can it handle oauth2? I had to write a httpie script recently just to test an oauth2 api.

We have released oauth2 support, some rough edges are being polished

Good thing it's open source. Money being involved, I don't have long term hopes for it's openness.

I understand this is a hard problem. We are fully bootstrapped and independent. We earn money via selling the Golden Edition. We will build more developer products in the long term, and the goal is to make even the golden edition features also open source in the future. I am committed to this cause.

History goes in circles. New API client appears, adds features, userbase grows. Forced login is added, users are angry and look for alternative. New API client appears.

I have felt this pain. That's one of the reasons why I denied VC funding and chose to remain independent. Having seen 10 years of this cycle, its enough. We don't want to repeat the same saga.

Some good links where I have discussed about opensource, freedom and monetization

- https://www.usebruno.com/blog/bootstrapping

- https://github.com/usebruno/bruno/discussions/269

- https://www.youtube.com/watch?v=7bSMFpbcPiY

We are also working on standardizing and improving the Bru Lang to bring more features in Bruno. See: https://www.brulang.org/

If you'd like to pre-order the golden edition: https://www.usebruno.com/pricing

Thank you for all the love and kind words, HN!

If you use Emacs, restclient is awesome

https://github.com/pashky/restclient.el

I myself use Paw [0] because it's native to MacOS, but I'm a little bit worried for it's longevity as it being supported by a SaaS business. But so far it's been great to document API for my personal projects.

[0]: https://paw.cloud/

I really like the idea of serializing requests to a Git-friendly text format.

But if we want a Git-friendly text format, why not mimic HTTP/1.1 request syntax as much as possible? Maybe with Jekyll-like YAML front matter for metadata that doesn’t fit?

So for Get Users.bru instead of the current example of:

  meta {
    name: Get Users
    type: http
    seq: 1
  }
  
  get {
    url: https://reqres.in/api/users
    body: none
  }
  
  headers {
    Content-Type: application/json
  }

  ---
  name: Get Users
  type: http
  scheme: https
  seq: 1
  ---
  
  GET /api/users HTTP/1.1
  Host: reqres.in
  Content-Type: application/json

One thing I like doing when working with APIa is to have an echo server at hand.

I.e. something that I can query via curl or via a network library that I’m using, and see in response what kind of request it actually received. It helps me verify that I’m making correct requests (and not misusing curl or a network library).

Currently I google for that and use the first online result that comes up. Is there an open source local equivalent, or does Bruno offer some solution for that?

I have nothing against this app or the other graphical HTTP tools like Postman, Insomnia, etc., as people clearly get value out of them, but personally, I've moved everything over to Hurl --> hurl.dev

- Open source

- Text files all the way down

- Easily understood DSL

- Easily distributed

- Easily versioned

- Fast

Download the executable, copy the two lines below into "first-test.hurl" and you're up and running.

    GET http://localhost:3000
    HTTP 200

Very tempting! But, will there be a lifetime version/license? Would rather pay upfront instead of ending up potentially not really using it much for 2 years.

This makes me think of an alternative that no one seems to be mentioning: http/rest files. They're git-friendly and there are community plugins to operate them from every major IDE.

I believed the standard was created by jetbrains.

https://www.jetbrains.com/help/idea/http-client-in-product-c...

Funny. I just found Bruno two weeks ago after getting fed up with Insomnia and am loving it. It feels like what Postman and Insomnia were when they started. Simple and to the point.

There are a few minor features I miss (being able to bulk edit headers is the main one), but overall I highly recommend it.

Damn, I wasn't sure if I cared about another postman/insomnia like tool, but I saw the cute dog logo, and it sold the tool to me. Maybe I am just silly, but that got me. Congrats to the team for developing it!

Good to see some more open source competition in this space. SoapUI had most of those features some 15 years ago. I never understood why Postman became so popular, my current team even throws money at them.

I just finished watching the introductory video and found the whole concept of PostMan and Bruno disappointing. It's baffling that one has to dive into the code to unearth the appropriate routes—a completely unnecessary and time-consuming endeavour. This process should be automated, ensuring that documentation and code are always perfectly aligned, eliminating any out of sync issues. The endpoints themselves should be directly accessible from automatically generated documentation using tools like Swagger. This isn't just a convenience; it's a necessity for efficient and effective development.

So, what is the utility of tools like PostMan, Bruno and others when one has automatically generated docs with Swagger with which one can interact? As an example, you can check my current project where I have set docs like that (still need to add an endpoint field): https://peacefounder.org/PeaceFounder.jl/dev/schema

Can someone help me understand the difference between the .bru file and an OpenAPI spec (Swagger), aren't they representing the same thing with different syntax?

While we are at it, is there a nice tool to document (foreign) APIs in a collaborative way? Maybe using Markup Language? Shared via Git? There are so many undocumented APIs there, that i use daily and it is good to put my annotations anywhere.

I am using bruno on all my REST projects and the entire team is more than happy. We have bruno file for most endpoints demonstrating basic usage and as soon as something is problematic, someone creates bruno file in the repo and link to it so others can interactively discover what the problem is about. Since its cross platform and doesn't require any kind of on-boarding its joy to use and nobody complained. Previously, people used postman, thunder, curl and whatnot, but now everybody is on the same page. People created all sorts of scripts, such as automatic token refresh, so you jump straight to action. The fact that I can edit it in vscode is also amazing. Thank you.

I really like IDEA's .http files [1]

Very similar idea as Bruno: everything is configured in text, which I always find myself more productive in that full blown GUI where I need to tab from edit text to edit text to get anything don.

[1] https://www.jetbrains.com/help/idea/http-client-in-product-c...

This looks great, and less bloated than Postman but after a few seconds of testing the Linux (Snap) version, I noticed the system file browser opens with what is probably an invalid font (all characters appear as squares).

As well, it would be nice to be able to import my rather large postman collections (an vice versa - provide a collection from Bruno to a Postman user).

Looking forward to when I can switch to this full time.

I created a cli postman test runner 8 years ago due to the pains involved in API testing: https://github.com/hantuzun/jetman

It seems like the API QA developer tooling has still room for disruption.

That looks nice! I stopped using Insomnia after they introduced the forced login to save your collection and wiped all my stored requests…

It looks great. Postman always loses me because I usually only need simple requests and I have to go through a big structure. As a result, it only ever edits one request over and over again, which I have configured correctly.

The key thing about Postman is that I was able to configure my own script to refresh the API token. For the internal API, we have a short-lived "access_token" token (~1 minute) and then a long-lived "refresh_token" (~1 day) based on the user's email address and password. When renewing the token, you receive information about its lifespan. You cannot create a new scratch token every time because you will be rate limited. I put all that logic in Postman hook script.

Making these HTTP requests in Curl – due to token refreshing – is painful.

Will Bruno support this use case?

I've had my eye on Bruno for a while but this issue with path parameters is somewhat annoying. https://github.com/usebruno/bruno/pull/484

It's nice, but variable import from OpenAPIv3 needs a bit of work, compared to Postman and Insomina.

Our OpenAPI spec has something like this:

    servers:  
      - url: https://{host}/api/v2  
        variables:  
          host:  
            default: someserver.example

Check lama2 https://github.com/HexmosTech/Lama2

I am currently looking for a solution to run automated tests on a sql website generator I am working on ( https://sql.ophir.dev )

I wanted to use hurl (https://hurl.dev/), but Bruno's UI seems to be useful while developing the tests... Has someone tried both ? Which is better for automated testing, including when the response type is html and not json?

I am quite partial RapidAPI (previously Paw) but this looks really nice!

Doesn't seem to support advanced stuff like GraphQL, gRPC, WebSockets...

Looks great!

Postman dug its own grave after selling out itself for VC money. The “File over app” philosophy is a direction that we should be supporting after the Post-ZIRP VC money world.

1: https://stephango.com/file-over-app

It may already be the case but it's not clear. If Bruno supported importing Postman collections it would be an easy decision moving across

What, if anything, differentiates an "API client" from an "HTTP client" (HTTP client includes TCP client)

What is required to be considered an "API client"

Perhaps "API client" is "HTTP client" + "JSON parser"

Could "JSON parser" be a separate program

Bruno is awesome. The import from postman thing is really what make the difference - it makes adoption instant (because yes everyone is still running on postman).

Regarding long term strategy, they seems to have a valid (non subscription based) where you can get some very nice premium feature for a one-off licence price (which is the kind of business model we need to support - instead of the madness we have going today with everything is subscription)

I've replaced Postman with Bruno (dekstop app), works great so far! It's nice to put the collection folder in git so I can collaborate with others and commit the changes to the repo.

I tried Bruno not long ago. Have they added request “examples” like Postman has? If those make it into the codebase, I’m switching!

This is exactly what I was looking for, never understood why postman decided to monetize that way

can you tell me where its shortcut is ?

Do you plan on supporting SQL queries? My top 2 would be postgres and snowflake.

Switched from Insomnia around one year ago! Really like Bruno :)

Golden Edition in the pricing page is listed twice, it looks like the middle column should read "Individual plan"

I prefer curl and bash for testing API's, it's less polished, but very flexible and it will never break or require an account.

But for sharing requests in a team an app is nice. I had a good experience with Bruno. Bonus point for easy to store configs.

Bruno has been taking root in our organization (displacing postman).

It was nice to find out about the for-pay golden edition in this thread to support Bruno’s efforts. The feature split for free vs Individuals vs Organizations seems well done.

As feedback to the Bruno team:

for Individuals - I most value the gRPC/websocket, then load-testing

for Organizations - My org would most value central license mgmt

MQTT is in the pipeline? That’s gonna be a huge deal for those of us working on IoT projects that also use REST for service data. I’ll be watching this for sure.

There is also HTTPie which I've mostly been using for its excellent `http` CLI as a modern replacement for curl.

However I recently learned that it also has web and desktop client apps which are pretty great too!

https://httpie.io/

Hurl is better than any of those GUIs. You can version your Hurl files and use them for CI/CD.

I found Bruno after Insomnia adopted the Postman strategy of being cloud first, with a disastrous migration - I momentarily lost all my local projects after an update.

I've been using it for a while and I really like the offline first + git collaboration aspect of it. Only missing Websockets functionality at the moment.

I personally enjoy using restfox, OSS and in browser, it does the job well.

* web app: https://restfox.dev/ * repo: https://github.com/flawiddsouza/Restfox

The source code for Golden Edition features is proprietary.

Here we go again. There are two versions of this tool. One which is "open source" and another that has additional features which are closed source.

Not very "open-source" after all.

I looked into using Bruno ever since Postman enshittened the free client. I ended up just installing the version of Postman pre collections being removed and ignoring the prompt to update.

I'm struggling to remember the reason I didn't stick with Bruno. I think it was due to not having an equivalent to Postman's pre-request scripts. If that could be added, I'd certainly give Bruno another try.

Edit: Another comment has mentioned that Bruno now has (or maybe always had and I just didn't see) pre request scripts.

Take note makers of HN. If you launch a product with this attitude and respect, I will pay for it in a heartbeat.

I’m the principal maintainer at work of a couple hundred bash scripts that use httpie and jq. I don’t have a huge appetite to redo that work… but this certainly seems nicer!

gRPC support is still paid

Looks great

History goes in circles. New API client appears, adds features, userbase grows. Forced login is added, users are angry and look for alternative. New API client appears...

I just block Postman servers in my hosts file and run an old version that still allows offline/anonymous mode. Works perfectly for my needs.

Been using Bruno for a while now and it's done what I need, I'm not doing any thing crazy just testing endpoints with maybe a small bit of scripting afterwards. Very pleasant to use.

Can this read OpenAPI (Swagger) specs and generate calls based on the service description?

I've been using it for a month or so at work and I love how simple and fast it is. I need to dig into the advanced features but it's already useful.

The ability to SCM your "scripts" is so nice.

Does anyone know if it supports mTLS and maybe multiple certificates per domain?

That would be great

Here is why you should ditch Insomnia: https://www.youtube.com/watch?v=eqf9kD2XPn8

I would love to show this to my colleagues, but sadly we don't talk about bruno (/s)

Bruno is great. I'm in the process of moving my team to it. Cli, gui, human readable files. They are hitting all the right points. And it's open source so I don't care if they close up later down the line. It can always be forked like insomnium. I do admit it is rough around the edges (bugs and a bunch of missing features) but there is a lot of momentum right now and devs are working hard. Not long before postman parity.

Insomnia was great. Than they more or less put of 90% of their users by forcing them in their cloud. Did that get any better?

The complaints about postman collection files being hostile to Git collaboration is valid, but I will just say: we managed to cobble together a reasonable workflow, persisting our postman collections in source control, by writing a utility that strips out all the guids that postman needlessly changes every time you do a collection export. We use Newman to run the collections in our CI pipelines, and as the main way to run tests locally.

It’s painful having to do an import/export of the collection from a file every time you want to modify the collection or debug a test, though, and the JSON files are still not entirely diffable/code reviewable even with the guids stripped. But it works - you can collaborate as a team with postman without using their cloud.

But the idea of switching to a tool that actually wants you to work that way is definitely tempting.

Good. Postman and Insomnia have shot themselves in the foot with overly complex UI and a mess of managing your collection of API calls in some horrible format and messing up the whole sync process and the simple ability to run everything offline without login, etc. I would also add that streaming (SSE) support would be great.

The Insomnium (fork of Insomnia) might be a good alternative to compare. https://github.com/ArchGPT/insomnium

Well this is fun to see. After Postman deleted my local data after I declined a cloud account, I started working on my own tool: https://github.com/EvWilson/sqump

Some similar ideas - actually treats the file system as authoritative, runs locally, can share collections via source control with teammates. Difference in this case is that I used Lua as a lightweight scripting layer that I gave all my necessary tools to. So now I have a HTTP toolkit, and some for Kafka as well (which I use a good bit). I’ve been able to use it to replace all my API testing and development, as well as perform some more involved migrations and some dashboard-like actions (e.g. can list out resources and then check failures for each of their IDs).

It’s also just a single binary with the web UI and CLI bundled in, which works more for me. Still early days for the little tool, but hoping it could be helpful for someone else.

This is awesome, the postman collection format is not version-control friendly. I love what Bruno is doing!

I like this a lot. Happy to support any project willing to reject the usual “success story” of selling out to VCs and turning your product into subscription-based SaaS junk.

Funny, i literally wrote an API tester a week ago for my job. It doesn't have a pretty syntax (in fact, it is the opposite of pretty, tests must be written in XML), but it does understand our authentication flow, and is able to not only assert the status codes and the returned json, but also the contents of Excel files, since we do lots of reporting.

I haven't seen anything being able to compare excels. Also, usually test frameworks are aimed at developers (unsurprisingly), not at testers who might not be comfortable in writing scripts (looking at you, Katalon)

This would complete the e2e DX if you could generate SDKs from .bru. Even if it's through a openapi export, I'm sure it will happen eventually.

I'm sure Bruno is still in the 1st phase of enshittification, but at least with local .bru files we can ensure longterm maintainability.

On the other hand, devs are most likely the stingiest individuals on the planet that expect all of their tools to be free. So I respect the team for even releasing it open source in the first place.

The IntelliJ http client is pretty great too (after using both postman and insomnia) if you use IntelliJ already.

Insomnium.

We recently adopted Bruno at our company and I'm very happy with it. Versioning your requests with GIT is great, and the client is really nice as well.

I’ve been happy with Postman, but it has gotten ridiculous lately, and I would ditch it in a heartbeat. It’s so painfully obvious that postman has turned into a money generating corpse. A good API testing tool isn’t rocket science, go forth and eat their lunch :) $9 for a perpetual license is a pretty damn good deal, and a total slap in the face to postman and insomnia, you have my pre-order!

Bruno stores your collections directly in a folder on your filesystem. We use a plain text markup language, Bru, to save information about API requests. You can use git or any version control of your choice to collaborate over your API collections. Bruno is offline-only. There are no plans to add cloud-sync to Bruno, ever.

AMEN! I've been annoyed by Insomnia and Postman for a good while for these reasons exactly. My latest client of use, Thunder client VS Code extension also started pulling the same shit, and I'm cutting it off too.

If you use and enjoy Bruno, please consider purchasing the "golden" edition that should be released in a few days. https://www.usebruno.com/pricing

This looks amazing. Postman is a great tool overall, but definitely seems to have gotten clunky and overly engineered. I don't need so many damn features. 99% of use cases are just hit an api. Will be trying this out immediately!

If you want to:

store REST API requests as files, such that you can git version-control them

may I recommend:

https://marketplace.visualstudio.com/items?itemName=humao.re...

super simple. just requires VS Code.

Im checking out Bruno as well though, looks like a great tool

Looks awesome! Having version controlled api collections is a good enough idea that it makes all other ideas seem a little crazy.

Any idea if the CLI app is available as a standalone? Looks like its a "desktop app + cli” or nothing deal from what I can find.

There was a discussion a while back when the whole insomnia thing happened, where the dev points out how he aims to not go the same route

https://github.com/usebruno/bruno/discussions/269

bruno seems really easy and good, but then.. it doesn't support cookies..

I'm tired of Postman freezing when sending JSONs over a MB in size. I had to purge it from the system a couple times because the tab wouldn't even load on start up making the whole thing unresponsive.

I hope Bruno works better in that regard.

I needed something like this today - was going to download Insomnia but I happened to check HN.

I tried it out; it's exactly what I wanted. Postman, as echoed in previous comments, has gotten out of control with the upsell and the confusing UI.

I bought the pre-order, seems like a good deal at $9, that's nearly the cost of a latte around here and if this works out I'll get a lot more use out of it than a latte.

I just started to use the intellij built-in http client for my quick and dirty curl debugs and I gotta say it's pretty good for my limited needs so far.

how does compare to the rather resources-hog postman? My go-to setup for quick apis was curl with fish, as postman was growing it became so bloated i'd rather stick to my curl.

Why not the .http files that IntelliJ and VSCode have implemented for years now?

This should've become the standard by now.

looks very good! gonna import my postman collection and give it a try. my collections in postman keep disappearing and reappearing since the required account update happened. glad there is an alternative now!

Just one minor note about your website: it breaks the back button.

Is this native or an electron app?

I've purchased the golden copy of Bruno, not just because this is the right way to do software, but also because of the Bru DSL and git-based sharing "everything as code" model.

Meanwhile, I often dev on iPad Pro with keyboard and trackpad, and instead of Postman, Insomnia, etc., I've enjoyed HTTPBot:

- HTTPBot for iOS: https://apps.apple.com/us/app/httpbot/id1232603544

- HTTPBot for MacOS: https://www.httpbot.io/

HTTPBot even supports postman collections and environments including sync with postman, along with GraphQL, Websockets, and response metrics.

Does anyone know of any good guides to getting the most out of these kind of tools? I’m mostly interested in Postman since that’s what we have to use a work.

I make requests with it, have things organized in collections, and use a variable for JWT handling but that’s as fancy as I’ve gotten and I know these tools have a lot more depth than I’m using.

I would love to see more UI done in this style. That is to say treating your business logic as an API and then exposing it publicly to clients on different platforms.

But can it handle oauth2? I had to write a httpie script recently just to test an oauth2 api.

Looks nice! Will give it a try, so I can ditch Insomnia

Just discovered.

Perpetual license - nice. I do not buy software subscriptions for my development tools. Only perpetual. In cases like Postman - sure I'll take free version but I was holding off from doing anything serious with it.

All data local only - even nicer.

Ported couple of requests from Postman. All works.

Congrats. Unless I hit some stones during testing I will be buying license when available

Most likely Postman will go to trash bin very soon

Good thing it's open source. Money being involved, I don't have long term hopes for it's openness.

We recently moved over to bruno (from postman) for integration tests, and have had a great experience so far!

Pros:

- DevEx is great, the experience moving between writing tests through text vs the client is seamless (allows different expertise to collaborate more easily)

- Fast and has all the basic features you’d expect

- Offline first

- Continuous improvements being made

Cons:

- Somehow, if the test fails connecting with the server its a passed test. So watch out for that one! I really hope it gets fixed soon!!

- Would be great to be able to dump the variables after a run through CLI

- Failed outputs from assertions and expects could be a bit more verbose, but it’s mostly likely the result of a dependency I assume

Love the cute puppy logo!

I've been looking for an alternative to Postman since its enshittification. Postman does not even work anymore if it can't reach internet. This looks actually useful and seems to have support for OAuth2 (which is the main reason I use something separate app instead of python/curl + sh etc)