Git-native API client

API requests that
live in git.

Senda is a fast, lightweight API client where every collection is a plain folder of YAML. No cloud account, no proprietary format — open a collection, send requests, and commit the diff.

MIT licensed Linux · macOS · Windows ~24 MB binary ~100 MB RAM Go + SolidJS
senda — desktop
Senda walkthrough: open a collection, send a request, inspect the response, run tests, switch theme
~24 MB
release binary
~100 MB
RAM at idle
100%
plain YAML on disk
13
built-in themes
3
frontends, one engine

Why Senda

Built for people who live in version control

Existing API clients hide your work in the cloud or a proprietary blob. Senda keeps it in files you already track.

Postman & Insomnia store collections in the cloud or proprietary formats.
Plain YAML files — git diff works on your requests.
Electron apps ship 150 MB binaries and use 400 MB of RAM.
Wails + native webview: ~24 MB binary, ~100 MB RAM.
Bruno is close, but .bru files need custom tooling to read.
Standard YAML, no custom DSL — readable by anything.
Sync conflicts turn shared team collections into a nightmare.
Collections are folders — merge conflicts resolve naturally.
Heavy UI frameworks cause jank on large responses.
SolidJS + virtualized CodeMirror 6 — 20 MB JSON stays smooth.
Secrets get committed by accident or scattered across tools.
*.secret.yaml is gitignored and merged only at send-time.

Features

Everything you need for everyday API work

A full request/response client — plus a test runner, mock server, load tester, and security scanner, all driven from the same files.

Git-native YAML

One folder per collection, one YAML file per request — switch between open collections from the workspace rail. Fully trackable: your requests live next to your code and git diff just works.

Full HTTP + GraphQL

GET through OPTIONS, query, headers, and body with per-row toggles. JSON, form, multipart, and GraphQL with one-click schema introspection.

Environments & secrets

{{var}} interpolation across URL, headers, and body — with {{$faker}} autocomplete and dev/prod/staging files. Secrets stay in gitignored overlays, merged only at send-time.

Assertions & schema

Per-request tests on status, timing, size, JSON path, headers, and regex — plus JSON Schema validation of the response body on every send.

Pre/post scripting

Shape a request before it goes out and extract tokens after it returns, in a sandboxed JS engine (Goja). Chain requests with senda.setVar / getVar.

Folder runner & load tests

Run a whole folder sequentially with live results, or switch to concurrent virtual-user load testing reporting p50/p95/p99 latency and status mix.

Mock server

Spin up a local HTTP server straight from YAML — response templating, named scenarios, stateful CRUD resources, proxy passthrough, CORS, and hot-reload.

Security scanning

Run an embedded pack of nuclei-compatible HTTP checks across every request under a folder. Filter by severity and tags; stream progress check-by-check.

WebSocket & SSE

Connect to ws:// / wss:// endpoints or Server-Sent Events and watch the live message log — variables and auth resolve just like HTTP.

Import & codegen

Import from curl, Postman v2, and OpenAPI 3. Export to curl, fetch, httpie, Python, and Go — or render the whole collection to Markdown / HTML docs.

Command palette & themes

Fuzzy-search requests and actions with Ctrl+K. 13 built-in themes — Catppuccin, Nord, VS Code, and more — with light/dark/system mode.

Desktop, TUI & CLI

The same send pipeline powers a native desktop app, a keyboard-driven terminal UI, and a headless CLI runner that drops straight into CI.

The format

git diff on your API requests just works

Collections are plain directories. Every request is one human-readable YAML file — no database, no binary blob, no lock-in.

my-api/
my-api/
├─ .senda/            # config & state
│  ├─ senda.meta.yaml
│  ├─ environments/
│  │  ├─ dev.yaml
│  │  └─ prod.secret.yaml  # gitignored
│  └─ mocks/
└─ users/
   ├─ list-users.yaml
   └─ create-user.yaml
users/create-user.yaml
name: Create user
method: POST
url: "{{baseUrl}}/users"
headers:
  - { key: Authorization, value: "Bearer {{token}}" }
body:
  type: json
  raw: '{ "name": "Ada Lovelace" }'
asserts:
  - { target: status, op: eq, value: "201" }
  - { target: body, op: contains, value: Ada }
postScript: |
  senda.setVar("userId", res.json.id);

One engine, three ways to run

Desktop, terminal, or CI

Scripts, variables, secrets, assertions, and the cookie jar behave identically across all three — pick whichever fits the moment.

Senda desktop app
Desktop

The full GUI

A native 3-pane shell built with Wails — tree, request editor, response viewer — with tabs, theming, and a command palette.

senda gui

Senda terminal UI
Terminal

senda

A keyboard-driven TUI on Bubble Tea — no webview, pure Go. It's what bare senda opens. Perfect over SSH, in tmux, or when you'd rather not leave the terminal.

senda ./my-api

Senda CLI runner
Headless

senda run

The same pipeline, scriptable in CI. Exits 0 when every request passes, 1 on any failure.

senda run -collection ./my-api -env dev

A closer look

Polished where it counts

Every panel earns its place — send and inspect, assert, mock, generate, and switch workspaces without leaving the keyboard.

Install

Up and running in one line

Prebuilt binaries for Linux, macOS, and Windows ship with every release — each bundles the desktop app and the headless CLI.

$ curl -fsSL https://raw.githubusercontent.com/this-senda/senda/main/scripts/install.sh | sh

Installs into ~/.local/bin and verifies the release SHA-256 before installing. On Linux the desktop window needs a WebKitGTK runtime — the installer prints the exact package if it's missing.

> irm https://raw.githubusercontent.com/this-senda/senda/main/scripts/install.ps1 | iex

Runs the PowerShell installer. WebView2 is bundled on Windows — no extra runtime needed.

$ brew install this-senda/tap/senda

Works on macOS and Linux via the Homebrew tap. On macOS, Homebrew re-applies quarantine to the unsigned binaries — add --no-quarantine to skip it (see the note below).

Coming soon. The winget and Chocolatey (choco install senda) packages aren't published to their repositories yet. For now, install on Windows with the PowerShell installer or grab the .exe from the releases page.

Unsigned builds

Senda isn't Apple/Microsoft code-signed yet, so the OS shows a one-time warning on first launch — the download is intact, it's only the missing signature.

macOS — Gatekeeper blocks the unsigned app; on Apple Silicon it usually says "Senda is damaged and can't be opened" (older Macs: "developer cannot be verified"). The "damaged" dialog can't be cleared by right-clicking → Open — remove the quarantine flag once. The shell installer does this for you; the .dmg and manual .tar.gz downloads need it run by hand, and it affects the terminal senda CLI/TUI too, not just the GUI:

xattr -dr com.apple.quarantine /Applications/Senda.app
xattr -dr com.apple.quarantine ./senda ./senda-desktop

Windows — SmartScreen may show "Windows protected your PC". Click More info → Run anyway.

How this was built

Honest disclosure: Senda is largely vibe-coded — most of the code, tests, and docs were written with heavy AI assistance, with a human steering the direction and deciding what shipped. It's young, lightly used, and maintained by one person, so treat it as experimental. The source is plain Go and YAML, so when in doubt, read the diff. Catch something off? Open an issue.

Send your first request

Open a folder of YAML, hit Ctrl+Enter, and commit the diff. That's the whole workflow.