FoxAPIs Desktop. Connect once, use everywhere.

Why a desktop relay?

Web-based MCP works, but every client needs its own auth dance. Pasting bearer tokens into Claude Desktop, then again into Cursor, then again into n8n. Rotating the key? Now do that three times. Wonder which client just burned credits on a bad call? Check three different log surfaces. FoxAPIs Desktop fixes all of that with one local hop.

One URL, then any client

The desktop app spawns a tiny HTTP server on 127.0.0.1:8732 as soon as it launches. Point any MCP-aware client at it. The relay forwards every request to FoxAPIs in the cloud with your bearer key attached. Latency is whatever your network is, plus a microsecond of localhost hop. Drop the same three lines below into any client config and you are done.

# Claude Desktop — claude_desktop_config.json
{
  "mcpServers": {
    "foxapis": {
      "url": "http://127.0.0.1:8732/mcp"
    }
  }
}

# Cursor — ~/.cursor/mcp.json
{
  "mcpServers": {
    "foxapis": { "url": "http://127.0.0.1:8732/mcp" }
  }
}

# Continue — ~/.continue/config.json
{
  "experimental": {
    "modelContextProtocolServers": [
      { "name": "foxapis",
        "transport": { "type": "http",
                       "url": "http://127.0.0.1:8732/mcp" } }
    ]
  }
}

Or just hit Install in the Connector Hub tab inside the app. The desktop app does the file edit for you, with a confirmation dialog before saving. If a config already exists, the merge is non-destructive — your other servers stay where they are.

Works with eight clients out of the box

Anything that speaks the Model Context Protocol works with the local relay. The eight below have first-class support in v0.1 — three with one-click writers, the rest with copy-paste snippets generated for your platform. New clients keep landing as the protocol spreads, and the catalog inside the app updates automatically.

For the full integration matrix with status badges and walkthroughs, see the FoxAPIs Integrations Hub. Every client there can point at the local desktop URL or the hosted endpoint — same tools, same responses, your choice of hop.

Every tool, one connector

The FoxAPIs MCP server exposes a vetted set of research, scanning, visibility, and pipeline tools. The desktop app surfaces every one of them in the Tools tab with full descriptions, schemas, and a live "Try it" sandbox. Whatever the catalog grows to, the app pulls the live tool list on launch — anything new shows up in your local catalog within minutes of shipping.

Where your data goes

Every MCP call you make is forwarded directly to the FoxAPIs cloud endpoint with your bearer key attached, and the response is sent straight back to your local client. The desktop app does not phone home, does not log to any third party, and does not touch any other network. Your bearer key is stored in your operating system's keychain — macOS Keychain, Windows Credential Vault, gnome-keyring or libsecret on Linux. The app never writes your key to disk in plain text.

Activity-log events live in memory and are cleared when you quit. Cached responses live in your app cache directory and stay there until you delete them, with a one-click "purge cache" in Settings. The whole codebase is open source: read it, audit it, fork it. github.com/OsakaSaul/foxapis-desktop.

Who this is for

If you are a solo developer wiring up Claude Desktop, Cursor, and a side n8n flow against the same data layer, the desktop app saves you three rounds of token-pasting and gives you one log to grep when something goes sideways. If you are an agency running multiple clients through workflow tools, the desktop relay is the cleanest way to keep keys out of vendor configs and rotate them on demand. If you are an indie hacker building agentic workflows, this is the missing piece between "I have an API key" and "I have ten clients calling the same key with one log to look at." Most people who install the app are using at least three MCP-aware clients before the week is out, and the activity log becomes the surface they keep open while building.

The relay is free. You bring your own FoxAPIs key — see pricing for the tiers, or grab a trial key with no card on file from /trial/. The cloud endpoint is also documented at /docs/ if you would rather skip the desktop app entirely and call the hosted endpoint directly. Both paths hit the same tools and return the same shape of response, so the choice is really about whether you want a single local log surface and a key vault, or whether you would rather keep things plain and call the hosted URL from each client config separately.

There is no lock-in. Uninstall the app and your existing client configs keep working — they just point back at the hosted endpoint instead of the local hop. The configs the app writes are plain text files, edited in place with a backup written next to them on first save. Nothing the desktop app touches is proprietary. Read the source, copy the relay logic into your own tooling, fork the repo and ship a different UI on top of the same protocol. The only thing the desktop binary does that you cannot trivially do yourself is the auth-merge dance across config formats, plus the activity log overlay across clients.

Common questions

Roadmap

v0.1 ships the architecture. v0.2 and beyond fill it in. Issues and pull requests welcome on the GitHub repo — this is a tool built in the open, with a public changelog and a public issue tracker.