Insomnia REST Client: Setup and Best Practices (2026)

Insomnia is a free, open source (Apache 2.0) desktop API client from Kong for sending and testing HTTP/REST, GraphQL, gRPC, WebSocket, Socket.IO and Server-Sent Events (SSE) requests, and it can also act as an MCP client. To use it well: install it from insomnia.rest, pick the right storage (Local Vault, Git Sync or Cloud Sync) before you create anything, put every URL and token in environment variables, chain requests with response tags or scripts, and write after-response tests so the same collection runs in CI with the Inso CLI. This guide is a practical Insomnia tutorial for beginners and teams on Insomnia 13, the current major version as of November 2026 (latest release: 13.4.0, October 29, 2026).

What Insomnia is (and what changed in version 13)

The Insomnia HTTP REST client gives you a GUI: a desktop alternative to typing curl commands. You build a request (method, URL, headers, body, auth), send it, and read the response with syntax highlighting, a timeline of the raw exchange, and saved history. On top of that it adds environments, template tags, scripting, a collection runner, OpenAPI design, mock servers and a CLI. It runs on macOS, Windows and Linux, and is developed in the open at github.com/Kong/insomnia under the Apache 2.0 license. The official site is insomnia.rest, and the documentation now lives on developer.konghq.com/insomnia.

Insomnia REST client features, at a glance:

Area	What you get
Protocols	HTTP/REST (including the new QUERY method), GraphQL, gRPC, WebSocket, Socket.IO, SSE, MCP client
Organization	Projects, API Collections, folders, multiple tabs, a tree sidebar (13.0)
Data	Environments (global, collection, folder), private environments, encrypted secrets, external vaults (Enterprise)
Automation	Pre-request and after-response JavaScript, Collection Runner with CSV/JSON iteration data
Design	OpenAPI editor with linting in the Spec tab, export to OpenAPI (13.4)
Mocking	Cloud or self-hosted mock servers, mocks generated from a spec
CLI	Inso: run collections, lint and export specs, run scripts in CI

Kong ships a major version about twice a year and minor releases about every four weeks (Insomnia docs). Recent changes worth knowing, from the official changelog and breaking changes page:

• 13.0 (June 16, 2026): a tree-based sidebar, native Kong Konnect sync, and a switch of the template engine from Nunjucks to LiquidJS. Most templates work unchanged, but some tag syntax needs manual fixes after upgrading (see the table below). Plugins now run in a separate hidden background window, so plugins that reach into the app's UI, or call Node.js APIs at the top level of their entry file, break.
• 13.1 (July 24, 2026): Git Sync projects can live anywhere on disk and read your ~/.gitconfig; first-class support for the HTTP QUERY method.
• 13.2 (August 25, 2026): sidebar focus mode, persistent vault links, JSONPath match counts.
• 13.3 (September 23, 2026): the old "Document" and "Collection" workspace types merged into one API Collection with Spec and Tests tabs, plus an opt-in sandboxed script engine.
• 13.4 (October 29, 2026): confidential environment variables that are masked in previews and logs, a visual diff for Git Sync, and Export OpenAPI Spec.

If you follow an older tutorial and the menus don't match, this is why.

LiquidJS syntax changes in 13.0 that you may need to fix by hand (breaking changes):

What	Nunjucks (12.x and older)	LiquidJS (13.x)
Assign a variable	{% set x = "val" %}	{% assign x = "val" %}
Else-if	{% elif cond %}	{% elsif cond %}
Filter arguments	{{ s | replace('a','b') }}	{{ s | replace: 'a', 'b' }}
Uppercase	upper	upcase
Removed filters	batch, groupby, striptags, nl2br	no direct equivalent

Plain variables such as {{ _.base_url }} and the built-in template tags keep working.

