# OpenRelay: A Local Proxy That Reuses the AI Quota You Already Pay For

> OpenRelay is a TypeScript local proxy that reads credentials from AI desktop apps and CLI tools already on your machine, then re-exposes them through one HTTP endpoint on port 18765. It is useful, it is also the kind of tool that can get an account banned, and the README says almost nothing about that.

**romgX/openrelay** — 几百个免费 AI 模型配额，一键接入本地项目。| Hundreds of free AI model quotas, one-click access to local projects. 

- Repository: https://github.com/romgX/openrelay
- Stars: 2,306 · Forks: 322
- Language: TypeScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/romgx-openrelay

## The silo problem OpenRelay is aimed at

AI subscriptions arrive attached to a client, not to a protocol. The README states the situation plainly: Claude Pro only works in Claude Desktop, Kiro quota only works in Kiro, and Cursor stops you once the request allowance is gone. Every one of those clients speaks a different internal API, so the quota you paid for cannot follow you into the editor or CLI you actually prefer.

OpenRelay's answer is to sit between them. It discovers AI sources already installed on the machine (the README lists Claude Desktop, Claude Code, Kiro, Windsurf, Antigravity, OpenCode, VS Code Copilot, OpenAI Codex, Gemini CLI, Rovo Dev and QClaw), reads the credentials those apps already hold, and serves them back out as an Anthropic-compatible and OpenAI-compatible HTTP endpoint. The README also claims 45 direct API or local endpoints such as Groq, Gemini API, DeepSeek, Mistral, OpenRouter, LongCat, Qianfan, Qiniu, Anthropic API and Ollama, which you configure with your own API key or endpoint.

The audience is narrow and specific: individual developers who already hold several of these accounts and want one endpoint instead of six sets of environment variables. It is not a team gateway, and nothing in the README suggests multi-user access control.

## How the proxy, the panel and the IDE bridges fit together

The architecture is a single local process. package.json describes it as a "Multi-provider AI local proxy" that "extracts auth from locally installed AI desktop apps and exposes a unified HTTP proxy", and the bin entry points at ./dist/index.js. The only runtime dependency listed is sql.js, so the storage layer is a local SQLite database compiled to WebAssembly rather than a server database.

Three surfaces sit on top of that process. First, a provider layer that either harvests credentials from installed apps or accepts an API key you supply. Second, a Web panel on port 18765 that shows discovered providers and their quota status, and that writes configuration into your CLI tools. Third, protocol bridges for IDEs: the README describes a ConnectRPC over HTTP/2 RPC proxy for Cursor and Windsurf, an Ollama BYOK bridge for VS Code Copilot, and a Gemini REST proxy for Antigravity.

The routing trick is path-based. The base endpoint is http://localhost:18765, and appending a provider name selects it, as in http://localhost:18765/kiro. That is the whole mechanism for pointing one tool at a different upstream, and it is why the setup instructions are two environment variables rather than a config file. Credentials, per the README, stay on the machine in ~/.openrelay/, and requests go from your machine to the provider without OpenRelay's servers in the path.

## Installing OpenRelay and pointing Claude Code at it

There is no npm install step. The README states you download a prebuilt executable and run it, so Node is not required on the target machine even though the project is written in TypeScript and package.json declares engines.node >=18 for anyone building from source.

On macOS, the README's instructions download openrelay-macos and then clear the quarantine attribute, because the binary is unsigned:

```bash
chmod +x openrelay-macos
xattr -d com.apple.quarantine openrelay-macos
./openrelay-macos
```

The xattr line is the one people skip. Without it macOS refuses to open the file. Linux builds follow the same shape, with a separate binary per architecture:

```bash
chmod +x openrelay-linux-x64
./openrelay-linux-x64
```

After the process starts, the README says to open http://localhost:18765 in a browser. Everything is managed there, and the panel is bilingual. The dashboard is where discovery happens: providers it finds locally appear with a quota status, and the Work view writes configuration into supported CLI tools.

The first real use is the one the README leads with, redirecting Claude Code at a different quota source. On macOS or Linux:

```bash
export ANTHROPIC_BASE_URL=http://localhost:18765
export ANTHROPIC_API_KEY=unused
```

On Windows PowerShell the equivalent is:

```powershell
$env:ANTHROPIC_BASE_URL="http://localhost:18765"
$env:ANTHROPIC_API_KEY="unused"
```

The API key value is a placeholder; the local proxy supplies the real credential. To route through a specific provider instead of the default, the README shows appending the provider name to the base URL, for example ANTHROPIC_BASE_URL=http://localhost:18765/kiro. Reopen the terminal after setting these, and Claude Code will talk to the proxy rather than to Anthropic directly.

## Linux is a second-class platform, and the README says so

The README's Linux note is unusually honest and worth reading before you commit. Supported local and CLI providers on Linux are Claude Code, Kiro, Windsurf, OpenCode, VS Code Copilot, OpenAI Codex, Gemini CLI and Rovo Dev. Claude Desktop and Antigravity have no Linux version, so those two sources cannot be discovered there at all. QClaw is described as depending on the desktop app and a local gateway, and may run in a degraded mode.

Credential storage also changes. On Linux the README says credentials go through secret-tool (gnome-keyring) or a file cache. That fallback matters: on a headless server or a minimal desktop without gnome-keyring, you are relying on the file cache, which the README does not describe in detail. If you were planning to run this on a remote box to pool quota across machines, the documentation does not support that plan, and the security section's promise that credentials stay on the machine cuts against it.

