APIGit vs Bruno
Bruno shares APIGit's view that API work belongs in files and in Git: it is an offline API client that stores collections as plain files in a folder, which you version in a repository of your own. It sends and tests requests. APIGit hosts the repository and does the other half: designing the OpenAPI file, reviewing it, publishing docs and serving mocks.
Bruno is an open-source, offline API client by Bruno Software. Facts checked against its public documentation on 19 November 2026.
APIGit
Bruno
The short version
The same belief, different jobs
Both keep API work as plain files under Git. Bruno's files are requests and tests; APIGit's are the API description, its guides and its mock scripts.
Bruno has no server; APIGit is one
Bruno is a desktop app with no cloud, so the Git host, pull request review, published docs and hosted mocks come from somewhere else. APIGit provides all four.
Bruno tests, APIGit does not
Requests over REST, GraphQL, gRPC and WebSocket, scripts, a collection runner and a CLI for CI are Bruno's ground. They work well together.
Git, side by side
An APIGit project is a Git repository from its first commit. This is what that means next to Bruno, topic by topic.
| Topic | APIGit | Bruno |
|---|---|---|
| Where your API files live | Yes:In a Git repository that APIGit hosts: specs, Markdown and mock scripts as files | Partly:Plain files in a local folder (.bru or OpenCollection YAML); no cloud. The repository is yours to host |
| Clone and push with any Git client | Yes:HTTPS with a token, or SSH at git.apigit.com | No:Bruno is offline only and not a Git host |
| Branches and tags | Yes:Git branches and tags, created in the browser or pushed from your machine | Yes:Git branches in your own repository; the branch controls in the app are on paid editions |
| Pull requests and review | Yes:Built in: reviewers, approvals, and merge, rebase or squash | Partly:Create and list pull requests for GitHub remotes on paid editions; review happens on your Git host |
| Commit history and diff | Yes:Every commit of every branch, with a unified or split diff | Yes:A history tab and text diffs in the app; a visual diff on paid editions |
| Working with GitHub, GitLab and others | Yes:Optional: two-way sync with a remote repository, or push mirrors (Enterprise) | Yes:A Git interface for GitHub, GitLab, Bitbucket and Azure DevOps: clone and pull free, commit and push on paid editions |
- Yes:Has it
- Partly:Has part of it; the cell says which
- No:Does not have it
Feature by feature
Design, documentation, mock servers, governance, testing, agents and plans. Where Bruno has something APIGit lacks, the table says so.
| Topic | APIGit | Bruno |
|---|---|---|
| API design | ||
| OpenAPI versions | Yes:OpenAPI 3.0 and 3.1, Swagger 2.0 | Partly:Imports OpenAPI 2.0 and 3.x and exports a collection as OpenAPI 3 |
| Visual editor for OpenAPI | Yes:A form view beside the code view, with a diff before you commit | No:A spec viewer and a text editor; no form editor is documented |
| AsyncAPI and GraphQL | Yes:Both: edit as code, preview and publish, in the same repository | Partly:GraphQL, gRPC, WebSocket and SOAP as requests; AsyncAPI is not listed |
| Documentation | ||
| Hosted documentation | Yes:One site for OpenAPI, AsyncAPI, GraphQL and Markdown, published from a commit | Partly:Generates one HTML file with a try-it playground that you host yourself |
| Custom domain | Yes:On Team and Enterprise | No:No hosting is offered |
| Try it console | Yes:Try It Out for OpenAPI, on every plan | Yes:A playground in the generated HTML file |
| Private documentation | Yes:Members only, named external viewers, or a password-protected link | No:No hosting is offered; access is up to where you put the file |
| Mock servers | ||
| Hosted mock server from a spec | Yes:From OpenAPI documents or a GraphQL schema, with request validation | No:No hosted mock server |
| Mocks with your own code and state | Yes:Express.js scripts from the repository (Team and Enterprise) | No:Static responses with matching rules, locally |
| Mock on your machine | Yes:apigit mock serve, from the working copy | Partly:A local mock server (beta) from saved examples or an OpenAPI file, while the app is open |
| Governance | ||
| Style rules for API descriptions | Yes:Spectral: two built-in rule sets, your own on Enterprise | No:No lint rules for OpenAPI are documented |
| Breaking-change check | Yes:apigit breaking, between two Git refs, in a terminal or in CI | No:Its OpenAPI sync lists added, removed and changed items, without marking breaking ones |
| API client and testing | ||
| API client for sending requests | Partly:Try It Out in the reference; no standalone client or saved collections | Yes:REST, GraphQL, gRPC, WebSocket and SOAP |
| Test scenarios, runners and monitors | No:Not provided | Yes:Scripts, assertions, a collection runner and bru run for CI |
| CLI and AI agents | ||
| Command line | Yes:apigit: lint, score, diff, breaking, preview, mock and publish; the checks run offline with no account | Yes:bru: run collections in CI with reports, import OpenAPI, generate docs |
| MCP server | Yes:One for each published document, and one for your account | Not covered in this check |
| Plans | ||
| Free plan | Yes:1 user, 1 published document, 1 mock server | Yes:Open source under the MIT licence, with no user limit stated |
| First paid plan | Yes:Team: $24 a month, 3 seats included; $8 per further seat | Yes:Pro: $6 per user a month, billed yearly |
Checked on 19 November 2026 against each vendor's public documentation and pricing pages. APIGit's column follows our documentation and pricing. Products change: if a cell is out of date, tell us and we will correct it. Product names are trademarks of their owners.
Where Bruno is the better choice
A comparison that only lists our strengths is an advertisement. These are the things it does that we do not, or does better.
Local, offline and yours
No account, no cloud and no server hold your collections. Nothing leaves the machine unless you push it. APIGit is a hosted service.
A full request client
Bruno sends REST, GraphQL, gRPC and WebSocket requests, runs scripts and assertions, runs whole collections, and runs them in CI with reports. APIGit has only Try It Out.
Open source and inexpensive
The core is MIT licensed and free for any number of users, and the paid editions start at $6 per user a month.
Choose Bruno when
- You need a client to send, script and test requests
- Collections must stay on your machines, with no vendor cloud
- You want an open-source tool
Choose APIGit when
- You need a Git host with pull requests for the API description
- You want hosted documentation with access control
- You want hosted mock servers your whole team can call
- You want style rules and a breaking-change check on the OpenAPI file
Using Bruno with APIGit
Keep Bruno, add the spec
There is usually nothing to move away from. Put the OpenAPI file your Bruno collection was imported from, or exported to, in an APIGit repository.
Put the collection beside it
A Bruno collection is a folder of plain files, so it can be committed to the same APIGit repository and cloned by everyone who tests the API.
Point Bruno at the mock
Publish a mock server from the commit and use its URL as a Bruno environment, so tests run before the real service exists.
$ git clone git@git.apigit.com:acme/orders-api.git$ cd orders-api$ cp ~/Downloads/openapi.yaml .$ apigit lint openapi.yaml$ git add openapi.yaml$ git commit -m "Import the orders API"$ git pushQuestions about APIGit and Bruno
What is the main difference between APIGit and Bruno?
Is APIGit an alternative to Bruno?
Can I keep a Bruno collection in an APIGit repository?
Does Bruno host documentation or mock servers?
Can Bruno call an APIGit mock server?
Other comparisons
- APIGit vs Mintlify
A documentation platform for product and API docs
- APIGit vs Postman
An API client and testing platform
- APIGit vs SwaggerHub
An API design platform, now named Swagger Studio
- APIGit vs Stoplight
An API design and documentation platform
- APIGit vs Apidog
An all-in-one API design, debugging, testing, mock and documentation platform
- APIGit vs Redocly
An API documentation platform, with the open-source Redoc and Redocly CLI
- APIGit vs ReadMe
A hosted developer hub for API documentation
- APIGit vs Insomnia
An open-source API client with a spec editor
- All products in one table
The comparison overview
Try it yourself
Worked examples from the learn hub, each with the output of the tools.
- Run a mock server from an OpenAPI file on your machine
One command starts a mock that answers every operation of an OpenAPI file with generated examples and refuses requests that do not match the description. What it returns, how it validates, and when to move it to a hosted mock.
- Bundle a multi-file OpenAPI description into one file
Splitting an OpenAPI description over files keeps it maintainable; many tools still want one file. apigit bundle resolves the external $refs into components and leaves internal ones as references. A four-file example, the output, and why to lint the bundle.
- oneOf vs anyOf in OpenAPI: the one payload that tells them apart
oneOf needs exactly one schema to match, anyOf at least one. The difference only shows on a payload that fits two schemas: oneOf refuses it, anyOf accepts it. The same request sent to both, with a mock server's answers.
- "invalid-ref ... does not exist" and "Can't resolve $ref": finding a broken reference
An OpenAPI $ref that points to nothing. How a linter and a bundler report it, how to read the path in the message, and the five usual causes: a typo, the wrong section, a moved file, a missing escape, a case difference.
Put one API in a repository and see
Create a free workspace, commit the OpenAPI file you already have, and open a pull request against it. It is Git from the first commit.
Free for individuals. No credit card.
$ npm install -g @apigit/cli$ apigit auth login$ apigit doc publish