Skip to content

Build the request. Load test it. Let your agent drive.

Vayu is a free, open source API client for REST and GraphQL with a native C++ load tester built in - and an MCP server that hands the whole engine to Claude Code, Cursor, VS Code, or Codex. One app instead of three, all of it on your machine: no account, no cloud sync, no telemetry.

MCP (Model Context Protocol) is the open standard that lets coding agents such as Claude Code or Cursor call tools; Vayu exposes its engine as one, so an agent can send the request it just wrote, load test it and read the report without leaving your editor.

Download Vayu Use it from your agent See what it does

Coming from another tool? Read the honest comparison: Postman · Bruno · k6 · JMeter

The load-test run view: rate fidelity, throughput, error counters and the pass/fail budget verdict, with the run in the history sidebar.

Install

Windows (x64), macOS 13.3+ (universal), and Linux (x86_64 AppImage and .deb). No account, no sign-in.

bash -c "$(curl --proto '=https' --tlsv1.2 -fsSL https://athrvk.github.io/vayu/install.sh)"

macOS 13.3 (Ventura) or later. Electron sets a macOS 13 floor for the app, and the engine raises it to 13.3: libc++ only ships floating-point std::to_chars from that release, and the engine cannot be built without it. The installer refuses an older macOS before downloading.

Installs the latest release to /Applications, and asks for your password once. Vayu is not code-signed, so the script ad-hoc signs the app and clears the quarantine flag - without that, macOS reports it as damaged. Not signed is not unverifiable: the script checks the download against its published checksum and refuses to install without one, and every asset of a release from 0.40.0 on carries a build-provenance attestation - confirm one by hand with gh attestation verify <file> --repo athrvk/vayu. When it finishes, it offers to open Vayu.

If you downloaded the .dmg or .zip from the release page instead, macOS says Vayu is "damaged". The file is fine; the quarantine flag on a download is what trips it. Run the command above, which is the supported route.

Updating is the same command. It keeps your collections and settings, offers to quit Vayu if it is running (and reopens it after), and does nothing if you already have the latest version - --force reinstalls anyway.

Pin a version with VAYU_VERSION=0.2.1 in front of the command, or uninstall by re-running it with -- --uninstall, which also removes the Start at login entry if you turned it on.

Do not pin a version older than 0.27.0 over existing data. Those releases have no check on the database version, so opening a workspace that 0.27.0 or later has used empties its requests and collections and overwrites the automatic .bak copy, with no error. The installer refuses while a workspace exists, before it downloads anything, and -- --allow-data-loss overrides that. Take a Workspace backup in Settings first.

winget install athrvk.Vayu

Installs the latest release with winget.

Or download the installer directly:

  1. Download Vayu-x64.exe.
  2. Run the installer and follow the wizard. When it finishes, it offers to launch Vayu.

Pinning an older version. winget install athrvk.Vayu --version <x.y.z> runs the installer of that release, and neither it nor the installer you download can check your data first. Do not install a version older than 0.27.0 over a workspace that 0.27.0 or later has opened: it empties your requests and collections without an error. Take a Workspace backup in Settings first and restore it if you go back.

If Windows shows "Windows protected your PC", that is SmartScreen stopping a file it does not recognise. Vayu is not code-signed, and a checksum and a build-provenance attestation are how you verify a download (gh attestation verify <file> --repo athrvk/vayu). Choose More info, then Run anyway. winget install athrvk.Vayu skips the prompt.

bash -c "$(curl --proto '=https' --tlsv1.2 -fsSL https://athrvk.github.io/vayu/install.sh)"

The same command as macOS. It installs the AppImage under ~/.local/share/vayu and registers a launcher entry, so Vayu shows up in your applications menu. Nothing it writes leaves your home directory, so it never asks for root. Re-run it to update. x86_64 only. When it finishes, it offers to open Vayu if a desktop session is running.

glibc 2.35 or later: Ubuntu 22.04, Linux Mint 21, Debian 12, Fedora 36 or newer. The release is built on the oldest supported Ubuntu LTS so it runs there and on everything after it.

