voiden

Why Voiden

Voiden is an offline API client that helps developers, QA and technical writers build, test, collaborate and document APIs in one place. With a programmable interface (/slash commands) and an agent-friendly CLI, Voiden adapts to how engineers already work. Voiden is built with Electron, Typescript and Javascript, and it doesnt require an account to use it.

No telemetry, no VC funding, and no cloud lock-in.

✨ Features:

Voiden supports all major API protocols:

• Supports REST, GraphQL, Grpc, Web-Sockets. All these are plugins that you can install or uninstall according to your needs. Community plugins available: https://voiden.md/plugins
• Import collections from Postman, Insomnia and Swagger/ OpenAPI.

Single Source of truth for all API work in the same file:

• Keep API requests, tests, notes and docs together in the same executable.void files. Keep everything in one format and one workflow.
• Requests can be composed by API building blocks (endpoint, auth, params, body). Decompose requests into blocks. Reuse the same blocks across files, like functions.
• Work in Markdown and structured blocks instead of opaque collections locked inside an app.
• Test and document APIs without leaving the editor.

Workflows:

• Scripting: Execute JavaScript, Python, or Shell scripts before sending requests and after receiving responses.
• Stitch runner: Batch-execute multiple .void files sequentially. Supports glob patterns, stop-on-failure, variable isolation, configurable delays, and environment selection.

Collaboration:

• Collaborate with Git branches and pull requests instead of proprietary team workspaces.
• Stay local-first with no signup and no required cloud sync.

AI Friendly:

• No proprietary workspace. No binary exports. Pure text all the way down, diffable like code, greppable, AI-editable, and merge-friendly.
• Supports Voiden skills for Claude and Codex agents.
• MCP support — connect Claude Code or Codex directly to a project so they can run your .void requests themselves, or serve your own requests as tools other agents can call. See the MCP docs.

Voiden Runner: A headless CLI for running those .void files outside the desktop app, directly in the terminal.

• runs on Node.js 18+
• works in terminal, CI/CD, Docker, and cron jobs
• supports REST, WebSocket, gRPC, and GraphQL
• supports request chaining through runtime variables
• works with core Voiden plugins like scripting, assertions, faker, advanced auth, + more.

Install

Current version: 2.3.3 (stable)

Download installers for macOS, Windows, and Linux from voiden.md/download. Direct downloads are available for Apple Silicon and Intel macOS, Windows .exe, and Linux .deb, .rpm, and .AppImage builds.

Windows note (starting v2.1.1): the Windows installer is now signed via Azure Trusted Signing instead of our previous certificate provider. Because of this change, you may see a "Windows protected your PC" SmartScreen dialog during install — the installer is signed and verified, this is expected while the app builds up download reputation with Microsoft. Click "More info" → "Run anyway" to proceed.

Package managers

Platform	Stable	Early access
macOS	Homebrew, Nix	Homebrew (voiden@beta), Nix
Windows	winget, Chocolatey	winget (Voiden.Voiden-Beta)
Linux	Flatpak, Homebrew, apt, snap, Nix	Beta apt and snap channels, Nix

macOS

Homebrew

brew install voiden

# beta
brew install voiden@beta

Windows

winget

winget install Voiden

Chocolatey

choco install voiden

# beta (winget)
winget install Voiden.Voiden-Beta

Linux

Flatpak (any distro)

flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
flatpak install flatpark md.voiden.Voiden

Homebrew on Linux

brew tap voidenhq/voiden
brew trust voidenhq/voiden
brew install voidenhq/voiden/voiden

APT (Ubuntu / Debian)

curl -fsSL https://voiden.md/apt/stable/voiden.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/voiden.gpg
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/voiden.gpg] https://voiden.md/apt/stable stable main" | sudo tee /etc/apt/sources.list.d/voiden.list
sudo apt update && sudo apt install voiden

# beta
curl -fsSL https://voiden.md/apt/beta/voiden.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/voiden-beta.gpg
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/voiden-beta.gpg] https://voiden.md/apt/beta beta main" | sudo tee /etc/apt/sources.list.d/voiden-beta.list
sudo apt update && sudo apt install voiden

Snap

sudo snap install voiden
# beta
sudo snap install voiden --channel=beta

Nix (Linux / macOS)

One-time setup — trust the voiden Cachix binary cache so Nix fetches a prebuilt result instead of compiling Electron and native modules from source (the default multi-user Nix install won't honor a flake's own substituter config without this):

