Bruno

What is Bruno?

Bruno is a revolutionary open-source API client that takes a fundamentally different approach to API collection management. Unlike Postman, Insomnia, or other tools that store collections in proprietary cloud platforms or binary formats, Bruno saves your API collections directly as files in a folder on your filesystem. This file-based approach means collections can be version-controlled with Git, reviewed in pull requests, and collaborated on using existing development workflows.

The philosophy behind Bruno is simple yet powerful: API collections are code artifacts and should be treated as such. When collections live in Git repositories alongside the code they test, teams gain version history, branching, merge conflict resolution, and code review processes for their API definitions. No more syncing issues, no cloud dependencies, and no proprietary formats locking your data into specific tools.

Bruno uses a plain-text markup language called Bru for storing requests, making collections human-readable and diff-friendly. The desktop application provides a beautiful, fast interface for creating and executing requests while the underlying files remain accessible and portable. This combination of excellent user experience with developer-friendly storage has resonated strongly with teams who value control over their tooling and data.

Key Features

• Git-Friendly Storage: Collections stored as plain files in your filesystem. Version control, branch, merge, and review API collections like any other code.
• Bru Markup Language: Human-readable plain-text format for requests. Easy to read, diff, and understand without special tools.
• No Cloud Required: Works entirely offline with local file storage. No accounts, subscriptions, or data syncing to external servers.
• Fast and Lightweight: Built with performance in mind. Quick startup, responsive interface, and minimal resource consumption.
• Multiple Environments: Define variables for different environments. Switch between development, staging, and production seamlessly.
• Scripting Support: Pre-request and post-response scripts for dynamic values and assertions. Full JavaScript support for complex scenarios.
• Collection Runner: Execute multiple requests sequentially or in parallel. Automate testing workflows within the application.
• Import Support: Import existing collections from Postman, Insomnia, and OpenAPI specifications. Migrate without losing work.
• Cross-Platform: Native applications for Windows, macOS, and Linux. Consistent experience across operating systems.
• Open Source: MIT licensed with active community development. Inspect, modify, and contribute to the codebase.

Recent Updates and Improvements

Bruno has seen rapid development since its launch, with features being added based on community feedback and real-world usage patterns.

• GraphQL Support: Full GraphQL query support with syntax highlighting, schema introspection, and variable handling.
• OAuth 2.0: Complete OAuth 2.0 authentication flow support including authorization code, client credentials, and token refresh.
• CLI Tool: Command-line interface for running collections in CI/CD pipelines without the graphical application.
• Secret Management: Secure handling of sensitive values with environment-based secret management that doesn’t commit secrets to Git.
• Improved Performance: Faster collection loading, better handling of large responses, and reduced memory usage.
• Certificate Support: Client certificate authentication for APIs requiring mutual TLS.
• Cookie Management: Automatic cookie handling across requests with manual override capabilities.
• Response Visualization: Enhanced response viewing with JSON path queries, filtering, and better formatting options.

System Requirements

Desktop Application

• Windows 10/11 (64-bit)
• macOS 10.15 (Catalina) or later
• Linux (Ubuntu 18.04+, Fedora 32+, or equivalent)
• 4 GB RAM minimum
• 200 MB disk space

CLI Tool

• Node.js 18 or later
• npm, yarn, or pnpm
• Any operating system supporting Node.js

How to Install Bruno

Desktop Application

# Download from usebruno.com
# Available for Windows, macOS, and Linux

# macOS with Homebrew
brew install --cask bruno

# Windows with Chocolatey
choco install bruno

# Linux (Ubuntu/Debian)
sudo apt install bruno

# Linux via Snap
sudo snap install bruno

CLI Installation

# Install globally via npm
npm install -g @usebruno/cli

# Or via yarn
yarn global add @usebruno/cli

# Run a collection
bru run --env production

Working with Collections

# Collection structure
my-api-collection/
??? bruno.json           # Collection configuration
??? environments/
?   ??? development.bru  # Dev environment
?   ??? production.bru   # Prod environment
??? users/
?   ??? get-users.bru    # GET /users request
?   ??? create-user.bru  # POST /users request
?   ??? folder.bru       # Folder configuration
??? orders/
    ??? get-orders.bru   # GET /orders request

# Example request file (get-users.bru)
meta {
  name: Get All Users
  type: http
  seq: 1
}

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

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

