Meridian: An Anthropic API Facade Over the Claude Agent SDK
Use your Claude Max subscription with OpenCode, Pi, Droid, Aider, Crush, Cline, Jcode. Proxy that bridges Anthropic's official SDK to enable Claude Max in third-party tools.
At a glance
- What is it?
- Meridian is a local proxy that exposes the Claude Agent SDK through standard Anthropic and OpenAI endpoints so tools like OpenCode, Aider, and Cline can use a Claude Max subscription. The design is deliberately narrow: it formats SDK output rather than bypassing Anthropic's own controls.
- Who is it for?
- Adopt Meridian if you already pay for Claude Max, want to keep using OpenCode, Aider, Cline, Crush, Droid, Pi or Jcode, and are comfortable with a proxy that depends on the Claude Agent SDK staying callable the way it is today. Do not adopt it if you need a written licence grant before shipping it inside a company, if you want an OpenAI-compatible gateway for arbitrary model providers, or if you cannot run a local process on 127.0.0.1:3456.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap Meridian fills between Claude Max and third-party agents
A Claude Max subscription is consumed through Claude Code. The Claude Agent SDK, formerly the Claude Code SDK, gives programmatic access to the same machinery through a documented `query()` function. Neither of those is an HTTP endpoint that an editor plugin can point at. OpenCode, Aider, Cline, Crush, Droid, Pi and Jcode all expect an Anthropic-compatible API with a configurable base URL, and that is the mismatch Meridian addresses. It is aimed at developers who already hold a Max subscription and would rather keep their existing terminal or editor workflow than move into Claude Code itself. The README is explicit that the target is interoperability, not access: Meridian describes itself as a presentation and interoperability layer that translates Claude Code output into the standard Anthropic API format. The API key handling reflects that framing. Meridian authenticates through the Claude Code SDK, so the `ANTHROPIC_API_KEY` value is a placeholder. Most Anthropic-compatible clients insist the field be populated, but the README states any value works.
How the SDK bridge works, and why there is no OAuth interception
The mechanism is narrow by design. Every request flows through `query()`, the documented function Anthropic provides for programmatic access. The README states plainly that no OAuth tokens are extracted, no binaries are patched, and nothing is reverse-engineered. That matters because the alternative approach in this space is to intercept Claude Code's OAuth traffic or patch its binary, both of which break whenever Anthropic changes internals. Meridian instead depends on the SDK for prompt caching, context window management, compaction, rate limiting and authentication. The proxy adds session management, SSE streaming with MCP tool filtering, concurrent parent and subagent requests, and passthrough mode, where tool calls are forwarded to the client rather than executed inside the proxy. Subagent model selection is a documented detail worth noting: primary agents get a 1M context window while subagents get 200k, which the README frames as preserving rate-limit budget. There is also an envelope integrity check that validates the wire output on every response, looking for dangling blocks and undelivered or empty tool calls, with violations surfaced on the dashboard. That self-audit is unusual and suggests the author has been bitten by malformed streaming output before.
Installing Meridian and pointing an agent at port 3456
The quick start is four steps. Install globally with `npm install -g @rynfar/meridian`, authenticate once with `claude login`, run `meridian setup` for OpenCode, then start the proxy with `meridian`. It listens on `http://127.0.0.1:3456`. Connecting a tool is a matter of environment variables, shown in the README as `ANTHROPIC_API_KEY=x ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode`. The setup command has a V2 variant, `meridian setup --v2 --opencode-bin ~/.local/bin/opencode2`, which the README labels a pinned V2 beta. Configuration lives in `docs/configuration.md` and covers environment variables, endpoints, API key auth, SDK feature toggles, passthrough mode and CLI commands. Multi-account support is documented separately in `docs/profiles.md`, including headless login and opt-in sticky session routing that distributes sessions across accounts while keeping per-account prompt caches warm. Cost estimation reads from `~/.config/meridian/model-pricing.json`, editable at the `/settings` page, and telemetry is visible at `/telemetry`. Deployment options listed are NixOS and Nix flake, a Home Manager service, and Docker. Per-agent configuration for OpenCode, Crush, Droid, Cline, Aider, Codex CLI, Open WebUI, Cherry Studio, ForgeCode, Pi, Claude Code and Claude Design MCP is in `docs/agents.md`.
The dependency on Anthropic's SDK is the real constraint
Meridian's honesty about working within the SDK's constraints is also its main risk. Because everything routes through `query()` and the SDK owns authentication and rate limiting, a change in the SDK's behaviour or in how Anthropic governs Max usage propagates straight through the proxy. The README's own framing acknowledges this: Max limits exist because Anthropic can optimize and manage usage through Claude Code, and Meridian depends on those mechanisms rather than bypassing them. Practically, that means the project cannot promise stability independent of Anthropic's roadmap. The README also does not describe what happens when the SDK rejects a request, whether errors surface as Anthropic-shaped error responses or raw SDK failures, or how the proxy behaves when a token refresh fails mid-stream. Auto token refresh is listed as a feature, but the failure path is not documented in the supplied material. Anyone running this in front of a team should treat those gaps as unknowns to test, not as solved problems. There is also a single point of failure in the local process itself: if `meridian` stops, every configured agent stops with it.
Where an OpenAI-compatible gateway is a better fit
LiteLLM is the obvious comparison, and the README makes the contrast itself by noting that the OpenAI-compatible endpoints (`/v1/chat/completions` and `/v1/models`, including `image_url` support for data URLs) exist so tools like Open WebUI and Continue work without LiteLLM. The difference in approach is the direction of the abstraction. LiteLLM is a multi-provider router: one OpenAI-shaped interface in front of many backends, with its own key management, budgets and fallback logic. Meridian is the opposite. It is a single-backend adapter that happens to speak two protocols, and its authentication story is a Claude Max subscription rather than API keys. If you need to route across Anthropic, OpenAI and local models from one endpoint, or you need per-key spend limits, Meridian is the wrong tool. If you have one Max subscription and several agents that each want their own base URL, LiteLLM adds a configuration layer you do not need. The choice is between breadth of providers and depth of integration with one.
Release cadence, licence ambiguity and upgrade cost
The release history shows a fast cadence: meridian-v1.67.0 on 2026-09-04, v1.68.0 on 2026-09-05, and v1.69.0 on 2026-09-09. Three minor releases in five days implies active development and a steady stream of fixes, but it also means the version you pin today will be several releases behind within a week. For a proxy sitting between your editor and a paid subscription, that is a real operational cost: upgrades are not optional if a fix matters, and each upgrade is another chance for an agent adapter to regress. The licence situation needs attention. The README badge says MIT, but the repository metadata supplied here lists the licence as unknown. Those two signals conflict, and the badge is not a substitute for the LICENSE file. Before using Meridian inside a company, read the actual licence text in the repository rather than trusting the badge. If the project is MIT as the badge claims, the usual obligations apply and no legal advice is needed beyond confirming the file exists. If it is not, the terms may differ in ways that matter for internal distribution.
Who should run Meridian, and what to verify first
The fit is specific. You should consider Meridian if you hold a Claude Max subscription, you already use one of the supported agents, and you want session persistence across proxy restarts plus streaming and multimodal passthrough without writing your own bridge. The multi-profile and adapter-instance features are aimed at people running several accounts or several configurations of the same agent side by side, selected by header or match rules. You should not adopt it if you need a licence you can point a legal team at today, if your agents only speak the OpenAI protocol and you also need non-Anthropic providers, or if you cannot run a persistent local process. The verification list is short and concrete. Confirm the LICENSE file matches the MIT badge. Confirm `claude login` succeeds and that auto token refresh actually recovers from an expired token in your environment, since that path is listed as a feature but not documented in detail. Confirm your agent accepts `ANTHROPIC_BASE_URL` and tolerates a placeholder API key. Then decide whether the three-releases-a-week pace is something you can absorb.
Editorial conclusion
Adopt Meridian if you already pay for Claude Max, want to keep using OpenCode, Aider, Cline, Crush, Droid, Pi or Jcode, and are comfortable with a proxy that depends on the Claude Agent SDK staying callable the way it is today. Do not adopt it if you need a written licence grant before shipping it inside a company, if you want an OpenAI-compatible gateway for arbitrary model providers, or if you cannot run a local process on 127.0.0.1:3456. Before committing, verify the licence badge against the actual LICENSE file in the repository, confirm that `claude login` works on your machine, and check that your agent accepts a custom base URL.
Community notes