Or take the AppImage from the latest release and run it yourself - it is self-contained either way.

If it does not start, your system is probably missing FUSE 2: sudo apt install libfuse2, or run it once with APPIMAGE_EXTRACT_AND_RUN=1.

On Debian or Ubuntu you can install the .deb instead. Download Vayu-amd64.deb from the latest release and let apt install it, which also pulls in what it depends on:

sudo apt install ./Vayu-amd64.deb

This route installs system-wide and needs sudo, and updates are not automatic: Vayu tells you when a new version is out, and you install the new .deb the same way. Same x86_64 and glibc 2.35 requirements as above.

All releases Build from source instead

What you can do

Build and test

  • Send REST and GraphQL requests

    Every method, and JSON, XML, JSON-RPC, form-data, URL-encoded, raw, or GraphQL bodies. Collections nest, with their own variables, auth, and scripts.

  • Bring what you already have

    Drop in a Postman or Insomnia (v4 or v5) export, a JMeter test plan, or an OpenAPI or Swagger spec and keep your folders, variables, auth and scripts. What carries over.

  • Keep your Postman tests

    A QuickJS runtime implements pm.test(), pm.expect(), pm.environment.set() and pm.response.*, so most scripts run unmodified (not cheerio, Backbone or Node built-ins).

  • Auth that inherits

    Bearer, Basic, API key, and OAuth 2.0 (client credentials, password, authorization code + PKCE) - resolved engine-side, inherited down the tree.

  • Watch a stream as it arrives

    text/event-stream is a first-class request type: events land in a live Events view, you can stop the stream, scripts assert on it afterwards, and the list comes back when you reopen the run.

  • Find anything, by what is inside it

    One shortcut opens a command palette over every collection, request, environment and setting - searching their contents, not just their names.

Under load, and beyond

  • Load test without a second tool

    A multi-worker C++ event loop drives the load and streams throughput, latency percentiles, and error counts live. See the benchmarks against wrk and vegeta.

  • Drive a run from a data file

    Point a collection at a CSV, TSV, JSON or JSONL file and each iteration gets its own row, as {{data.column}} tokens and pm.iterationData. Data-driven runs.

  • Mock what is not built yet

    Serve a collection's saved examples as a live mock, with a mock OAuth issuer for auth flows and a webhook inbox that captures what a third party sends you.

  • Hand it to your coding agent

    A built-in MCP server exposes the engine to Claude Code, Cursor, VS Code and Codex (Zed via the stdio CLI) - behind a host allowlist and load caps you set. Drive Vayu from your agent.

  • Private by default

    100% offline execution. No telemetry, no account, no cloud sync - your requests and secrets never leave the machine.

Bring your existing collections

Switching tools is only cheap if your work comes with you. Drop in an export - the format is detected for you, no "which importer?" dialog - and Vayu rebuilds the tree, variables, auth and scripts.

v2.1 and v2.0 exports. The folder tree, collection and folder variables, auth (Bearer, Basic, API key, OAuth 2.0), pre-request and test scripts, query parameters including disabled ones and their descriptions, and raw, JSON, URL-encoded, form-data and GraphQL bodies.

Environments come across too. Postman exports those as separate files - drop one in and it imports as a Vayu environment, keys, values, enabled state and secret flag intact. A globals export imports the same way, merging into Vayu's globals scope rather than creating an environment; variables you already had are kept, and a name that clashes is overwritten.

Three things come across but will not behave as they did. A file body (or a form-data file) keeps the path the export named, marked to relink: choose the file again in the request before it will send. A custom HTTP verb such as PROPFIND imports as GET and is counted. And Digest, AWS, NTLM, Hawk, OAuth 1.0, EdgeGrid and JWT auth are kept as data and not executed. The import preview counts each of them rather than dropping them silently.

Insomnia v4 and v5 exports. Vayu rebuilds the workspace, folder and request tree from Insomnia's flat resource list, and workspace environments do come across.

