ApiArk — Local-First API Client That Ditches the Cloud

TL;DR

TL;DR: ApiArk is an open-source, local-first API client that replaces Postman with ~60 MB RAM, sub-2s startup, and git-friendly YAML storage — no account, no cloud, no bloat.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: apiark.dev ← visited and verified
• Source repository: github.com/berbicanes/apiark ← README read in full
• License: MIT ← verified via GitHub API (spdx_id: MIT)
• Latest release: v0.4.6 ← verified 2026-03-26
• HN launch thread: not available for this tool

What Is ApiArk?

ApiArk is an open-source API development platform that runs entirely on your machine — no login, no cloud sync, no telemetry. It supports REST, GraphQL, gRPC, WebSocket, Server-Sent Events (SSE), MQTT, and Socket.IO in a single app.

The project is built with Tauri v2 (Rust + native OS webview), which is why it stays so lightweight compared to Electron-based alternatives.

“Postman uses 800 MB of RAM. ApiArk uses 60 MB.”

That tagline is front and center on the project README. The performance difference is a direct result of the Tauri architecture.

Setup Workflow

Download and Install

Head to the latest release and pick your platform:

| Platform | Download | |---|---| | macOS (Apple Silicon / Intel) | .dmg installer | | Windows | .exe installer or .msi | | Linux | .AppImage, .deb, or .rpm |

You can also install via package managers:

# macOS (Homebrew)
brew tap berbicanes/apiark
brew install --cask apiark

# Windows (Scoop)
scoop bucket add apiark https://github.com/berbicanes/apiark
scoop install apiark

# Linux (APT)
curl -fsSL https://berbicanes.github.io/apiark-apt/install.sh | sudo bash
sudo apt install apiark

Import Your Existing Data

Already use Postman? Switching takes under a minute:

1. Export your Postman collection (Collection v2.1 JSON)
2. Open ApiArk
3. Press Ctrl+K → type “Import Collection” → select your file
4. Your requests are now YAML files you own

ApiArk also imports from Insomnia, Bruno, Hoppscotch, OpenAPI 3.x, HAR, and cURL.

Core Concepts

Requests are YAML files. Collections are directories. This means every API call you make is a plain text file that you can version control, diff, and review in pull requests.

# users/create-user.yaml
name: Create User
method: POST
url: "{{baseUrl}}/api/users"
headers:
  Content-Type: application/json
body:
  type: json
  content: |
    {
      "name": "{{userName}}",
      "email": "{{userEmail}}"
    }
assert:
  status: 201
  body.id: { type: string }
  responseTime: { lt: 2000 }

Run a Collection from CLI

apiark run ./my-collection --env production

Supports data-driven testing with CSV/JSON files, configurable iterations, and JUnit/HTML report output.

Deeper Analysis

What Sets It Apart

Git-friendly data storage is the core differentiator. Postman locks your data into their cloud or a proprietary format. Bruno uses .bru files which are git-compatible but not standard. ApiArk uses plain YAML — your collection files are readable, diffable, and work in any text editor or code review tool.

Multi-protocol support covers more than any competitor:

• REST (obviously)
• GraphQL
• gRPC
• WebSocket
• Server-Sent Events (SSE)
• MQTT
• Socket.IO

No other API client supports this many protocols natively.

Local mock servers let you create mock APIs from your collections with Faker.js data, latency simulation, and error injection — all offline, no usage limits.

Plugin system supports both JavaScript and WASM extensions, so the community can extend functionality without forking the core.

Performance

From the README:

| Metric | Target | |---|---| | Binary size | ~20 MB | | RAM at idle | ~60 MB | | Cold startup | under 2 seconds | | Request send overhead | under 10 ms |

For comparison, Postman typically consumes 300–800 MB of RAM, Bruno 150–300 MB, and Hoppscotch (Electron-based) 50–80 MB.

Comparison vs. Alternatives

| | Postman | Bruno | Hoppscotch | ApiArk | |---|---|---|---|---| | Framework | Electron | Electron | Electron | Tauri v2 | | RAM Usage | 300–800 MB | 150–300 MB | 50–80 MB | ~60 MB | | Startup | 10–30s | 3–8s | under 2s | under 2s | | Account Required | Yes | No | Optional | No | | Data Storage | Cloud | Filesystem | IndexedDB | Filesystem YAML | | Git-Friendly | No | Yes (.bru) | No | Yes (YAML) | | gRPC | Yes | Yes | No | Yes | | WebSocket | Yes | No | Yes | Yes | | SSE | Yes | No | Yes | Yes | | MQTT | No | No | No | Yes | | Mock Servers | Cloud only | No | No | Local | | Monitors | Cloud only | No | No | Local | | Plugin System | No | No | No | JS + WASM | | Proxy Capture | No | No | No | Yes | | Response Diff | No | No | No | Yes |

Practical Evaluation Checklist

• [x] MIT licensed open-source project
• [x] Cross-platform (macOS, Windows, Linux)
• [x] Supports REST, GraphQL, gRPC, WebSocket, SSE, MQTT
• [x] Local-first — no account required
• [x] Git-friendly YAML storage (not proprietary format)
• [x] Sub-2s cold start, ~60 MB RAM
• [x] CLI for CI/CD integration
• [x] Local mock servers (no cloud needed)
• [x] Collection runner with test scripting (TypeScript)
• [x] Import from Postman, Insomnia, Bruno, OpenAPI, HAR, cURL
• [x] Active development (v0.4.6 as of 2026-03-26)

Security Notes

ApiArk stores everything locally. There is no mandatory cloud sync, no telemetry, and no account to be breached. Your API keys live in local YAML files you control. For CI/CD use, the CLI supports environment variables and secret injection through your shell — no plugin needed.

If you use the proxy capture feature, traffic is intercepted locally and never leaves your machine unless you explicitly replay it.

FAQ

Q: Does it have AI features? A: Yes. ApiArk includes an AI assistant that converts natural language to API requests, auto-generates tests, and exposes an OpenAI-compatible API for custom integrations.

Q: Can I use it offline? A: Fully offline. No network is required after installation.

Q: How does it handle environments and secrets? A: Environments use variable substitution ({{baseUrl}}, etc.) and are plain YAML files. You manage them yourself — no cloud sync, no team sharing unless you commit them to git.

Q: Does it support team collaboration? A: Not in a hosted sense. But because collections are YAML files, you can collaborate via git — standard workflow, standard code review.

Q: How does it compare to Bruno? A: Bruno is also git-friendly, but uses .bru format (Bruno-specific). ApiArk uses standard YAML which any tool can read. Bruno is Electron, ApiArk is Tauri (smaller, faster). Bruno has no local mock servers or gRPC support; ApiArk has both.

Conclusion

ApiArk is a genuinely refreshing take on API development tools — it respects your time, your hardware, and your data. The performance numbers are not marketing: Tauri v2 makes a measurable difference in RAM and startup time.

If you’ve been putting up with Postman’s cloud dependency, slow launches, and memory bloat, ApiArk is the open-source alternative that treats you like a developer, not a subscription renewal.

Head to apiark.dev to download it — no account required.