The larger unresolved question is provider terms. The README explains where credentials are read from and where they are stored, and points at src/cookie.ts as auditable. It does not discuss whether using a Claude Desktop session to drive Claude Code is permitted by the upstream provider. That is the risk you are accepting, and the project leaves it to you.

## Model groups and failover sit behind the commercial licence

The feature that makes OpenRelay more than a credential shim is model grouping. The README gives this example:

```
"fast-group" = Groq (Llama 90B) + Cerebras (Llama 70B) + SambaNova (Llama 405B)
```

A request to the group goes to Groq first, falls to Cerebras when Groq's quota is unavailable, then to SambaNova. The README describes this as cross-provider round-robin and failover that keeps using configured available quota and reduces manual switching.

That is also where the licence splits. The README describes an Open Core model: the framework portion (proxy, format conversion, configuration) is MIT, while Pro features, explicitly model combination and higher request ceilings, fall under COMMERCIAL-LICENSE.txt. package.json declares "license": "MIT" for the package itself, and the repository carries both LICENSE and COMMERCIAL-LICENSE.txt at the top level, which is consistent with that split.

The practical consequence: if automatic failover across providers is the reason you are interested, check whether it is a Pro feature before you build a workflow around it. The README does not state how the Pro licence is obtained or what it costs. That is a gap, not a detail, and it is the first thing to resolve if failover is your use case.

## Alternatives, and where OpenRelay is the wrong tool

The closest alternative in kind is a self-hosted LLM gateway such as LiteLLM or an OpenAI-compatible router you configure yourself. The difference in approach is where credentials come from. A conventional gateway expects you to paste an API key for each provider; it is a routing and format-translation layer. OpenRelay's distinguishing move is credential discovery from installed desktop and CLI applications, which is what lets it use a Claude Desktop or Kiro session that has no API key to paste. If you already hold API keys for everything you use, a plain gateway gives you the same routing without touching application credential stores.

The wrong-tool cases are easier to list. Do not use it on a machine you do not control: the README's security section is built on the premise that credentials stay local, and a shared build server breaks that premise. Do not use it as a team gateway, since nothing in the README describes authentication for the panel or the endpoint on port 18765. Do not use it if your only provider is one whose terms you are unwilling to test, because the project gives you no guidance on that question. And do not use it on Linux if your main quota source is Claude Desktop or Antigravity, because those are not available there.

One operational point the README does address: message content is not written to logs, caches or persistence by default, and request-shape debugging output appears only when you explicitly enable it locally. That is a reasonable default for a proxy that sees every prompt you send.

## Maintenance, releases and what the licence split means for you

The repository is not archived, and the last push was on 2026-08-12, which is the same date as the v0.10.64 release. The two releases before it were v0.10.63 on 2026-07-22 and v0.10.62 on 2026-07-03, so the project has been shipping on a roughly two-to-three week cadence through that period. Note that package.json reports version 0.8.3 while the releases are at 0.10.64, so the manifest in the repository is not the version you download; treat the release tag as the version that matters.

Upgrade cost is low by design. You replace a single binary and restart it. The README does not document a migration path for the ~/.openrelay/ configuration, and it does not document rollback, so if a release changes how credentials are stored, the documentation is silent on what happens to your existing setup. Back up ~/.openrelay/ before upgrading if you have configured several providers.

On licensing, the split is the thing to read carefully. The framework is MIT, which is permissive and uncontroversial. Model combination and higher request ceilings are under COMMERCIAL-LICENSE.txt, and the README does not state the terms. This is not legal advice, but the practical question for a company is whether the workflow you want to build depends on the Pro portion, because that determines whether you are evaluating an MIT tool or a commercial product with an open core.

## Conclusion

Adopt OpenRelay if you already hold several AI subscriptions or free-tier API keys, you work on a single developer machine, and you want Claude Code, Aider or Goose to draw on whichever provider still has quota left. Do not adopt it on a shared or company-managed machine, and do not adopt it if your provider terms forbid moving credentials out of the first-party client; the README's security section explains where credentials are stored but never addresses whether reusing them elsewhere is permitted. Verify three things before you rely on it: which providers the panel actually discovers on your OS, whether the Pro model-combination feature is required for the failover you want, and what the Open Core split means for your use, since the framework is MIT but model combination and higher request ceilings sit under COMMERCIAL-LICENSE.txt.

## FAQ

### What is OpenRelay and what does it do?

It is a local proxy that discovers AI quota already available on your machine, from apps like Claude Desktop, Kiro and VS Code Copilot or from API keys you supply, and exposes it through one HTTP endpoint on port 18765. Tools that speak the Anthropic or OpenAI API can then use any of those providers.

### How do I install OpenRelay?

Download the prebuilt executable for your platform from the releases page and run it; the README states no npm install or Node environment is needed. On macOS you must also run chmod +x and xattr -d com.apple.quarantine on the binary before it will open.

### Does OpenRelay work on Linux?

Yes, with limits. The README lists Claude Code, Kiro, Windsurf, OpenCode, VS Code Copilot, OpenAI Codex, Gemini CLI and Rovo Dev as supported local or CLI providers on Linux, but states that Claude Desktop and Antigravity have no Linux version, and that QClaw may run in a degraded mode.

## Sources

- [Issues](https://github.com/romgX/openrelay/issues)
- [License: MIT](https://github.com/romgX/openrelay/blob/main/LICENSE)
- [README](https://github.com/romgX/openrelay/blob/main/README.md)
- [Releases](https://github.com/romgX/openrelay/releases)
- [romgX/openrelay on GitHub](https://github.com/romgX/openrelay)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/romgx-openrelay