Getting started

arpeesee has two parts: a Chrome extension that intercepts RPC calls in your browser and a desktop app that decodes them using your local .proto schemas.

1. Install the desktop app

Download the binary for your platform from the downloads page. On macOS you may need to right-click → Open on first launch (Gatekeeper).

2. Install the browser extension

The extension is available for Chrome and Chromium-based browsers (Edge, Arc, Brave). Install it from the download page.

3. Add a proto source

Open arpeesee, go to Sources, and add your proto files. See Proto sources for details.

4. Open your app and make some calls

With the extension installed and arpeesee running, open your app in the browser. Every Connect RPC and gRPC-web call will appear in the panel in real time.

Using the call list

Every intercepted call appears as a row showing its method name, transport protocol, gRPC status code, and how long it took. Click any row to open the decoded request and response payloads.

If arpeesee doesn't have a matching proto schema for a call, it still shows the raw binary. Add a proto source and the payload will decode automatically — no need to re-make the call.

DevTools panel

The extension adds an arpeesee panel to your browser's DevTools (open with F12 or ⌘⌥I, then switch to the arpeesee tab). The panel shows calls for the current tab as they happen. Click any call to read its payload inline.

The desktop app receives the same calls and decodes them against your proto schemas. Use the browser panel for a quick look and the desktop app for fully decoded payloads.

Copy history

Every time you copy a value from a call's request or response, arpeesee logs it in the copy history panel. Useful when you're iterating and need to refer back to something you copied earlier.

Filtering

Both the extension panel and the desktop app let you slice the call list in several ways. Filters stack — you can combine them freely.

Search bar

Type anything into the search bar to filter by method name or status code. The list updates as you type. Clear it to go back to the full list.

Method filter

The ▾ button opens a hierarchical method picker. It shows your calls organised by protobuf package, then service, then individual method. Check or uncheck at any level to include or exclude that whole branch. This is the fastest way to focus on one service when a busy page is making calls to many endpoints.

Desktop app filters

The desktop app adds extra dimensions beyond method name:

Tab — show calls from a specific browser tab only
Host — filter by the server hostname
Transport — separate gRPC-web calls from Connect RPC calls
Status — filter to a particular gRPC status code, e.g. show only errors

Proto sources

arpeesee needs your .proto files to decode calls. It supports three source types:

Local directory

The simplest option. Point arpeesee at a directory on your machine that contains .proto files. It scans recursively. Use the folder browser button to avoid typing paths.

If the directory contains a buf.yaml or buf.work.yaml, arpeesee uses buf build to compile the schema (requires buf in your PATH). Otherwise it uses protoc.

Git repository

Paste a git clone URL. arpeesee clones the repo to ~/.config/arpeesee/repos/ and builds from it. You can specify a branch or tag. Pull updates anytime from the sources panel.

GitHub (OAuth)

Connect your GitHub account via the Settings panel. Once connected, you can browse your repos and organisations and add them with a single click. arpeesee clones via HTTPS using your GitHub token.

MCP server

arpeesee exposes a Model Context Protocol server so AI coding agents (Claude, Cursor, etc.) can inspect your captured calls.

How it works

The MCP server runs as a separate binary (arpeesee-mcp) that communicates over stdio (the standard MCP transport). When an agent calls connect, arpeesee shows a native permission dialog. You approve or deny every connection.

Configure in Claude Desktop

{
  "mcpServers": {
    "arpeesee": {
      "command": "/path/to/arpeesee-mcp",
      "args": ["--url", "http://localhost:8787"]
    }
  }
}

Available tools

connect — request permission from the user and get a session token
summary — get a count and list of captured call methods
search — search calls by path, status, or latency (no payloads)
get_call — fetch a specific call including request and response bodies

Revoking sessions

Go to Settings → Connections → Agents to see active MCP sessions and revoke them at any time. Sessions are cleared when arpeesee restarts.

Configuration

Configuration is stored in ~/.config/arpeesee/ as JSON files. The UI manages them so you shouldn't need to touch these directly.

repos.json — list of proto sources
github.json — GitHub OAuth token (if connected)
app.json — preferences (editor, clone directory, build tool)

Server address

arpeesee listens on localhost:8787 by default. The Chrome extension is hardcoded to this address. If you need to change it, set the ARPEESEE_PORT environment variable when launching the app.

Editor

When you open a .proto file from arpeesee, it launches your preferred editor. Set this in Settings → Editor. Any editor that accepts a file path as an argument works — VS Code, Zed, Neovim, etc.

Extension internals

The extension has three parts:

inject.js — runs in the MAIN world and patches XMLHttpRequest and fetch to capture RPC calls
content.js — runs in the ISOLATED world and relays messages from inject.js to the service worker
background.js — the service worker that forwards calls to arpeesee's /decode endpoint and manages the side panel port

The extension only intercepts requests where Content-Type matches a gRPC-web or Connect RPC variant. Regular JSON and form requests are left alone.

Documentation