{{var}} templates are converted to Vayu's own. Nunjucks tags ({% ... %}) and filtered expressions ({{ x | filter }}) are left verbatim as text, since Vayu has no equivalent - they stay visible instead of silently breaking.

.jmx test plans. An HTTP sampler becomes a request, with its URL, headers, parameters and body. Loop, if, once-only, transaction and throughput controllers become folders carrying the matching control element. Extractors (JSON, regex, boundary), assertions (response, duration, size, JSONPath) and timers (constant, random, Gaussian, throughput) become elements on the request, and User Defined Variables become collection variables.

JSR223 and BeanShell scripts import disabled, since Groovy and BeanShell are not JavaScript. A class with no equivalent (a listener, CSV Data Set, the cookie manager) is counted in the import preview by name rather than dropped silently. Thread and loop counts are not imported: you set the load profile when you start a load run. JMeter import in detail.

OpenAPI 3.1/3.0 and Swagger 2.0, JSON or YAML. A spec describes endpoints rather than recording requests, so Vayu generates stubs: one collection per tag, a {{baseUrl}} variable from the server definition, parameters with empty values, and a request body sampled from the schema. Auth schemes map across: an OAuth 2.0 scheme is seeded with {{clientId}} and {{clientSecret}} for you to fill in, while bearer, basic and API-key schemes arrive with their credentials empty.

How import works, format by format

How it fits together

Vayu is a sidecar: the Electron + React UI talks to a C++23 daemon over HTTP on 127.0.0.1:9876. That split is why the interface stays responsive while the engine saturates a target - and why the engine can be driven on its own, from the command line or by a coding agent over MCP.

How it works in full

Drive Vayu from your coding agent

MCP (Model Context Protocol) is the open standard that lets coding agents such as Claude Code or Cursor call tools; Vayu exposes its engine as one, so an agent can send the request it just wrote, load test it and read the report without leaving your editor.

Vayu ships an MCP server, so an agent can use the same engine the UI does - send a request, start a load run, read the report, compare two runs. It runs inside the app on 127.0.0.1:9877, proxying the engine's REST API; there is no second process to manage, and nothing leaves the machine.

claude mcp add --transport http vayu http://127.0.0.1:9877/mcp

Or click Connect in Settings → MCP, which shells out to the CLI for you.

// .cursor/mcp.json
{
  "mcpServers": {
    "vayu": { "type": "http", "url": "http://127.0.0.1:9877/mcp" }
  }
}
// .vscode/mcp.json - note the "servers" key, not "mcpServers"
{
  "servers": { "vayu": { "type": "http", "url": "http://127.0.0.1:9877/mcp" } }
}
# ~/.codex/config.toml
[mcp_servers.vayu]
url = "http://127.0.0.1:9877/mcp"

80 tools, 9 resources, 4 prompts. Inspection (list_collections, get_run_report, compare_runs), execution (run_request, run_collection_smoke), load (start_load_run, stop_run), and writes (full CRUD over collections, saved requests and environments, plus globals and the cookie jar) - each with a typed schema, so the agent gets validation rather than guesswork. The agent can see what you have open (get_app_focus), and every request, run, variable or GraphQL operation has a Copy for agent button that puts a reference on the clipboard - so "load test this" means the thing on your screen.

Zed speaks stdio only, so it connects through the stdio CLI rather than a URL; the MCP reference has the details.

An agent pointed at your engine is a real capability, so it is gated. Tools that touch the network refuse any host outside an allowlist that starts empty (deny all). Load runs are additionally capped on RPS, concurrency and duration, and require confirmation. The tools that mutate saved data sit behind a write toggle that is off by default. All of it lives in Settings → MCP and persists.

MCP reference

Reference

Engine - the C++23 daemon: execution, load generation, persistence, scripting.

Document Covers
Overview Core structure, engine-side auth resolution
HTTP API Every endpoint, payload shape, and status code
Test Scripting The QuickJS sandbox, script globals, hooks, limits
Local Database SQLite tables and the JSON shapes stored in them
Command Line Flags and subcommands for running the engine standalone
MCP Server The tool surface exposed to coding agents
Benchmarks RPS head-to-head against wrk and vegeta, with methodology

