---
title: "Say Goodbye to Postman's Fee Trap! A Hands-on Guide to Bruno, the Open-Source Git-Native API Testing Powerhouse."
description: "Postman starts charging and cutting features? Try Bruno (usebruno), a fully open-source, lightweight, and Git-friendly API testing tool! This article introduces the powerful Rest Client, analyzes how it solves Postman's pain points, and is a can't-miss new free API testing alternative for developers."
canonical_url: "https://blog.markkulab.net/en/post/bruno-postman-alternative-guide"
author: "Mark Ku"
author_url: "https://blog.markkulab.net/en/author/mark-ku"
site: "Mark Ku's Tech Notes"
date_published: "2026-06-22 22:15:51 +0800"
category: "Tech Sharing"
language: "en"
license: "CC BY 4.0"
license_url: "https://creativecommons.org/licenses/by/4.0/"
attribution: "when reusing or quoting, credit the author and link back to the original"
---

# Say Goodbye to Postman's Fee Trap! A Hands-on Guide to Bruno, the Open-Source Git-Native API Testing Powerhouse.

## Foreword: The Pain Points of API Testing Tools and the 2026 Turning Point

In the daily life of a backend developer, API testing tools are software that nearly every engineer opens every day. In the past, Postman became the de facto industry standard with its intuitive interface. However, as time went on, many teams began to feel the hidden burdens it brought. This was especially true in 2026, when Postman significantly adjusted its pricing strategy, limiting its free plan to single-user access. For team collaboration, you had to upgrade to a license costing $19 美元的 Team 方案。這意味著一個僅僅 5 人的小團隊，每年就得支付高達 $1,140 per person per month, which was undoubtedly a significant expense for many startups and small to medium-sized teams.

In the search for alternatives, we might have tried VS Code's REST Client extension. While lightweight, it lacks a standalone GUI and intuitive collection management, making it difficult to maintain as project scale increases. Another well-known open-source project, Hoppscotch (formerly Postwoman), is also a good choice, but its web-based design sometimes raises concerns for security teams regarding offline support and the privacy of sensitive corporate data.

