The switching guide

Leaving Insomnia? Make the repo the source of truth.

Bandura is an Insomnia alternative with one storage mode: your repository. Insomnia can store a project locally, in Git, or in Kong's cloud, and which of those you get has been a vendor decision more than once. Bandura only has the one mode. A flow is a plain-YAML .aether file that you put in your repository; the app reads it from disk and writes it back. There is no store to mirror, no account to create, and no seat to rent. Your Insomnia v4 export, requests and environments together, comes across in a single pass.

v1.0.0-rc.8 is out now on Windows and Linux. v1.0.0 final, and signed macOS builds, in August 2026.

Download for Windows or Linux
or

One email when the signed macOS build and 1.0.0 ship, no reselling, opt out any time.

Windows · Linux · macOS when notarized  ·  Why people look ↓  ·  Importing your export ↓  ·  Where Insomnia still wins ↓

Why people go looking

The 8.0 episode is over. The shape it revealed isn't.

In September 2023 Insomnia 8.0 moved everyone toward an account and cloud storage. The reaction was loud, and Kong reversed it: local-only projects returned in 8.3 later the same year, and they are there today. Anyone still telling you Insomnia requires an account is repeating a three-year-old fact. What the episode did make visible is worth stating carefully.

Storage mode is a setting someone else owns

Local, Git, and cloud are three modes of one product, and which of them you have (and on which plan) is a decision made upstream of you. The Enterprise tier even sells the ability to mandate where projects are stored, which tells you whose lever it is. Bandura has one mode, and it is a folder.

Git Sync is a mirror, not the format

Insomnia acts as a Git client inside the app and writes project resources into your repo as YAML, along with metadata it maintains to support application features, which is why a diff can move when the request didn't. Kong's own docs note you can't restructure a project from Insomnia's UI; that has to happen in Git. It works. It is still a mirror of an internal store.

The free tier counts your teammates

As of August 2026, Essentials gives Git Sync to three users; past that it is $12 per user per month on Pro and $45 on Enterprise, billed annually. Paying per head to keep files in a repository you already own is the part that sends people searching.

Chaining is still scripting

Insomnia is an excellent request client. A three-step scenario (log in, capture the token, branch on what came back, retry the flaky one) is code you write in the request, and code you then own. Bandura makes those steps node types in the same file the graph draws.

Checked August 2026 against insomnia.rest/pricing, Kong's Git Sync documentation, and Kong's 8.0 and 8.3 release posts. Corrections welcome at [email protected]. We would rather fix a line than win an argument with a stale number.

What actually changes

The file stops being an artefact and starts being the thing.

Every capability named below is in the app today. Nothing here is a plan.

One flow, one file, wherever you put it

A .aether file is YAML you can read without us. Routing lives on the nodes, in next, then and else, so the graph is derived from the text rather than stored beside it, and a reviewer on GitHub sees the whole change. No export step, because there was no import step. Git-native API testing →

Ten node types, not one plus scripting

Request, gRPC, WebSocket, assertion, condition, loop, parallel, subflow, script, and ai-action. Retry and poll-until are lines of config rather than a loop you maintain. Hooks run before, after, and on error around every request-like node, which is where signing and correlation ids belong. Node reference →

Graph and code, both editable, same file

Wire two nodes on the canvas and the YAML changes; type in the YAML and the graph redraws. Neither view is a read-only preview of the other, and there is no third representation hiding in a database.

A debugger, not just a runner

Breakpoints, step, run-one-node, run-from-node, loop-iteration badges, and a variables panel that tells you where each value came from. Breakpoints live on your machine, never in the flow file, so nobody's debugging session lands in someone else's diff. Run and debug →

Headless, and first-party

The same engine runs in the desktop app, in a compiled CLI binary with JUnit and GitHub-annotation reporters, and in a local MCP server that gives Claude Code or Cursor fourteen tools over stdio. Same file, same result, no relay. The MCP server →

Bring your own model, or host it

Anthropic and Gemini natively, or any OpenAI-compatible /chat/completions endpoint with a base URL you set. Point it at http://localhost:11434/v1 and the chat, flow generation and the ai-action node run on your own hardware with no key at all. Local models →

Same request, two file formats

One is a record. One is the test.