nix run nixpkgs#cachix -- use voiden

Then run Voiden directly using Nix Flakes:

nix run github:VoidenHQ/voiden

If you skip the cachix use step, nix run still works — Nix just falls back to building from source, which is slower.

Looking for newer builds? Check the early access section on voiden.md/download.

Get started with Voiden

1. Install Voiden and open it. No signup or login is required.
2. Create a .void file in any folder and add your request, docs, and reusable blocks.
3. Run the request with Cmd+Enter or Ctrl+Enter, then commit the file to Git.

For a guided first run, see the Voiden quick start.

Coming from Postman and other tools?

If you already use Postman, you can bring your existing collections with you:

1. In Postman, export your collection as JSON (v2.1 is recommended).
2. Drag the exported JSON file into the Voiden file list on the left panel.
3. Open the imported file and click Generate Voiden Files to create a folder of native .void files — one per request, with headers, auth, query params, path variables, bodies, and response examples preserved.

Full walkthrough: Postman Imports.

Using Swagger or Insomnia?

OpenAPI Imports. Insomnia Imports

What you can do

• Build REST and HTTP requests with headers, query params, JSON/XML/YAML/form bodies, file uploads, and cURL import/export.
• Work with GraphQL using schema import, a visual query builder, variables, and subscriptions.
• Use WebSocket and gRPC workflows in the same workspace.
• Add pre-request and post-response scripts in JavaScript, Python, or shell.
• Run assertions and stitch multiple .void files into batch runs with aggregated results.
• Import OpenAPI specs and Postman collections into native Voiden files.
• Keep Git, terminal, docs, and API testing close together inside the desktop app.

What a .void file looks like

Voiden files combine frontmatter, Markdown, and structured void request blocks so the request and the documentation live together.

Document frontmatter:

---
version: 1.4.6
generatedBy: Voiden app
generatedAt: 2026-04-16T10:24:00.000Z
---

Markdown body:

# Hello, World

A simple GET request you can run with Cmd/Ctrl+Enter.

A void request block:

---
type: request
content:
  - type: method
    content: GET
  - type: url
    content: https://echo.apyhub.com
---

Voiden generates the document metadata and block IDs for you inside the app.

Documentation

User docs

• Getting started
• Download
• Changelog

Contributor docs

Topic	Description
Fresh install	Repository setup and local development
Architecture overview	Core app, extension system, and request flow
Extension guide	Build your own extension
Themes	Create custom themes
Troubleshooting	Common issues and fixes

See the documentation index for the full list.

Build from Source

For platform-specific prerequisites and troubleshooting, start with Fresh Install.

git clone https://github.com/VoidenHQ/voiden.git
cd voiden
corepack enable
yarn set version 4.3.1
yarn install
yarn workspace @voiden/core-extensions build
cd apps/electron && yarn start

Build with Nix

If you have Nix installed, you can manage the development environment or build Voiden natively:

# 1. Enter the reproducible development shell (sets up Node, Corepack/Yarn, Git)
nix develop

# 2. Build the Nix package (compiles source and creates sandboxed wrapper)
nix build

# 3. Run the compiled executable binary
./result/bin/voiden

If you hit Windows build issues, see Build Errors.

Project Structure

voiden/
├── apps/
│   ├── electron/          # Electron main process
│   └── ui/                # React renderer
├── core-extensions/       # Built-in extensions
└── docs/                  # Documentation

Why Electron?

Voiden is built on Electron. We are building something closer to an IDE for APIs than a lightweight request sender, so we wanted a mature, cross-platform foundation that ships consistently on macOS, Windows, and Linux, gives us deep system access for things like Git and the terminal, and lets us keep a rich, custom editor experience.

We also know Electron gets a bad reputation, often inherited from other API tools. Our take is that footprint matters, but stability, reliability, and cross-platform predictability matter more when users feel them every day. We would rather be transparent about resource usage and keep optimizing it than chase a lighter stack that breaks in subtle ways.

Read some more of our thoughts here: Why Voiden is Built on Electron (and not Tauri)?.

Community

• Report bugs and request features in GitHub Issues.
• Join the Voiden Discord for updates and office hours.
• Track upcoming work in GitHub Milestones.

Contributing

We welcome contributions. Start with:

• Contributing Guide
• Code of Conduct
• Security Policy

Useful Resources

• Community & Feedback
• Documentation
• Voiden vs Postman
• Voiden Plugins
• Blog and articles
• Privacy Policy

License

This project is licensed under the Apache License 2.0.