Phurpa Tsering
Your Imported Requests Lost Their Auth. Put It Back Once.
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:

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:

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

Phurpa Tsering
Where API Secrets Leak, and How to Keep Them in Your Vault
Most API keys don't leak from production. They leak from the tools we test it with: saved requests, exports, synced workspaces and curl commands. Why copies of secrets are the real problem, and how to keep only references in your requests with Vault, Doppler, Infisical, Bitwarden or KeePassXC.

Davinder singh
Agents Live on the Error Path
An error that says what to do next is an instruction. Test it like one. What an agent needs from your API errors, where hints should stop, and how to keep error contracts from breaking.
Phurpa Tsering
Turn Your Tested API Requests Into Agent-Callable MCP Tools
Turn a request you've already tested into an MCP tool that agents can call, then publish it with @voiden/mcp. Use stdio for local use, or --http/--tunnel for a server you can host.