headers {
  Content-Type: application/json
}

script:post-response {
  bru.setVar("userCount", res.body.length);
}

Pros and Cons

Pros

• Git Integration: Collections version-controlled alongside code. Review API changes in pull requests with full history.
• No Vendor Lock-in: Plain text files mean you own your data. Switch tools anytime without migration headaches.
• Offline First: Works entirely without internet. No cloud sync issues or connectivity requirements.
• Free Forever: MIT license with no paid tiers or feature restrictions. Open source means truly free.
• Developer Workflow: Fits naturally into existing development workflows with Git, code review, and CI/CD.
• Lightweight: Fast startup and minimal resource usage compared to Electron-heavy alternatives.
• Privacy: No telemetry, no accounts, no data collection. Your API data stays on your machine.

Cons

• Newer Tool: Smaller community and ecosystem compared to established tools. Fewer tutorials and resources.
• Team Sync: Real-time collaboration requires Git workflows rather than instant cloud sync.
• Learning Bru: New markup format to learn, though it’s simple and well-documented.
• Feature Gaps: Some advanced features available in Postman may not exist yet in Bruno.
• Import Limitations: Complex Postman scripts may need manual adjustment after import.

Bruno vs Alternatives

Who Should Use Bruno?

Bruno is ideal for:

• Git-Centric Teams: Organizations that want API collections version-controlled and reviewed like code.
• Privacy-Conscious Developers: Users who prefer keeping API data local without cloud synchronization.
• Open Source Advocates: Developers who value truly open tools without commercial restrictions.
• CI/CD Integration: Teams needing to run API tests in pipelines with collections stored in repositories.
• Resource-Limited Machines: Developers tired of heavyweight Electron apps consuming system resources.
• Security-Sensitive Projects: Projects where API credentials and endpoints shouldn’t leave the local network.

Bruno may not be ideal for:

• Non-Technical Teams: Teams without Git experience may struggle with the version control workflow.
• Real-Time Collaboration: Teams needing instant sync prefer cloud-based solutions.
• Heavy Postman Investment: Organizations deeply embedded in Postman’s ecosystem.
• Enterprise Features: Large organizations needing advanced team management and compliance features.

Frequently Asked Questions

How do I share collections with my team?

Share collections by committing them to your Git repository. Team members clone or pull the repository to get the latest collections. Changes go through normal Git workflow—branches, pull requests, and code review. This approach provides full history, conflict resolution, and review process that cloud sync lacks.

Can I migrate from Postman to Bruno?

Yes, Bruno supports importing Postman collections. Export your Postman collection as JSON and import it in Bruno. Most requests, environments, and basic scripts transfer correctly. Complex test scripts may need adjustment for Bruno’s scripting API. The Bru format is documented if manual tweaks are needed.

How does Bruno handle secrets and credentials?

Bruno supports environment-specific secrets that can be excluded from Git through .gitignore. Store sensitive values in local environment files while committing sanitized versions. The secrets management keeps credentials secure while allowing collection structure to be version controlled.

Does Bruno work offline?

Yes, Bruno works entirely offline since collections are local files. No internet connection needed for any functionality. This makes it reliable for air-gapped environments, travel, or unreliable network conditions. The only time network is needed is for the actual API requests you’re testing.

Is Bruno actively maintained?

Yes, Bruno has active development with regular releases. The open-source community contributes features and fixes, and the maintainers are responsive to issues and feature requests. The project has gained significant traction and shows no signs of slowing development.

Final Verdict

Bruno represents a thoughtful reimagining of what an API client should be in a world where Git workflows dominate software development. The decision to store collections as plain text files isn’t just a technical choice—it’s a philosophy that respects how development teams actually work. Version control, code review, and CI/CD integration come naturally because collections are treated as first-class code artifacts.

The trade-off is clear: real-time cloud collaboration gives way to Git-based workflows. For teams already comfortable with Git, this is an upgrade—API changes go through the same review process as code changes. For teams expecting Postman-style instant sync, the adjustment requires embracing different workflows.

Bruno delivers on its promise of a fast, open-source API client that fits developer workflows rather than fighting them. The tool is maturing rapidly with community-driven development adding capabilities while maintaining the lightweight, privacy-respecting core. For developers who believe API collections belong in Git alongside the code they test, Bruno is the tool that finally makes that vision practical and pleasant to use.