Bruno

Open-source, offline-first API client that stores collections as plain text files alongside your source code. No cloud sync, no account, no subscription - commit your requests to Git and review them in pull requests like any other code.

What is Bruno?

Bruno is an open-source API client built for developers who want their HTTP collections to live where their code lives - in a Git repository. While tools like Postman store collections in the cloud and require an account to collaborate, Bruno takes the opposite approach: every request is a plain text .bru file you can read, edit, diff, and commit without ever opening the GUI.

Bruno supports REST, GraphQL, and other HTTP APIs. It includes environments and variables, pre/post-request JavaScript scripting, assertions, authentication (bearer, basic, API key, OAuth 2.0), and a CLI runner for CI pipelines. The GUI app is available for macOS, Windows, and Linux. The project is fully open source under the MIT license with no paid tier or proprietary cloud component.

Key Features

• Offline-first - works without an internet connection; no cloud sync, no telemetry, no account required
• Git-native storage - collections are plain text .bru files; diff them, review them in PRs, search with grep
• Bru language - human-readable format for requests: method, URL, headers, body, scripts, and assertions in one file
• Environments & variables - switch between dev/staging/production configs; secrets kept out of version control
• JavaScript scripting - run pre/post-request scripts to set variables, chain requests, or validate complex responses
• Assertions - declare expected status codes, body properties, and header values directly in the .bru file
• Import from Postman/Insomnia - migrate existing collections with a single import action
• CLI runner - run collections headlessly with bru run in any CI environment

Installation

# Install the Bruno CLI globally (for CI/scripting)
npm install -g @usebruno/cli

# Run a collection from the CLI
bru run --env production

# Run a specific folder of requests
bru run requests/users --env staging

# Run with environment variables and output JUnit XML (for CI)
bru run --env ci --reporter junit --output results.xml

# Download the GUI app (macOS / Windows / Linux)
# https://www.usebruno.com/downloads

GET Request with Assertions

Each request is a standalone .bru file. The assert block lets you declare expected response values inline - no separate test file needed.

# requests/users/get-user.bru
meta {
  name: Get User by ID
  type: http
  seq: 1
}

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

headers {
  Accept: application/json
  X-Request-ID: {{$randomUuid}}
}

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

assert {
  res.status: eq 200
  res.body.id: eq {{userId}}
  res.body.email: isDefined
}

POST Request with Post-Response Script

Scripts run after a response arrives and can read the body, set variables, and chain into subsequent requests. Here a login request saves its returned token for use in later requests.

# requests/auth/login.bru
meta {
  name: Login
  type: http
  seq: 1
}

post {
  url: {{baseUrl}}/api/auth/login
  body: json
  auth: none
}

headers {
  Content-Type: application/json
}

body:json {
  {
    "email": "{{userEmail}}",
    "password": "{{userPassword}}"
  }
}

script:post-response {
  // Save the token for subsequent requests
  const token = res.getBody().token;
  bru.setVar("authToken", token);
}

assert {
  res.status: eq 200
  res.body.token: isDefined
}

Environments

Environment files define variables per target. Secret variable names are declared but their values are stored outside Git - Bruno keeps sensitive data out of your repository automatically.

# environments/staging.bru
vars {
  baseUrl: https://staging.api.example.com
  userId: 42
  userEmail: [email protected]
}

vars:secret [
  userPassword,
  authToken
]

# environments/production.bru
vars {
  baseUrl: https://api.example.com
  userId: 42
  userEmail: [email protected]
}

vars:secret [
  userPassword,
  authToken
]

Scripting API

Bruno's scripting layer exposes bru helpers for reading and writing variables, environment values, and request/response data. Use the Chai-style expect API for programmatic assertions.

// script:pre-request - runs before the HTTP request is sent
const timestamp = new Date().toISOString();
bru.setVar("requestTime", timestamp);

// Access environment variables
const baseUrl = bru.getEnvVar("baseUrl");
console.log("Sending request to:", baseUrl);

// script:post-response - runs after the response arrives
if (res.getStatus() === 401) {
  bru.setVar("authToken", "");
  console.warn("Token expired - clear and re-authenticate");
}

// Assertions in scripts (alternative to the assert block)
expect(res.getStatus()).to.equal(200);
expect(res.getBody()).to.have.property("id");

Bruno vs Postman

Pros and Cons