As we mentioned in [Reflecting on What I Did to Improve the Developer Experience](https://blog.markkulab.net/post/improving-developer-experience), optimizing the development process and toolchain is key to improving team efficiency [2]. Against this backdrop, an open-source API testing tool called **Bruno** has quietly emerged. It has not only garnered over 50,000 stars on GitHub and adopted a permissive MIT license, but it has also redefined the API testing workflow with its "Git-native" and "fully offline" design philosophy.

---

## Why Choose Bruno? Core Advantages and Technical Architecture

The biggest difference between Bruno and traditional API testing tools lies in its approach to data storage architecture.

### 1. File-System First
Postman's data is synced to the cloud by default or exported as a single, massive JSON file that's difficult to version control. Bruno, on the other hand, adopts a **file-system-first** design. It stores every API request as a separate, plain text `.bru` file (using its custom Bru Markup Language).

This means you can place your API test files directly into your project directory, commit them into your Git repository along with your code, and conduct code reviews via Pull Requests (PRs). Here is an example of a typical `.bru` file:

```text
meta {
  name: 取得會員資料
  type: http
  seq: 1
}

get {
  url: {{baseUrl}}/api/v1/users/123
  body: none
  auth: bearer
}

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

assert {
  res.status: eq 200
  res.body.status: eq "success"
}
```

### 2. Fully Offline and Secure
By default, Bruno operates 100% offline. It doesn't force you to link a cloud account; all your API collections, environment variables, and secrets are stored only on your local hard drive. For enterprises that prioritize security and data privacy, this completely eliminates the risk of sensitive API information being leaked to third-party clouds.

### 3. Full Functionality and CI/CD Automation
Though lightweight, Bruno's feature set is quite complete. It supports not only REST, GraphQL, and WebSocket but also allows you to write pre-request scripts and post-response assertions using JavaScript. Paired with the official `@usebruno/cli` tool, we can easily integrate API tests into our deployment pipeline to achieve automated regression testing.

To give you a more intuitive understanding of the differences, we've compiled the following comparison table:

| Feature / Characteristic | Bruno | Postman (2026 Plan) | VS Code REST Client |
| :--- | :--- | :--- | :--- |
| **License Model** | Open Source (MIT) | Closed Source Commercial (Limited Free) | Open Source |
| **Team Collaboration Cost** | **$0** | $0** (開源版) | $19 / user / month | **$0** |
| **Storage Method** | Local plain text (`.bru`) | Cloud sync / Massive JSON | Local plain text (`.http`) |
| **Git Friendliness** | Very High (PR conflicts are easy to resolve) | Poor (Hard to merge on conflict) | High |
| **GUI Interface** | Standalone desktop app | Standalone desktop app | Integrated within VS Code |
| **CLI Execution** | Supported (`@usebruno/cli`) | Supported (Newman) | More limited support |

---

## Implementation Steps: From Installation to a Team Collaboration Workflow

Next, we'll demonstrate how to integrate Bruno into your daily development workflow.

### Step 1: Cross-Platform Installation and Creating a Collection
Bruno supports Windows, macOS, and Linux. You can download it directly from the official website or install it quickly via a package manager:

```bash
# macOS (Homebrew)
brew install bruno

# Windows (Chocolatey)
choco install bruno
```

After installation, open the Bruno interface and select **"Create Collection"**. It's recommended to point this collection's directory directly inside your current project folder (e.g., `./tests/api`). This allows your API test files to be managed alongside your project's source code.

### Step 2: Configuring Environment Variables and API Requests
In actual development, we usually have different environments like development (Dev), testing (Test), and production (Production). In Bruno, you can click the environment settings icon in the top right corner to create different environment configurations.

For example, we can set up a `Dev` environment and add a `baseUrl` variable. When configuring an API request, you can dynamically insert this variable using double curly braces `{{baseUrl}}`.

> 💡 **Pro Tip**: If your project uses an API gateway to manage traffic, you can refer to [Building an Efficient API Management Platform: Deploying Kong Gateway from Scratch - Part 1](https://blog.markkulab.net/post/kong-api-gateway-part1-setup) to set up your backend infrastructure [3], and then use Bruno for end-to-end integration testing.

### Step 3: Writing Test Assertions and Scripts
In Bruno, we can use JavaScript to handle complex API workflows. For instance, before sending a request, we might need to dynamically generate a signature, or after receiving a response, automatically write a token to an environment variable.

In the **Post-Response** section of the **Script** tab, you can write something like this:

```javascript
// 取得回應中的 Token 並寫入環境變數
const data = res.getBody();
if (data && data.token) {
  bru.setEnvVar("token", data.token);
}
```

Meanwhile, in the **Assert** tab, we can set expected results in a declarative way without writing complex JS code:

| Expression | Operator | Value |
| :--- | :--- | :--- |
| `res.status` | `eq` | `200` |
| `res.body.data.id` | `isDefined` | |

### Step 4: CI/CD and Git Collaboration
When you add or modify an API request in Bruno, you'll notice that corresponding `.bru` files are added to the `tests/api` folder in your project directory. Simply commit and push them to Git:

```bash
git add tests/api/
git commit -m "feat: 新增使用者 API 與相關測試案例"
git push
```

In our CI/CD pipeline, we can use the official CLI tool to run these tests automatically. Here is an example GitHub Actions workflow:

```yaml
name: API Regression Testing

on: [push, pull_request]

jobs:
  api-test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Bruno CLI
        run: npm install -g @usebruno/cli

      - name: Run API Tests
        run: bru run tests/api --env Dev
```

This way, every time a team member submits a PR, the system will automatically run the API tests, ensuring no existing interfaces are broken.

> 💡 **Further Reading**: In addition to API-level contract testing, if you also need to perform end-to-end full-scenario validation for your front-end interface or core business website, you can refer to [Easily Build an End-to-End Automated Testing Environment with Microsoft Playwright to Protect Your Company's Core Website, with Teams Notifications and External Triggers](https://blog.markkulab.net/post/playwright-end-to-end-test). Using both together can build a more robust testing safety net [1].

---

## Caveats: Limitations and Pitfalls During Migration

Although Bruno's advantages are very clear, we've also observed some details that require special attention when migrating from Postman:

*   **Script Migration Costs**: While Bruno supports JavaScript, its built-in API objects are not fully compatible with Postman's `pm.*` object (e.g., `pm.test`, `pm.expect`). If your Postman collections contain a large number of complex pre-request/post-response scripts, you may need to spend some time manually rewriting them after importing them into Bruno.
*   **The Paywall Boundary**: Bruno's core features (including the CLI, environment variables, scripting, etc.) are completely open-source and free. However, it also offers a paid Ultimate Edition (annual subscription) that mainly includes advanced enterprise features (like built-in LDAP integration, more granular UI customization, etc.). When evaluating, we recommend starting with the open-source version, which can usually satisfy the daily needs of over 95% of development teams.

---

## Conclusion: Benefits After Adoption and Next Steps

After adopting Bruno, our most significant benefit has been the **elimination of the separation between code and API documentation/test scripts**. Now, API changes are reviewed and tested in the same PR as the feature code. We no longer face the dilemma of "the code has changed, but the collection in the testing tool is still on the old version." Even better, the team is completely free from the pressure of Postman's per-user licensing fees.

If your team is currently trapped by the pricing models of your API tools or wishes to bring API testing closer to a Git-based workflow, we recommend starting with a trial on a single microservice in an existing project. Create an API collection within the project and experience the seamlessness of collaborating on APIs via Git PRs. We believe that, like us, once you try it, you'll never go back.

---

## References

*   [Bruno Official Website](https://www.usebruno.com/) [1]
*   [GitHub - usebruno/bruno](https://github.com/usebruno/bruno) [2]
*   [Bruno vs Postman Official Comparison Guide](https://www.usebruno.com/compare/bruno-vs-postman) [3]
*   [REST API Testing in 2026: Bruno, Hoppscotch, and Moving on from Postman](https://devtoolsguide.substack.com/p/rest-api-testing-in-2026-bruno-hoppscotch) [5]

---

## About this article and its author

Originally published on [Mark Ku's Tech Notes](https://blog.markkulab.net/en/post/bruno-postman-alternative-guide)

License: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) — when reusing or quoting, credit the author and link back to the original

### About the author

**[Mark Ku](https://blog.markkulab.net/en/author/mark-ku)** — Software Solution Provider

- 10+ years senior software engineer, now an AI Builder
- Focused on large-platform architecture — North-American e-commerce, AI SaaS subscription billing
- Combining AI Agents and automation to build evolvable product foundations

### Free tools built by the author

All of these are free to use:

- [Free PDF Sign Tool](https://blog.markkulab.net/en/tools/pdf-sign): Online PDF sign tool — draw, type, or upload a signature, then drag, resize, and download. Everything runs in your browser; nothing is uploaded.
- [VS Code Refactory](https://blog.markkulab.net/en/tools/refactory): Refactory is a VS Code refactoring extension: 34 actions plus a 37-rule code-smell inspection layer with a Code Health dashboard, across 18 languages, backed by 534 tests. It learns your repo's conventions: where interfaces live, where DI is registered, whether 'use client' belongs. It ranks files by git churn × complexity so you know what to fix first, and hands any smell to the Claude Code already on your machine. Free to use, and your source never leaves your computer.
- [DB-Kit Database Manager](https://blog.markkulab.net/en/tools/db-kit): DB-Kit is a lightweight, cross-platform database manager built with Tauri + Rust + React. Manage MySQL, MariaDB, PostgreSQL, SQL Server, Oracle, SQLite, MongoDB, Redis, Kafka, Elasticsearch and RabbitMQ from one consistent interface: passwords encrypted in the OS keychain, SSH tunnels, full CRUD, a visual query builder, stacked multi-statement result sets, cross-connection data transfer and compare/sync, Excel / CSV import & export, visualized execution plans, ER diagrams, scheduled backups, SQL stress testing with p50–p99 latency percentiles, a 15-rule SQL review engine, Kafka message browsing with monitoring & alerts, a bilingual UI (Traditional Chinese / English), a built-in AI assistant (natural-language SQL, AI review and tuning advice) and the dbk CLI. Free and open source (MIT), with installers for Windows, macOS and Linux.
- [VS Code Super Mermaid](https://blog.markkulab.net/en/tools/super-mermaid): Super Mermaid is a VS Code extension for beautiful Mermaid diagrams out of the box: auto-colored live preview, mouse pan & zoom, high-res PNG / SVG export, 21 templates and multiple themes. Free and open source (MIT).
- [React Super Mermaid](https://blog.markkulab.net/en/tools/react-super-mermaid): react-super-mermaid is an open-source React component library: render beautiful Mermaid diagrams with a single <MermaidViewer>, with built-in colorful / sketch themes, pan & zoom, in-diagram search, and high-res SVG / PNG export. Lightweight, SSR-safe, fully typed. Free and open source (MIT).
- [Jira / Confluence Super Mermaid](https://blog.markkulab.net/en/tools/jira-super-mermaid): An Atlassian Forge app: write Mermaid syntax directly inside a Jira issue or a Confluence page and get flowcharts, sequence diagrams, state machines and Gantt charts. 11 diagram types, SVG / PNG export, light and dark themes, full CJK support. Runs on Atlassian: your diagrams live in your own site and the app calls no third-party service. Free, coming soon to the Atlassian Marketplace.
- [Mermaid Live Preview](https://blog.markkulab.net/en/tools/mermaid-preview): Write Mermaid in your browser, see it render instantly, and share the whole diagram as a single link. No sign-up, nothing uploaded to a server, and mermaid.live share links work as-is.
- [React Intl Phone Number](https://blog.markkulab.net/en/tools/react-intl-phone-number): react-intl-phone-number is an open-source React component: framework-agnostic and antd-free, with E.164 in/out, a searchable flag / country-code dropdown, configurable validation levels (strict / mobile-strict / loose), themeable CSS, and i18n — phone logic powered by google-libphonenumber. Lightweight and fully typed. Free and open source (MIT).
- [Uptime Kuma Cluster](https://blog.markkulab.net/en/tools/uptime-kuma-cluster): Turn single-node Uptime Kuma into a highly available cluster: OpenResty + Lua smart load balancing, shared MariaDB state, health checks and automatic failover, plus cluster-management REST APIs. One Docker Compose command to start. Free and open source (MIT).
- [Special Education](https://blog.markkulab.net/en/education): Learning materials crafted for special education students

### Daily podcasts

- [Tech News](https://blog.markkulab.net/en/category/tech-news): Daily curated AI and tech trends. Catch the latest developments via audio summaries — covering AI applications, software architecture, DevOps, and engineering practice. — RSS: https://blog.markkulab.net/feed.xml
- [AI Stock Chat](https://blog.markkulab.net/en/category/ai-stock-chat): Every trading day, an AI-analyzed take on the Taiwan stock market, delivered as a two-host conversation covering the session and the next-day outlook. — RSS: https://blog.markkulab.net/ai-stock-chat/feed.xml

### Newsletter

[Subscribe to the newsletter](https://blog.markkulab.net/en/subscribe) — Be the first to know about new posts. No spam, unsubscribe anytime.