Insomnia v4 export one request, as the exporter writes it

{
  "_type": "request",
  "_id": "req_8f2c1e40b7d24e0f",
  "parentId": "fld_2a7b93c1",
  "name": "Login",
  "method": "POST",
  "url": "{{ _.baseUrl }}/auth/login",
  "body": {
    "mimeType": "application/json",
    "text": "{\"email\":\"{{ _.email }}\"}"
  },
  "headers": [
    {
      "name": "Content-Type",
      "value": "application/json"
    }
  ],
  "metaSortKey": -1699999999
}

.aether flow what the importer writes to your repo

- id: login
  type: request
  config:
    method: POST
    url: ${{ variables.baseUrl }}/auth/login
    headers:
      Content-Type: application/json
    body: |
      { "email": "${{ env.DEMO_EMAIL }}" }
    capture:
      accessToken: response.body.token
  next: get_cart

Three differences do real work. The _id and parentId are gone: position comes from next, so the ordering is in the file rather than in a metaSortKey the app maintains. The body is readable YAML instead of a JSON string escaped inside JSON, which is why a diff on it is legible. And capture names a value from this response for the next node to use, which in a request client is the step that has to be a script. The routing field is also what the canvas draws, so this text and the graph are the same object.

The migration

One export, one pass, requests and environments together.

Insomnia keeps both halves in the same v4 JSON, so Bandura reads both halves at once. You do not run the import twice.

  1. Preferences → Data → Export Data → Insomnia v4 (JSON)

    One file with your requests and your environments in it. Nothing is deleted on the Insomnia side, so you can leave the app installed while you decide.

  2. Drop the JSON on Bandura, then read the review

    Before a byte is written you see the detected format, every flow it found with its node count and the requests it makes, the environment variables it picked up, checkboxes to take only some of them, and an editable destination folder. Each request becomes its own .aether flow with a status assertion and structured pathParams/queryParams rather than params baked into a URL string. Existing files are never overwritten.

  3. git add flows/ && ▶ Run

    Environment values are now .env entries with their names recorded in the manifest, so a teammate who clones gets told which variables are missing before anything is sent.

# Application → Preferences → Data → Export Data → Insomnia v4 (JSON)
bandura import insomnia-export.json

# Requests AND environments come across in the same pass:
# flows to .aether files, environment values to .env

Honest about the edges: method, URL, headers, JSON and form bodies, path and query params, and bearer/basic auth come across. GraphQL bodies, gRPC and WebSocket requests, pre-request scripts, and OAuth flows are skipped rather than half-imported, because a silently mangled request is worse than a named gap. Import reference →

The Import flows review step: a detected-format badge reading 3 flows, three ticked rows naming login, list_orders and cancel_order with their node counts and methods, an editable Destination folder, and Back, Cancel and Import buttons The Import flows review step: a detected-format badge reading 3 flows, three ticked rows naming login, list_orders and cancel_order with their node counts and methods, an editable Destination folder, and Back, Cancel and Import buttons
One review step for every format. This capture happens to have a Postman collection in it, and an Insomnia v4 export takes exactly the same path through it, environments included.

Head to head

Bandura vs Insomnia, as of August 2026.

