Your Imported Requests Lost Their Auth. Put It Back Once.
P

Phurpa Tsering

11/20/2026

Your Imported Requests Lost Their Auth. Put It Back Once.

Requests that inherited auth from a Postman collection or Bruno folder arrive in Voiden with none. How config inheritance puts it back in one file, and two choices we made that you might disagree with: replacing instead of merging, and keeping the file out of Git.

Import a Postman collection where the auth lives on the collection, run the first request, and it goes out with no Authorization header. So does the next one. The API answers 401 every time.

Nothing is broken in your collection. In Postman, those requests were set to inherit auth from their parent. Voiden's Postman importer only brings over auth that is set on the request itself, and the Bruno importer does the same with requests set to inherit. The parent's auth has nowhere to go, so it's dropped.

The way to put it back is config inheritance. You write the auth once, in a file at the top of the folder, and every request below it sends it again. This post shows how that works, and two choices we made in it that you might disagree with.

Put the auth back in one place

Right-click the folder you imported into and choose Add Config Inheritance. Voiden creates a .voiden-inherited.void file there and opens it. In the file explorer it shows up as Config Inheritance, with an inherited tag.

It's a plain-text .void file like your requests, so you add blocks the same way: type /auth or /headers and fill them in. Here's the setup from the clips below:

shop-api/
├── .voiden-inherited.void   ← bearer token, X-Api-Version, X-Client
├── users/
│   └── get-user.void        ← just GET + URL
└── orders/
    └── list-orders.void     ← GET + URL + its own headers table

get-user.void has a method and a URL, nothing else. Run it against an echo server and the request carries all three values from the folder:

Running a request that inherits auth and headers from its folder

The echo server sends back what it received: authorization: Bearer demo-token-123, x-api-version: 2026-11 and x-client: voiden-demo. None of them are in the request file.

If the importer brought requests in with an auth block you'd rather not delete, set that block's type to Inherit in the dropdown. Voiden then treats the request as having no auth of its own and uses the folder's.

How a request picks up its config

You can put an inheritance file in any folder. When a request runs, Voiden walks from the request's folder up to the project root, collects every .voiden-inherited.void on the way, and fills in the blocks the request doesn't already have. The nearest folder wins, so orders/ can use a different API key from the rest of shop-api/.

This isn't a new idea. Postman, Bruno and Yaak all let a request inherit auth from a parent folder. What's worth reading closely is where Voiden behaves differently.

Two choices you might disagree with

A request's own block replaces the inherited one. It doesn't merge. Inheritance works per block type. If a request has its own headers table, it uses only that table, and the folder's headers aren't sent. Here's list-orders.void, with one header of its own, X-Team: orders:

A request with its own headers table replaces the inherited one, while auth is still inherited

x-team is there and so is the inherited authorization, because this request has no auth block. x-api-version and x-client are gone. Yaak handles this differently: a request overrides an inherited header by giving one the same name, and the other inherited headers still go out.

Replacing has a cost. If you want the shared headers plus one more, you can't add a single row. You either copy the shared rows into the request or put the extra header in an inheritance file of its own. The upside is that once a request has its own headers table, it can't pick up headers from a folder's headers table you'd forgotten about.

The inheritance file stays out of Git. When you create one from the menu, Voiden adds .voiden-inherited.void to your project's .gitignore. The obvious thing to put in this file is a token, and a committed token in a file that every request in the folder reads is a leak from all of them at once.

The cost is that your teammates don't get the file when they pull. If your team wants the same setup, write {{token}} instead of the real token, keep the value in your private environment file (also git-ignored), and remove the line from .gitignore on purpose once the file holds references only.

So which would you rather have: a request's headers merging with the folder's, or replacing them? And should a file like this be committed by default? We'd like to hear which one you'd pick, and why.

Try it on one header

Pick the header you've pasted into the most requests. Right-click the folder that holds them, choose Add Config Inheritance, and add the header there. Delete it from one request and run that request. If the header still goes out, you can delete the other copies.

Config inheritance has been in Voiden since 2.2.0, and since 2.3.3 .env files work the same way: a request picks them up from its own folder and its parent folders. The full reference is in the config inheritance docs.

Voiden is free, open source and works offline, with no account. If you don't have it yet, download it here.

Related Posts