1. Sep 27, 20238.0: Organizations replace Teams, unlimited cloud projects, SSO, Server-Sent Events. Using anything beyond the Scratch Pad now requires an account, which caused a large community backlash.
2. Oct 16, 20238.3: local-only projects return as Local Vault, and projects can be converted between cloud and local (announcement).
3. Dec 19, 20238.5: Git Sync or Insomnia Sync for every file type.
4. Apr 24, 20249.0: pre-request scripts with insomnia.sendRequest, insomnia.test and insomnia.expect, mock servers, Buf Schema Registry for gRPC.
5. Jun 27, 20249.3: after-response scripts, folder-level inheritance of auth, headers and scripts, global environments. 9.3.3 adds the collection runner to Inso.
6. Sep 10, 202410.0: new onboarding, offline commits for sync, Postman environment and data-dump import.
7. Mar 18, 202511.0: Insomnia Format v5 (YAML), Git Projects, multiple tabs, vault key UI and secrets in private global environments.
8. Nov 3, 202512.0: MCP clients, AI commit messages and AI-generated mock servers.
9. Jun 16, 202613.0: tree sidebar, Konnect sync, Nunjucks replaced by LiquidJS, plugin isolation.
10. Oct 29, 202613.4: confidential variables, visual Git diff, OpenAPI export. Current release as of November 2026.

Dates are the GitHub release dates from Kong/insomnia releases; feature notes are from the changelog.

How to install Insomnia

How to install the Insomnia API client on each platform:

• Windows: download the installer from insomnia.rest/download and run it. Since 11.3 the Windows build uses an NSIS installer.
• macOS: download the .dmg from the same page, or use Homebrew. The cask is called insomnia:

brew install --cask insomnia

• Linux: the download page offers packages for Linux distributions.

The app updates itself (Homebrew marks the cask as auto-updating), so you rarely need to reinstall. For the command line, install Inso separately (see Best practice 6).

Do you need an account? The Insomnia 8 login story

This is the question most people searching for Insomnia actually have, so here is the short history:

1. Before September 2023 (2023.5.x and older), you could use everything locally with no account.
2. Insomnia 8.0 (September 27, 2023) introduced Organizations and cloud projects, and required a login for anything beyond the local Scratch Pad. Users who updated found their existing collections behind a login screen, which led to long threads on GitHub (for example discussion #7362) and Reddit, and to forks like Insomnium.
3. Insomnia 8.3 (October 16, 2023) brought local-only storage back as Local Vault. Kong's announcement was explicit that a free account is still needed for Local Vault, and that the Scratch Pad keeps working without one.
4. Today (13.x) the rule is the same. The README says Insomnia does not require an account if you use the local Scratch Pad, and the storage docs show a Use the local Scratch Pad option on the login screen.

So: you can send requests offline with no account in the Scratch Pad. For real projects you sign up once (free), and then choose where data lives. Local Vault keeps all project data on your machine; logging in does not by itself upload your requests.

Best practice 1: choose storage deliberately

Every project in Insomnia has a storage type, and it decides where your requests (and anything secret inside them) end up (storage docs):

Storage	Where data lives	Account	Use it when
Scratch Pad	Only on your machine	Not needed	Quick throwaway requests, trying Insomnia out
Local Vault	Only on your machine	Free account	Solo work, sensitive APIs, company rules against cloud storage
Git Sync	A Git repository you control (GitHub, GitLab, Bitbucket or any other)	Free account	Teams that want collections reviewed in pull requests next to the code
Cloud Sync	Insomnia Cloud, end-to-end encrypted	Free account	Quick sharing and branching without managing a repo

For team work, Git Sync is usually the best choice: request changes show up as diffs (13.4 adds a per-entity visual diff), and the collection version matches the API version in the same branch. Since 12.6 Git Sync projects are stored as files on disk that you can edit with other tools, and since 13.1 they can live anywhere on disk. On the free Essentials plan, Git Sync is available for up to 3 users; Pro ($12 per user per month as of November 2026) removes that limit and raises mock requests from 1,000 to 10,000 per month (pricing). Collection runs are unlimited on all plans.

You can change storage later under Project Settings > Type > Change. Two conversions are worth knowing before you click:

The Scratch Pad is a local workspace for quick, throwaway requests and needs no login; don't keep anything important there.

How to use Insomnia: your first requests (a CRUD walkthrough)

This short Insomnia tutorial is an Insomnia CRUD walkthrough using JSONPlaceholder, a free fake REST API, so you can follow along without a backend. It shows how to use Insomnia for create, read, update and delete.

1. Create a project and collection. Pick a storage type, then click + and create an API Collection (since 13.3 one collection holds requests, an OpenAPI spec and tests).
2. Add a base environment (environment icon in the sidebar) with { "base_url": "https://jsonplaceholder.typicode.com" }.
3. Create a request with + > HTTP Request. Leave the method as GET and type {{ _.base_url }}/posts/1. Click Send. The right pane shows the status (200), time, size, and the JSON body; the Timeline tab shows the raw request and response headers.
4. Insomnia POST request: duplicate the request (right-click > Duplicate), switch the method to POST, set the URL to {{ _.base_url }}/posts, open the Body tab, choose JSON and enter:

{ "title": "hello", "body": "from Insomnia", "userId": 1 }

Insomnia sets Content-Type: application/json for you. JSONPlaceholder answers 201 Created with an id. 5. Update and delete: a PUT or PATCH to {{ _.base_url }}/posts/1 with a JSON body updates the post; a DELETE to the same URL removes it. 6. Save as you go. Requests save automatically. Name them by intent (see the next section).

Shortcuts worth learning early: Ctrl+Space (Control+Space on macOS too) autocompletes variables and template tags in any field, and pasting a curl command into the URL bar turns it into a full request. If you have a cURL command in another language's format, our cURL converter helps.

Best practice 2: organize requests like your API

• One collection per API or service, not per developer.
• Folders by resource (/users, /orders, /auth), mirroring your routes. Folders can carry their own auth, headers, scripts and environment, which child requests inherit (since 9.3).
• Name requests by intent: Create order (valid), Create order (missing SKU → 400). Negative cases are as valuable as happy paths.
• Import instead of retyping: Insomnia imports OpenAPI 3.0/3.1 and Swagger specs, Postman v2.0/v2.1 collections, HAR files, WSDL, cURL commands and Insomnia v4/v5 files (import docs).
• Use the Spec tab when you have an OpenAPI file: Insomnia can generate requests from it, so the collection stays close to the contract.

Best practice 3: put everything variable in environments

Hard-coded hosts and tokens are the most common Insomnia mistake. Insomnia has several environment levels (environments docs): global environments (shared by every collection in a project), collection environments, and folder environments. Global and collection environments have a base environment and optional sub-environments (for example local, staging, production) that inherit everything from the base and override only what differs.

When the same variable is defined in several places, Insomnia resolves it in this order:

1. Folder environment
2. Selected collection sub-environment
3. Collection base environment
4. Selected global sub-environment
5. Global base environment

In scripts, temporary variables (insomnia.variables) and iteration data from the Collection Runner are checked before all of these.

A typical collection base environment:

{
  "base_url": "http://localhost:3000",
  "api_version": "v1"
}

And a staging sub-environment:

{
  "base_url": "https://staging.example.com"
}

Reference variables in any field, for example a URL of {{ _.base_url }}/{{ _.api_version }}/users. Press Ctrl+Space in a field to autocomplete variables and template tags. Since 13.3 the environment picker is split into a project dropdown and a collection dropdown, so check both when a value looks wrong.

Built-in template tags cover most dynamic values without scripts (template tags): Timestamp (the current timestamp in a chosen format), UUID (v1 or v4), Base64, Hash, Faker (random test data), Prompt (ask for a value at send time), Cookie, File, JSONPath, Request, Response and External Vault. To check a Unix timestamp you got back, our timestamp converter is quicker than doing the math.

Keep secrets out of synced data

• Mark a sub-environment as private: private environments are not synced or exported, and need a vault key to open.
• For tokens and passwords, use secret variables. Generate a vault key first in Preferences, then mark the variable as Secret. Secrets are stored encrypted locally, masked by default, and only available in private global sub-environments; you reference them in the vault namespace, for example {{ vault.api_token }}. Insomnia does not save the vault key for you: if you lose it, the stored secrets are deleted.
• Confidential variables (13.4+) are a lighter option: values show as dots in previews, generated code, the timeline and the console, but they are not encrypted and are exported in plain text. Treat them as screen-share protection, not security.
• With Git Sync, Insomnia does not stop you from committing a token. Kong's docs recommend private environments, external vaults, or a secret scanner on the repository.
• Enterprise plans can pull secrets from AWS, GCP, Azure or HashiCorp vaults instead.

Authentication types in Insomnia

Open the Auth tab of a request (or a folder, so every child request inherits it) and pick a type. Insomnia supports (auth docs):

Auth type	Typical use
Basic	Simple username and password APIs, internal tools
Digest	Legacy servers and some devices
OAuth 1.0	Older APIs that sign each request
OAuth 2.0	Most modern SaaS APIs; Insomnia fetches and refreshes the token for you
Bearer Token	JWTs and personal access tokens, e.g. {{ _.token }}
Microsoft NTLM	Windows-integrated services
AWS IAM v4	Signed calls to AWS APIs
Hawk	Hawk-signed APIs
Atlassian ASAP	Service-to-service auth at Atlassian
Netrc file	Reusing credentials from a .netrc file

For API keys sent in a header, add the header (for example X-API-Key: {{ vault.api_key }}) on the folder. To inspect a token you received, paste it into our JWT decoder. For mutual TLS, add a client certificate in the collection settings under Client Certificates; Insomnia only sends it when the request's host (and port, if set) matches the certificate's domain (client certificate docs).

GraphQL, gRPC, WebSocket and other protocols

GraphQL. Create a GraphQL request and point it at your endpoint. Insomnia runs an introspection query (with your auth and headers) to fetch the schema, then gives you autocomplete, inline validation and a documentation explorer (Schema > Show Documentation). Put variables in the separate Query Variables pane as JSON: queries themselves cannot contain Insomnia templating, but variables can (GraphQL docs). Insomnia builds the query, variables and operationName body for you.

gRPC. Create a gRPC request, enter the host (for example grpcs://grpcb.in:9001), and load the schema in one of three ways: upload a .proto file or a folder of them, use server reflection if the server supports it, or connect to the Buf Schema Registry with an API token and module path. All four call types work: unary, client streaming, server streaming and bidirectional streaming (gRPC docs). Since 10.3 you can skip TLS verification and use mTLS. Current limits per Kong: no request chaining, no unit tests, no deadlines and no saved history for gRPC.

WebSocket. Create a WebSocket request, set the ws:// or wss:// URL, headers and auth, then Connect. Send messages as JSON or raw text; sent and received messages appear in the Events panel. Environment variables and template tags work in the URL and message body. Custom WebSocket subprotocols are not supported (request docs).

Socket.IO and SSE. Socket.IO request types arrived in 11.4 (with a custom handshake path in 12.5), and Server-Sent Events have been supported since 8.0.

Insomnia MCP client. Since 12.0, Insomnia can connect to Model Context Protocol servers to list and call their tools, prompts and resources, which helps when you build tools for AI agents. 12.x added sampling and elicitation support, and MCP clients can be stored with Git Sync and Cloud Sync.

Best practice 4: chain requests with scripts

Request chaining means using a value from one response (a token, an ID) in the next request. Insomnia gives you two ways to do it.

Option A: the Response template tag (no code). In the field where the value should go, type response and choose Response > Body Attribute. Click the tag and set Request to the earlier request, Filter to a JSONPath such as $.token or $.[0].number, and Trigger Behavior to decide when Insomnia re-sends the source request (Kong's example uses Never). The live preview shows the value it will use (chain requests guide). Test the JSONPath first with our JSONPath tester if the response is large.

Option B: scripts. Insomnia supports pre-request and after-response scripts written in JavaScript (scripting docs). The most common use is logging in once and reusing the token.

After-response script on a POST {{ _.base_url }}/auth/login request:

const body = insomnia.response.json();

insomnia.test('login succeeds', () => {
  insomnia.expect(insomnia.response.status).to.eql(200);
  insomnia.expect(body.token).to.be.a('string');
});

insomnia.environment.set('token', body.token);

Then set the Auth tab of other requests to Bearer Token with the value {{ _.token }}. Set auth on a folder once and let child requests inherit it instead of repeating it on every request.

Pre-request scripts are useful for timestamps, signatures or computed headers:

insomnia.environment.set('request_time', new Date().toISOString());

Signing a request with HMAC, using the bundled crypto-js module:

const CryptoJS = require('crypto-js');
const secret = insomnia.environment.get('signing_secret');
const ts = Date.now().toString();
const sig = CryptoJS.HmacSHA256(ts + insomnia.request.url.toString(), secret).toString();

insomnia.request.addHeader({ key: 'X-Timestamp', value: ts });
insomnia.request.addHeader({ key: 'X-Signature', value: sig });

Fetching a token inside a script with insomnia.sendRequest, so one request handles its own login:

insomnia.sendRequest({
  url: insomnia.environment.get('base_url') + '/auth/login',
  method: 'POST',
  header: { 'Content-Type': 'application/json' },
  body: { mode: 'raw', raw: JSON.stringify({ user: 'ci', pass: insomnia.environment.get('ci_password') }) },
}, (err, resp) => {
  if (err) throw err;
  insomnia.environment.set('token', resp.json().token);
});

The scripting API at a glance:

Object	What it does
insomnia.environment	Get, set and unset values in the selected environment
insomnia.baseEnvironment	The collection base environment
insomnia.collectionVariables	Collection variables (maps to the base environment for Postman scripts)
insomnia.variables	Temporary variables for this run only
insomnia.request	Change method, URL, headers, body, auth or proxy before sending
insomnia.response	Read status, responseTime, json(), text(), headers and cookies
insomnia.sendRequest	Send another request from a script
insomnia.test / insomnia.expect	Named tests with Chai-style assertions
insomnia.parentFolders	Read a parent folder's environment
insomnia.vault.get	Read a secret (enable "vault in scripts" in Preferences first)

require() gives you ajv, atob, btoa, chai, cheerio, crypto-js, csv-parse/lib/sync, lodash, moment, postman-collection, tv4, uuid, xml2js, and Node's assert, buffer, events, path, querystring, punycode, stream, string_decoder, timers, url and util. Top-level await is allowed.

Scripts can read folder variables with insomnia.parentFolders.get('Orders').environment.get('order_id'), but only when the request is inside that folder.

Best practice 5: turn collections into tests

This is where Insomnia API testing starts. Every insomnia.test(...) block shows up in the Tests results and in the Collection Runner, which runs a folder or a whole collection in order, with optional iterations and CSV/JSON data files. Write at least one status assertion and one body assertion per request:

insomnia.test('returns the created order', () => {
  insomnia.expect(insomnia.response.status).to.be.oneOf([200, 201]);
  const order = insomnia.response.json();
  insomnia.expect(order.id).to.be.a('string');
});

A few more assertions that catch real regressions:

insomnia.test('is fast enough', () => {
  insomnia.expect(insomnia.response.responseTime).to.be.below(800);
});

insomnia.test('returns JSON', () => {
  insomnia.expect(insomnia.response.headers.get('Content-Type')).to.include('application/json');
});

For data-driven tests, put rows in a CSV (email,expected_status) and select it in the runner; each row becomes one iteration and its columns are available as variables. Kong deprecated the old "unit tests" inside design documents in 2025 and recommends after-response scripts for all tests (breaking changes).

Best practice 6: run the same collection in CI with Inso

The Inso CLI runs Insomnia collections and lints OpenAPI specs from a terminal or pipeline:

brew install inso                 # macOS; Docker image: kong/inso
inso run collection "Orders API" --env "staging"
inso lint spec "Orders API"
inso export spec "Orders API" --output openapi.yaml

Inso looks for data in the .insomnia folder of the working directory (Git Sync creates it) and then in the Insomnia app's data folder; point it elsewhere with -w/--workingDir. Useful flags for inso run collection (reference):

Flag	Purpose
-e, --env	Environment to use
--env-var key=value	Override a variable (inject CI secrets)
-n, --iteration-count / -d, --iteration-data	Repeat the run, or feed a CSV/JSON file
-t, --requestNamePattern	Run only requests whose names match a regex
-r, --reporter	dot, list, min, progress, spec or tap
-b, --bail	Stop after the first non-200 response
--requestTimeout	Request timeout in ms
--output	Write results to a JSON file
--ci	Disable all prompts

A GitHub Actions job using the Docker image:

name: API tests
on: [push]
jobs:
  insomnia:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Insomnia collection
        run: |
          docker run --rm -v "$PWD:/var/temp" -w /var/temp kong/inso:latest \
            run collection "Orders API" --env "CI" --ci --reporter spec \
            --env-var "token=${{ secrets.API_TOKEN }}"

With Git Sync, CI already has the collection files in the repository, so the pipeline tests exactly what's on the branch. Use a non-production environment and a dedicated test account for CI runs, and pass secrets with --env-var instead of committing them.

Importing from Postman

Moving from Postman takes a few minutes (Kong migration guide):

1. In Postman, export your collections as Collection v2.1 JSON, and export environments as JSON (or export all data as a ZIP).
2. In Insomnia, create a project, click Import, and choose File, URL or Clipboard. You can select several files or the ZIP; click Scan to preview, then Import.
3. If your collections relied on Postman globals, copy them into the base environment of each collection: insomnia.globals is not supported yet.
4. Check scripts. Most Postman pm.* scripts are converted on import, but deprecated interfaces such as postman.setEnvironmentVariable are not supported, and pm.collectionVariables maps to the base environment (scripting docs).
5. Rebuild mock servers by hand: they do not import.

Run the imported collection once in the Collection Runner to catch anything that didn't convert.

Other features worth using

• Mock servers to give frontend developers an endpoint before the backend exists, either self-hosted in your infrastructure or in Kong's cloud. You can define endpoints from any HAR response, generate mocks for every route of an OpenAPI spec, or describe endpoints in plain language and let AI generate them (API mocking). Free: 1,000 mock requests per month.
• Code generation: right-click a request and generate a snippet for cURL, JavaScript fetch, Python and more.
• MCP client: Insomnia can connect to and debug MCP servers, which helps if you build tools for AI agents.
• AI helpers (12.0+): suggested Git commit messages and mock servers generated from a description.
• Plugins for custom template tags and auth flows; check they support Insomnia 13 before installing.

Swagger vs Insomnia for API design, documentation and testing

People often compare Swagger and Insomnia, but they do different jobs. Swagger is a family of tools around the OpenAPI specification (Swagger Editor, Swagger UI, Codegen); Insomnia is a client that also edits OpenAPI files.

Job	Swagger tools	Insomnia
Swagger vs Insomnia for API design	Swagger Editor: write and validate an OpenAPI file	Spec tab in an API Collection, with linting (inso lint spec) and requests generated from the spec
Swagger vs Insomnia for API documentation	Swagger UI: publish interactive public docs from the spec	Not a doc publisher; export the spec (13.4) and publish it with another tool
Swagger vs Insomnia for API testing	"Try it out" sends one-off calls from the docs page	Environments, chaining, scripted tests, Collection Runner and Inso in CI
Mocking	Not built in to Swagger UI	Cloud or self-hosted mocks from the spec

A common setup: keep openapi.yaml in the repo, design it in Insomnia's Spec tab or any editor, publish docs with Swagger UI or a similar renderer, and test with Insomnia collections. For writing the docs themselves, see our REST API documentation best practices.

REST API vs Insomnia: what's the difference?

A REST API is the server side: an interface your backend exposes over HTTP. Insomnia is a REST client: a tool you use to call that interface. Asking "REST API vs Insomnia" is like asking "website vs browser": the Insomnia REST API client is the browser. You build an Insomnia REST API workflow by pointing Insomnia at an API's base URL, adding auth, and sending requests. Most people start with plain REST. Insomnia then grows with you into GraphQL, gRPC and WebSockets. If you're new to calling APIs, our guide to calling an API in 5 steps covers the basics, and the HTTP status codes reference explains every response you'll see.

Insomnia vs Postman and other alternatives

Postman is the best-known REST client. Insomnia and Postman cover similar ground: collections, environments, scripting, mocks and a CLI. Insomnia's main differences are that the desktop app is open source and that Local Vault and Git Sync let you keep data entirely off a vendor cloud. Postman has the larger ecosystem and public API network, and its free plan is now limited to one user. For a feature and pricing breakdown, see Insomnia vs Postman.

If you want something lighter, Bruno stores collections as plain files in your repo and works offline, and Hoppscotch runs in the browser. More options are on our free Postman alternatives page, in our roundup of the best REST clients, and in the API tools category.

How the four compare as of November 2026:

	Insomnia	Postman	Bruno	Hoppscotch
License	Apache 2.0 (GitHub)	Proprietary	MIT (GitHub)	MIT (GitHub)
Free plan	Unlimited projects; Git Sync for 3 users; 1,000 mocks/month	1 user; 1,000 monitor requests/month	Open source core; public Git providers; 2 workspaces	Personal workspace, collections, scripts, runner
Cheapest paid tier	Pro $12/user/month	Solo $9/month; Team $19/user/month (annual)	Pro $6/user/month (annual)	Business $6/user/month (annual)
Where data lives	Local Vault, your Git repo, or Insomnia Cloud	Postman cloud workspaces	Plain-text files in a folder; offline only, no cloud sync	Browser/desktop app, Hoppscotch cloud or self-hosted
Account needed	Only beyond the Scratch Pad	Only beyond the lightweight client	No	Team features need an account
Protocols	HTTP, GraphQL, gRPC, WebSocket, SSE, Socket.IO, MCP	HTTP, GraphQL, gRPC, WebSocket, Socket.IO, MQTT	HTTP, GraphQL, gRPC	HTTP, GraphQL, WebSocket, SSE, Socket.IO, MQTT
CLI for CI	inso run collection	postman collection run	bru run (@usebruno/cli)	@hoppscotch/cli

Sources: Insomnia pricing, Postman pricing and lightweight client docs, Postman CLI, Bruno pricing, Hoppscotch pricing, and each project's README.

Hoppscotch 80.7k

Bruno 48k

Insomnia 40.1k

Stars measure interest in the open source repos, not usage. Postman is closed source, so it has no comparable figure. Source: GitHub repository pages

Postman Team $19

Insomnia Pro $12

Bruno Pro $6

Hoppscotch Business $6

Postman Team, Bruno Pro and Hoppscotch Business are billed annually; Insomnia's page lists $12 without stating the billing cycle. Postman Solo ($9/month) is for one person only. Source: Vendor pricing pages, November 2026

For a broader view of where an API client fits next to gateways and design tools, see choosing an API development platform.

Troubleshooting common Insomnia problems

• "Insomnia increase timeout": go to Preferences > General > Request / Response > Request timeout (ms). The default is 30,000 ms; raise it for slow endpoints. In CI, use inso run collection --requestTimeout 60000.
• Self-signed certificate errors on localhost: turn off certificate validation in Preferences for local work only, or add your CA as a trusted certificate. In Inso, the equivalent is --disableCertValidation.
• Templates broke after upgrading to 13: fix the LiquidJS syntax listed in the 13.0 table above (assign, elsif, upcase, filter arguments with colons).
• A plugin stopped working after 13.0: plugins now run in an isolated window; update the plugin or check its repository for a v13 release.
• Variable shows as undefined or red: check which environment is selected in both the project and collection dropdowns (13.3+), and remember folder environments win over everything else.
• Projects disappeared after logging in or out: cloud and Git projects belong to an organization; switch organizations in the sidebar. Local Vault data stays on your machine.
• Git Sync push failed: credentials now live under Preferences > Credentials (12.3+) and Insomnia can read your ~/.gitconfig (13.1+); re-authorize there.
• Corporate proxy: the Insomnia HTTP client can use a proxy: set HTTP/HTTPS proxy and no-proxy hosts in Preferences; Inso has --httpProxy, --httpsProxy and --noProxy.

Limitations to know

• The free plan's Git Sync is capped at 3 users.
• An account is required for anything beyond the Scratch Pad, even for Local Vault projects that never leave your machine.
• Major releases can break plugins and template tags (13.0 did both); read the breaking changes page before upgrading a team.
• Secret variables only live in private global sub-environments, which is less flexible than per-collection secrets. Confidential variables are masked, not encrypted.
• gRPC requests have no chaining, tests or saved history yet.
• Custom WebSocket subprotocols are not supported, and there is no MQTT support (Postman and Hoppscotch have it).

FAQ

Is Insomnia a REST client?

Yes. Insomnia is a desktop REST API client, and it also supports GraphQL, gRPC, WebSockets, Socket.IO and Server-Sent Events. It adds environments, scripting, tests, mocks and OpenAPI design on top.

Is the Insomnia REST client free?

The app is open source under Apache 2.0, and the Essentials plan is $0 with unlimited local and cloud projects, unlimited collection runs, 1,000 mock requests per month and Git Sync for up to 3 users. Paid plans add more Git Sync users, mocks and enterprise controls: Pro is $12 and Enterprise $45 per user per month as of November 2026.

Is Insomnia open source?

Yes. The source is in the Insomnia GitHub repository, Kong/insomnia, under the Apache 2.0 license, with about 40,100 stars as of November 2026. Kong also sells paid plans for team features such as unlimited Git Sync users, SSO and vault integrations.

What is the difference between Postman and Insomnia?

Both send and test API requests. Insomnia is open source and lets you store data locally or in your own Git repo; Postman is closed source, cloud-first and has a larger ecosystem. See the full comparison.

How do I download Insomnia for Windows?

Get the Windows installer from insomnia.rest/download. Installers are also available there for macOS and Linux.

How do I install Insomnia with Homebrew?

Run brew install --cask insomnia for the desktop app and brew install inso for the CLI. Brew install Insomnia once; the app updates itself after that.

Does Insomnia require an account or login?

Not for the Scratch Pad, which works fully offline. Since Insomnia 8.0 (September 2023), projects (Local Vault, Git Sync, Cloud Sync) need a free account. Local Vault still keeps all data on your device.

Can I use Insomnia without uploading my data to the cloud?

Yes. Create projects with Local Vault storage (data stays on your device) or Git Sync (data goes only to the Git repository you choose), and use private environments and secret variables for credentials.

How do I import a Postman collection into Insomnia?

Export the collection from Postman as Collection v2.1 JSON, then click Import in your Insomnia project and choose the file (or a ZIP of all your Postman data). Most scripts convert automatically; globals and mock servers need manual work.

How do I chain requests in Insomnia?

Use a Response template tag (pick the source request and a JSONPath filter such as $.token), or an after-response script that saves a value with insomnia.environment.set('token', ...) and reference it as {{ _.token }}.

How do I add the current timestamp to an Insomnia request?

Press Ctrl+Space in the field and insert the Timestamp template tag, then pick a format. In a pre-request script you can also set insomnia.environment.set('now', Date.now()).

Can Insomnia test GraphQL and gRPC APIs?

Yes. GraphQL requests get schema introspection, autocomplete and a docs explorer. gRPC requests load the schema from proto files, server reflection or the Buf Schema Registry and support unary and all streaming call types.