Bandura compared with Insomnia across sixteen capabilities. Four rows go to Insomnia outright and one is a tie. Reviewed August 2026.
Bandura Insomnia
Where tests live Plain-YAML files you place in your repo; the file is the format Local, Git Sync, or cloud project: a per-project storage mode
Git model No sync step: the app reads and writes the files directly In-app Git client mirroring a project, plus its own metadata
Git for the whole team Unlimited; it's just a repository 3 users on the free tier; unlimited from $12/user/month
Account required None exists; there's no server to sign into Not for local projects; yes for cloud and paid tiers
Protocols REST, GraphQL, gRPC, WebSocket, SSE REST, GraphQL, gRPC, WebSocket, SSE. The same set
Visual flow editing ✓ graph and code are two renderings of one file ✗ request-and-folder tree
Multi-step logic Declarative nodes: condition, loop, parallel, subflow, retry/poll-until Chained requests plus JavaScript
Step-through debugging ✓ breakpoints, step, run-from-node, loop-iteration badges
Drift detection against OpenAPI ✓ deterministic, offline, per-finding fixes ✗ (spec-driven design tooling is a different job)
Mock server Generated from your flows, runs on loopback; as detailed as your assertions Hosted and metered: 1,000 requests/month free, more on paid tiers
Plugin ecosystem ✗ no plugin API ✓ an established plugin API with a public hub
Source availability ✗ commercial licence; the .aether format is open and documented ✓ Apache-2.0 on GitHub: auditable and forkable
Track record First public build August 2026: 1.0.0-rc.8, on Windows and Linux, with 1.0.0 final and signed macOS builds still to come Shipping since 2016, maintained by Kong, on a regular release cadence
AI BYO key (Anthropic, Gemini, OpenAI-compatible) or a local model; agentic chat, generation, and an in-flow node Built-in AI features, on Kong's platform
MCP direction Server: exposes your flows to an agent over local stdio, bundled in the CLI Client: Insomnia 12 added tooling to call and inspect other people's MCP servers
What it costs Free download; one-time per-seat licence for commercial use, priced at launch, covering 12 months of updates, after which the build you have keeps working Free (Essentials) · $12 Pro · $45 Enterprise, per user/month billed annually

Four rows go to Insomnia outright, one is a tie, and two point in different directions rather than up. Those are not throwaways: an Apache-2.0 codebase you can audit and fork, a plugin API, a hosted mock, and a decade of shipping are real advantages over a product that has not had its 1.0 yet. The MCP row is a genuine difference in kind, not in quality: Insomnia's tooling calls MCP servers, and Bandura is one. Pricing and feature rows checked August 2026 against insomnia.rest/pricing and Kong's Insomnia documentation.

When to stay put

When Insomnia is still the right call.

Switch if…

  • You want the test file itself in your repo, not a mirror of a project
  • Your scenarios are multi-step and you're tired of maintaining the glue code
  • Git access for the whole team shouldn't be a billing line
  • You want a debugger over your API tests: breakpoints, step, run-from-node
  • Your CI runs API regressions and you'd rather ship one binary than a runner setup
  • Policy says request and response bodies never reach a hosted model

Stay on Insomnia if…

  • You're on a Mac: Bandura's macOS builds wait on notarization, and Windows installs past a SmartScreen warning
  • A decade of release history matters more than the feature list; Bandura's 1.0.0 final isn't out
  • An auditable, forkable Apache-2.0 codebase is a hard requirement
  • You rely on Insomnia plugins; Bandura has no plugin API and none is planned for 1.0
  • Its hosted mock server is load-bearing; Bandura's mock runs on your machine, from your flows
  • You're inside Kong Konnect and want the design, governance, and gateway story in one place
  • Non-developers work in your collections through the hosted UI

Other honest options: Bruno is free, MIT-licensed and git-native. If all you need is a fast request client on plain files, it is very good, and we say so at length. Yaak is a fast file-based client. Hoppscotch is open source and web-first. Bandura imports Bruno and Insomnia exports either way, so landing here later costs you nothing.

The questions a switch raises

FAQ

Is Bandura a good Insomnia alternative?

It depends which half of Insomnia you use. If you use it as a local API client and keep the results in Git, Bandura is built for that case and goes further: the .aether file is the format rather than something a sync layer writes, the graph and the code editor are two renderings of it, and ten node types cover branching, loops, parallel fan-out and subflows without a script. If you use Insomnia's cloud projects, its design and governance tooling, or its plugin ecosystem, Bandura does not replace those and is not trying to.

Does Insomnia still require an account?

No, and it would be dishonest to imply otherwise. Insomnia 8.0 in September 2023 pushed everyone toward an account and cloud storage, which caused enough of a reaction that Kong shipped local-only projects again in 8.3 later that year; their own release post is titled around bringing local projects back. What is still true as of August 2026 is the shape of the product: cloud is one of three storage modes the vendor controls, the free Essentials tier limits Git Sync to three users, and the plans above it are $12 and $45 per user per month. Bandura has nothing to log into because there is no server on our side to log into.

How is Bandura's Git story different from Insomnia's Git Sync?

