How to Share Bruno Collections: Git, Export, and Import

Applies to Bruno 3.0 and later

At some point, there's usually a need to share your API collection. A teammate needs the requests/scripts you built, QA wants your test suite, or a partner wants to try your API without digging through reference docs. How you hand that work over decides whether everyone stays on the same version or ends up with three different copies.

Bruno gives you several ways to share: Git repositories, one-click Fetch in Bruno buttons, collection and workspace exports, and imports from other tools. This guide covers when to use each one, how to do it step by step, and how to keep secrets out of everything you share, so it's done securely.

Which sharing method should you use?

The rule of thumb: if the other person will edit the collection and you want their changes back, use Git. If they only need a copy, export it.

Why Bruno collections are easy to share

We built Bruno as an open-source, local-first API client. Instead of syncing your work to our servers or cloud, Bruno saves each collection as a folder of files on your machine. Since Bruno 3.0, those files use YAML that follows the OpenCollection specification, an open format we created so your collections are never locked to a single tool. Each request is its own .yml file, each folder is a real directory, and environments sit in an environments/ folder:

payments-api/
├── opencollection.yml      # collection settings
├── environments/
│   ├── local.yml           # one file per environment
│   └── staging.yml
├── orders/
│   ├── folder.yml          # folder settings
│   ├── create-order.yml    # one file per request
│   └── list-orders.yml
└── refunds/
    └── create-refund.yml

Because the collection is plain text, anything that works with files works with your collection. Git can version it, reviewers can read it in a pull request, you can open it in your IDE, and your backup tool can back it up. There is no proprietary sync layer between you and your data.

Share collections with Git (the recommended way)

Git is the way we recommend sharing collections. You get full history, branches, pull requests, and one source of truth, on whichever provider your team already uses: GitHub, GitLab, Bitbucket, or Azure DevOps. Our Git collaboration docs cover setup for each provider.

Pick a Git strategy

Decide where the repository lives before you initialize anything. Bruno supports three strategies:

• Workspace-level Git. One repository at the workspace root tracks every collection inside it. This suits monorepos and teams whose services ship together.
• Collection-level Git. Each collection gets its own repository and remote. This suits microservices owned by different teams, or keeping a collection inside the repo of the service it tests.
• Workspace repo with linked collections. Most collections are tracked by the workspace repository, while specific ones are linked to their own remote using Connect to Git from the workspace overview.

For a full comparison with a decision guide, read our guide, How to Use Git in Bruno: Collection, Workspace, and Hybrid Setup. For repository layouts at scale, see Structuring Git for API Collection Collaboration.

Set up Git from inside Bruno

1. 1Open the collection, click the Git icon in the top-right of the navbar, and click Initialize.
2. 2Connect a remote. Bruno can create a new GitHub repository for you with Create a Repo on GitHub, or you can add an existing remote (HTTPS or SSH) under Quick Links > Remotes.
3. 3In the Git UI, stage your changes, click Commit Changes, and write a message.
4. 4Click Push, choose the destination branch, and confirm.

Or use the terminal

Set up your .gitignore before the first commit (see the secrets section below) so local credentials never enter your history. Then:

# Start tracking the collection
$ cd path/to/payments-api
$ git init

# Save the first snapshot
$ git add .
$ git commit -m "Add payments API collection"

# Connect a remote and push
$ git branch -M main
$ git remote add origin <your-repository-url>
$ git push -u origin main

How teammates get the collection

Recipients don't need the command line. In Bruno, they click Import Collection (on the home screen or from the + menu), choose the Git repository option, paste the repository URL, and pick where to save it. Bruno clones the repo, lists the collections it finds, and opens the one they select, still connected to Git.

To pick up new changes later, they open the Git UI, click Fetch to see what's incoming, then click Pull. Both are available in the free edition. If you shared a whole workspace, teammates use Import workspace > Clone from Git Repository instead, which brings over the full Git history.

Review API changes like code

Since every request is a small YAML file, a change shows up as a readable diff. When someone moves an endpoint to a new API version, the pull request shows exactly that:

 http:   method: GET-  url: '/v1/orders'+  url: '/v2/orders'

Reviewers can comment on it the same way they review application code. Bruno's Git UI shows the same changes as text or visual diffs, and on Pro and Ultimate the History tab on any request lists every commit that touched it, with author, date, and message.

One-click sharing with the Fetch in Bruno button

Sometimes the audience is broader than your team: users of a public API, readers of your docs, or new hires following an onboarding guide. The Fetch in Bruno button turns cloning into a single click. Anyone who clicks it is prompted to open Bruno, chooses a save location, and gets a Git-synced copy, so they can pull your future updates.

To generate a button:

• For a collection: open the collection's Overview tab or its ... menu, select Share, go to the Embed tab, and copy the HTML or Markdown snippet.
• For a workspace: open workspace settings, click ..., select Export, and copy the snippet from the Embed tab.

