Relay

A keyboard-first API client where everything you build is a plain file on disk.

Relay keeps requests, routines, and environments as readable YAML in a folder you own. No account, no cloud, no database to export from. Open the workspace in your editor, review it in a pull request, sync it however you sync files, or hand it to an agent.

<picture> <source media="(prefers-color-scheme: dark)" srcset="apps/desktop/promo/relay-request-editor.png"> <img src="apps/desktop/promo/relay-request-editor-light.png" alt="The Relay request editor: a GET request with query params above a JSON response"> </picture>

What's inside

Requests. Params, headers, body, and auth (basic, bearer, API key, OAuth 2.0) in one editor, with a cookie jar and an auto-saved history of every send. Paste a curl command to create a request; copy any request back out as curl. GraphQL bodies get a schema-aware editor fed by live introspection.

Routines. Chain requests into a flow on an auto-layout canvas. Extract values from responses, branch on conditions, assert on results, wait, or pause for a human pick or entry. Run the whole flow, run to a step, or re-run a single step against cached data, and refactor with find and replace across the routine.

The {{reference}} grammar. One syntax reuses any value: vault keys, step outputs, extracted variables, and routine inputs, all resolved at send time. Cmd-click a reference anywhere to peek at what it resolves to.

Environments and secrets. A vault holds one column of values per environment. Mark a value as secret and it moves to the OS keychain; secrets resolve inside the Rust core at send time and never reach the interface, reports, or exports.

Webhook listener. Point any service at a generated URL and inspect what arrives, headers and body, without opening a port. Save a capture as a request to replay it.

MCP, both ways. Connect Relay to MCP servers, or serve your workspace over MCP so agents can browse, send, and create requests with your vaults in place. Every workspace also carries generated llms.txt and CLAUDE.md guides, so agents understand the file formats without being told.

Import and export. Import Postman collections, OpenAPI 3 documents, Bruno collections, and curl. Export Postman collections, a vault as .env, or any request or routine as a typed TypeScript or JavaScript client.

Undo for everything. File mutations are journaled with byte-exact snapshots, undo works app-wide, and deletes go through the OS trash.

Network control. Per-workspace proxy, mTLS client certificates, extra CA certificates, and custom DNS, kept machine-local and out of the shareable files.

And throughout: a command palette that teaches every shortcut, in-app guides on each feature's first open, an interface in English, French, or German, and on-device AI naming on Apple Silicon that never sends a byte anywhere.

The workspace is files

# ~/Relay/requests/Create issue.relay.yaml
schemaVersion: 1
id: 8f3c2b10-6a44-4e2f-9c1a-2d7e5b0f1a23
name: Create issue
request:
  method: POST
  url: https://api.github.com/repos/{{owner}}/{{repo}}/issues
  headers:
    - name: Authorization
      value: Bearer {{githubToken}}
      enabled: true
  body:
    type: json
    value:
      text: |-
        { "title": "Found a bug" }

File names follow the names you see in the app. Relay watches for edits made outside the app and reloads them, so the files stay the source of truth: version them, diff them, or generate them.

Install

Download the latest build from the releases page. On first launch Relay creates a workspace at ~/Relay with a few starter files. macOS may ask you to confirm the first open, since the app comes from outside the App Store.

Documentation

The full manual lives in apps/docs and is published as the documentation site: getting started, core concepts, and a page per feature, plus reference material for the {{reference}} grammar, the on-disk file formats, keyboard shortcuts, and the MCP tools.

Development

apps/desktop    the app: React frontend (src/) and Rust core (src-tauri/)
apps/docs       the documentation site (Astro + MDX)
docs/           architecture and design notes

Prerequisites: Node 20+, pnpm, Rust stable, and the Tauri prerequisites for your platform.

pnpm install
cd apps/desktop && pnpm tauri dev    # builds the Rust core and opens the app

Before sending a change:

pnpm typecheck && pnpm lint && pnpm test     # tsc + astro check, biome, vitest
cd apps/desktop/src-tauri
cargo clippy --all-targets -- -D warnings
cargo test                                   # also regenerates the IPC bindings

Start with docs/ARCHITECTURE.md for how the pieces fit and docs/CONTRIBUTING.md for the workflow. The project's cross-cutting conventions live in CLAUDE.md; they apply to human and AI contributors alike.

Stack

Layer	Tech
Runtime	Tauri 2, a Rust core behind the OS webview
Frontend	React 19, TypeScript, Tailwind CSS 4, Vite
HTTP engine	Rust reqwest with full wire timings
Storage	Plain YAML files, SQLite for response history
IPC	Generated end-to-end types via tauri-specta

License

MIT