Insomnia's Git Sync is a Git client inside the app that mirrors a project into a repository as YAML, plus metadata it writes to support application features. Kong's docs also note you cannot change the project structure from Insomnia's interface, only through Git tooling. Bandura skips the mirroring step: a flow is one .aether file that you put wherever you want in your repo, and the app reads it from disk. There is no store to sync from, so there is no sync commit, no structure the app owns, and no tier that decides how many people may use Git.

Can I import my Insomnia collections and environments?

Yes, and both halves in one pass, because Insomnia keeps requests and environments in the same export. Export via Application → Preferences → Data → Export Data → Insomnia v4 (JSON), drop the file on the window, and read the review step before anything is written: the detected format, each flow with its node count, the environment variables found, checkboxes, and an editable destination folder. Requests become one .aether flow each with a status assertion; environment values land in your .env with their names recorded in the manifest. Method, URL, headers, JSON and form bodies, path and query params, and bearer/basic auth come across. GraphQL bodies, gRPC and WebSocket requests, pre-request scripts and OAuth flows are skipped rather than half-imported.

Which protocols does Bandura speak, compared to Insomnia?

The same set: REST/HTTP, GraphQL, gRPC (unary and server-streaming, from a .proto file or server reflection), WebSocket, and Server-Sent Events. This is not a differentiator in either direction, and a comparison table that pretended otherwise would be wrong. The difference is what happens around a request: assertions, capture, branching, loops, parallel fan-out, subflows and retry/poll-until are node types in the file, not code you write and maintain.

Where do my API keys and settings live?

Keys go in your operating system's encrypted secret store (macOS Keychain, Windows DPAPI, libsecret on Linux) and never into a flow file or into settings. Flow-level secrets are env.* references read from your environment or a .env you do not commit. Preferences live in a hand-editable settings.json on your disk, comments allowed, with the licence key held separately so editing settings cannot invalidate it. None of it syncs anywhere, because there is nowhere for it to sync to.

What does Bandura cost against Insomnia's plans?

Bandura is free indefinitely for personal projects, learning, and open source. Commercial use is a one-time per-seat licence after a 30-day evaluation that disables nothing, priced when checkout opens at launch, covering every release built in the following 12 months, after which the build you have keeps working. Nothing auto-renews. Insomnia, as of August 2026, is free on Essentials with Git Sync capped at three users, then $12 per user per month on Pro and $45 on Enterprise, billed annually: $720 a year for a five-person team on Pro, recurring, against one payment per seat on Bandura.

My Insomnia requests use pre-request scripts. Where does that logic go?

Into one of two places, and the import names which requests carried a script rather than half-converting it. Cross-cutting work (signing, a correlation id, an audit line) belongs in the flow's hooks block, whose before, after and onError phases run around every request-like node, so one hook covers the whole flow instead of being pasted into each request. Anything specific to one step is a script node in the flow, and a hook or a script body can live in its own .js file that several flows point at, so a signing routine is written once. Both are plain JavaScript in the same scope, with a log() binding that writes to the run console.

Keep reading

The rest of the case.

Tests as files in your repo

What replaces Git Sync: a file the app reads from disk, so there is no mirror step and no sync commit to review.

Everything that works offline

The answer to the storage-mode question: there is one mode, your disk, and this page names the file each piece lands in.

Comparing Bruno too?

Bruno is free and genuinely good. The straight answer to "why pay for this instead", and Postman vs Bruno compares the two with Bandura as the third option, not row one.

Coming from Postman as well

Collections, environments, and pm.* scripts import; the migration guide covers both trips.

Run the suite in CI

The imported flows run headless from one binary, with no seat count deciding who may wire them into the pipeline.

The protocol set, in depth

How the shared set actually runs here: gRPC, WebSocket and SSE as flow nodes with assertions and capture, and GraphQL on request nodes with the same hooks as plain HTTP.

v1.0.0-rc.8 is out now. v1.0.0 final in August 2026

Your export is already the migration.

Requests and environments are in the same v4 JSON, so there is one export and one pass: drop the file on the window and read the review. Insomnia stays installed and untouched while you decide, which is the point of trying it this way. Windows and Linux builds ship with the importer in them; on a Mac, leave an address and you get the signed build the day it is notarized.

Download for Windows or Linux

One email when the signed macOS build and 1.0.0 ship, no reselling, opt out any time.

Still weighing it? The import reference lists field by field what comes across and what is deliberately skipped.