Desktop app - the Electron + React renderer.

Document Covers
Overview Renderer-side structural decisions
UI Components The modules/ + components/ layout
Design System Tokens, elevation, typography, component patterns
State Management Zustand stores, TanStack Query keys, cache policy
Talking to the Engine What the renderer sends the engine, and when
Variables How {{variables}} resolve, and scope precedence
Postman Script Support Which pm.* APIs the runtime supports
File Naming Naming rules across the renderer
Importing Collections The import pipeline, plus per-format mapping

Design notes - rationale that is easy to misread from the code alone: Request Storage, Lock Files.

Questions people ask

Is Vayu free?

Yes - fully free and open source, with no paid tier, no subscription, and no feature gating. The engine is AGPL-3.0 and the app is Apache-2.0.

How is it different from Postman, Bruno, or Insomnia?

Those are good API clients, but none of them load test - for that you reach for k6 or JMeter as a second tool. Vayu does both in one app: build the request, then load test that same endpoint with a native C++ engine. Side by side, with what each one does better: vs Postman, vs Bruno, vs k6, vs JMeter.

Does Vayu support SSE / streaming endpoints?

Yes - server-sent events are a first-class request type. Turn on Event stream and text/event-stream responses arrive in a live Events tab as they stream, with a Stop control, scripts that assert on the buffered events once it closes, and the event list restored when you reopen the run from history. Streams stay bounded under load rather than buffering without limit.

Can I import my Postman collections?

Yes - v2.0 and v2.1 exports, including folders, collection variables, auth, and pre/post-request scripts. Postman environments are a separate export; import that file too and it becomes a Vayu environment, and a globals export merges into Vayu's globals scope. Insomnia v4 and v5, JMeter .jmx test plans, OpenAPI 3.1/3.0 and Swagger 2.0 import too; see what carries over.

Will my Postman test scripts still run?

Most run unmodified. A QuickJS runtime implements the pm.* API - pm.test(), pm.expect(), pm.environment.get/set(), pm.response.* - as do the older tests["..."] / postman.* style and the bundled require() libraries; cheerio, Backbone and Node built-ins are not there. Postman Script Support lists exactly what is covered.

Can my coding agent use it?

Yes - Vayu hosts an MCP server on 127.0.0.1:9877 and one command registers it with Claude Code, Cursor, VS Code or Codex (Zed connects through the stdio CLI). The agent gets 80 tools across inspection, execution, load runs and writes, behind a host allowlist, load caps, and a write toggle that ships off - and while it is off the write tools are not listed at all. It can see what you have open (get_app_focus), and every request, run, variable or GraphQL operation has a Copy for agent button, so "load test this" means the thing on your screen. See the MCP reference.

Does it work offline, and does it need an account?

Offline, and no account. All execution is local; Vayu contacts no external server during normal use - no telemetry, no license check, no cloud sync.

How fast is the load testing, really?

On a laptop against a loopback target, the engine matches wrk (56,880 vs 54,280 req/s measured in the same session) and edges past vegeta, with all three converging on the same ~57k system throughput ceiling. Driven from the app's own UI, a 60-second run sustained 51,922 req/s and 3.1 M requests with zero errors. Full method, concurrency sweep, and a one-command reproduction are in the benchmarks.

Which platforms are supported?

Windows (x64), macOS 13.3 (Ventura) or later (Apple Silicon and Intel, universal), and Linux (x86_64 AppImage or .deb, glibc 2.35 or later: Ubuntu 22.04, Debian 12 or newer).

Contribute

Bug reports, feature ideas, docs, and code are all welcome. The Contributing Guide covers dev setup, code style, testing, and the release process; Build from Source gets the engine and app compiling locally.

Find Vayu useful? Recommend it on AlternativeTo, where people compare API clients:

Vayu API Client | AlternativeTo

Licensing

The engine is AGPL-3.0 and the app is Apache-2.0. See LICENSE for both texts, and the Security Policy for the threat model and how to report an issue.