Bruno

Fast, Git-friendly API client for testing and debugging. Store API collections as files and version control them.

43 commands

Browse by Topic

Getting Started

Quick setup and installation

3commands

Running

Execute requests

11commands

Environments

Manage environments

6commands

Collections

Manage collections

9commands

Scripts

Pre/post scripts

14commands

Install Bruno (macOS)

$ brew install bruno

Install Bruno API client using Homebrew on macOS

Install Bruno CLI (npm)

$ npm install -g @usebruno/cli

Install the Bruno CLI globally using npm

Check Bruno CLI version

$ bru --version

Verify Bruno CLI is installed and display the current version

Run collection

$ bru run

Run all requests in collection.

Run specific folder

$ bru run --folder users

Run requests in specific folder.

Run with environment

$ bru run --env production

Run with specific environment.

Run specific request

$ bru run -r 'Get Users'

Run a specific request by name.

Output format

$ bru run --output json

Output results as JSON.

Run with custom CA cert

$ bru run --cacert /path/to/ca.pem

Use custom CA certificate for TLS.

Skip TLS verification

$ bru run --insecure

Disable SSL certificate verification.

Stop on first failure

$ bru run --bail

Abort collection run on first error.

Set request timeout

$ bru run --timeout 10000

Set timeout in milliseconds per request.

HTML test report

$ bru run --reporter-html results.html

Generate HTML report of test results.

JUnit test report

$ bru run --reporter-junit results.xml

Generate JUnit XML report for CI.

List environments

$ bru env list

List available environments.

Show environment

$ bru env show production

Show environment variables.

Run with env file

$ bru run --env-file .env.local

Use dotenv file for secrets.

Environment file structure

$ vars { baseUrl: https://api.dev.example.com apiVersion: v1 } vars:secret [ authToken ]

Example environment.bru file format.

Secret variables

$ vars:secret [ apiKey dbPassword jwtSecret ]

Declare secret vars excluded from Git.

Override env variable

$ bru run --env staging --env-var baseUrl=http://localhost:3000

Override a single variable at runtime.

Initialize collection

$ bru init my-api

Create new Bruno collection.

Bru file structure

$ meta { name: Get Users type: http seq: 1 } get { url: {{baseUrl}}/users } assert { res.status: eq 200 }

Example .bru request file.

Import from Postman

$ bru import postman collection.json

Import Postman collection.

POST with JSON body

$ post { url: {{baseUrl}}/users body: json } body:json { { "name": "John", "email": "john@example.com" } }

POST request with JSON body payload.

Form data upload

$ post { url: {{baseUrl}}/upload body: multipart-form } body:multipart-form { file: @file(/path/to/image.png) description: Profile photo }

Upload file using multipart form data.

GraphQL request

$ post { url: {{baseUrl}}/graphql body: graphql } body:graphql { query { users { id name email } } }

Send a GraphQL query request.

Set request headers

$ get { url: {{baseUrl}}/users } headers { Authorization: Bearer {{authToken}} Content-Type: application/json X-Request-Id: {{$guid}} }

Add custom headers to a request.

Query parameters

$ get { url: {{baseUrl}}/users } params:query { page: 1 limit: 20 sort: created_at }

Set URL query parameters on a request.

Collection folder structure

$ my-api/ bruno.json environments/ dev.bru staging.bru users/ Get Users.bru Create User.bru auth/ Login.bru

Standard collection directory layout.

Pre-request script

$ script:pre-request { bru.setVar('timestamp', Date.now()); }

Script that runs before request.

Post-response script

$ script:post-response { bru.setVar('token', res.body.token); }

Script that runs after response.

Test assertions

$ tests { test('status is 200', function() { expect(res.status).to.equal(200); }); }

Write test assertions.

Set variable

$ bru.setVar('userId', res.body.id);

Store value for later requests.

Get variable

$ const userId = bru.getVar('userId');

Retrieve a previously stored variable.

Get environment variable

$ const baseUrl = bru.getEnvVar('baseUrl');

Read an environment variable in script.

Set next request

$ bru.setNextRequest('Create Order');

Control request execution order.

Multiple test blocks

$ tests { test('status is 200', function() { expect(res.status).to.equal(200); }); test('has users array', function() { expect(res.body.users).to.be.an('array'); }); test('returns 10 users', function() { expect(res.body.users).to.have.length(10); }); }

Multiple Chai assertions in tests block.

Assert status code

$ assert { res.status: eq 200 }

Built-in assert for response status.

Assert response body

$ assert { res.body.success: eq true res.body.data.id: isNumber res.body.data.name: isString }

Assert response body field types and values.

Assert response headers

$ assert { res.headers.content-type: contains application/json res.headers.x-request-id: isDefined }

Assert values in response headers.

Assert contains and matches

$ assert { res.body.email: contains @example.com res.body.phone: matches ^\+[0-9]{10,15}$ res.body.items: length 5 }

Use contains, matches, and length assertions.

Auth token chaining

$ script:post-response { if (res.status === 200) { bru.setVar('authToken', res.body.access_token); bru.setVar('refreshToken', res.body.refresh_token); } }

Extract and chain auth tokens between requests.

Dynamic request body

$ script:pre-request { const timestamp = Date.now(); const id = Math.random().toString(36).slice(2); bru.setVar('uniqueId', `${id}-${timestamp}`); }

Generate dynamic values before request.

Discussion

Loading comments...