The collection or workspace must already be initialized with Git and pushed to a repository your audience can access. The Markdown version looks like this (swap in your own repository URL):

[![Fetch in Bruno](https://fetch.usebruno.com/button.svg)](https://fetch.usebruno.com?url=https://github.com/your-org/your-collection.git)

The button also works with OpenAPI specs: point url at a spec file and add &type=openapi, and Bruno converts the spec into a collection on the reader's machine. To see the flow from the recipient's side, clone our GitHub REST API collection into Bruno.

Export a Bruno collection

Exports create a standalone copy. To export:

1. 1Hover over the collection in the sidebar and click the ... menu.
2. 2Select Share.
3. 3Choose a format and pick where to save the file.

Which format to choose depends on who's receiving it:

• Bruno Collection: a full copy for another Bruno user, a backup, or a machine without access to your Git host. The recipient imports it with Import Collection > Bruno Collection.
• Postman Collection: for colleagues who still use Postman. The two tools don't model every feature identically, so ask the recipient to spot-check scripts and auth after importing.
• OpenAPI Specification: for sharing the API contract with documentation portals, API gateways, or client generators. OpenAPI describes endpoints, parameters, and schemas. It has no place for tests or pre-request scripts, so those stay in Bruno. See Export to OpenAPI for details.

Whatever format you pick, secret variables are left out of the exported file.

Export and import a whole workspace

A Bruno workspace groups multiple collections together with global environment variables and workspace-level settings. When you need to hand over everything at once, such as onboarding a contractor or moving to a new laptop, export the workspace:

1. 1Open the workspace and click the ... menu at the top.
2. 2Select Export Workspace. Bruno saves a .zip file containing all collections and configuration.

To import it, go to the Workspace section, choose Import workspace, select From ZIP File, pick the file, and choose a destination folder. A ZIP is a snapshot. If the workspace should stay in sync, choose Clone from Git Repository in the same dialog instead. Full steps are in the workspace import and export docs.

Import collections into Bruno

Sharing works both ways. When someone sends you a collection, click Import Collection on the home screen or from the + menu and pick the matching format:

After importing, review the requests, set up your environments, and configure authentication before sending anything. The full list of options is in the import docs.

Share environments without leaking secrets

Environments hold base URLs, tokens, and API keys, which makes them the riskiest part of any shared collection. Bruno gives you three ways to share the shape of an environment without the sensitive values. For a deeper look at keeping credentials safe, see our guide to managing secrets in Bruno.

Export and import environments

To share variables on their own, open the Environments section in the top right, click Configure, and use Export. Select the environments you want and Bruno saves them as a JSON file. On the receiving side, Import in the same screen accepts both Bruno and Postman environment files, for collection and global environments alike. See importing and exporting environments.

Mark sensitive values as secret

Tick the secret checkbox on any variable and Bruno stores its value on your machine, encrypted with your operating system's encryption where available and AES-256 otherwise. The value is never written to the environment file, so you can commit the collection safely, and it is excluded from collection and environment exports. Starting with Bruno 4.0, secret variables appear in their own tab.

Keep credentials in a .env file

For teams that already manage secrets in .env files, Bruno reads a .env file at the root of the collection folder:

API_KEY=your_api_key_value
JWT_TOKEN=your_jwt_token_value

In your environment, set the variable's value to . The environment file you commit then contains only the reference, never the key itself:

name: staging
variables:
  - name: baseUrl
    value: https://staging.example.com
  - name: apiKey
    value: ''

Add the .env file to your .gitignore so it never reaches the repository:

# Local secrets
.env

Then commit a .env.sample file with the same keys and empty values, so teammates know exactly what to fill in:

API_KEY=
JWT_TOKEN=

Since Bruno 3.1, you can also manage workspace-wide credentials from Workspace > Global Environment without editing a .env file by hand, and reference them from any collection in the workspace. For organization-wide secrets, Bruno integrates with secret managers including HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, and Google Cloud Secret Manager.

A quick checklist before you share

• ✓Every token, password, and key is marked secret or moved to .env.
• ✓.env is in .gitignore, and a .env.sample with placeholders is committed.
• ✓Requests use variables such as instead of hardcoded hosts, so recipients can point them at their own environment. Our guide on how to manage variables in Bruno walks through the setup.
• ✓The collection has docs explaining what it covers and how to authenticate.
• ✓You've run the collection end to end, so the first thing a teammate sees is passing tests.

Frequently asked questions

Start sharing

Git keeps everyone on the same version and gives API changes a real review process. Fetch in Bruno buttons put a collection one click away for anyone reading your docs. Exports and imports cover everything else, from Postman handoffs to OpenAPI contracts, while secret variables and .env files keep credentials on the machines they belong to.