Meridian: a local Anthropic API bridge for your Claude Max subscription

The gap Meridian fills between the Claude Agent SDK and your editor

The Claude Agent SDK gives programmatic access to Claude. Most coding agents, however, expect an HTTP endpoint that speaks the Anthropic or OpenAI wire format, with a base URL setting and an API key field. Meridian sits in that gap. It runs locally, accepts standard API requests, and routes them through the SDK's `query()` function. The README is explicit that this is the whole design: "The SDK does the work; Meridian formats the result." The target user is someone who already has a Claude Max subscription and a preferred frontend, whether that is OpenCode, Crush, Cline, Aider, Pi, Droid, Jcode, Open WebUI or Claude Code itself, and who does not want to switch tools to use the plan. The project also ships an OpenAI-compatible surface at `/v1/chat/completions` and `/v1/models`, which matters for tools that never learned the Anthropic protocol. No LiteLLM instance is required for that path, and the README notes `image_url` support for data URLs.

How the proxy works, and why it is not an OAuth interceptor

Meridian's stated position is that it does not extract OAuth tokens, patch binaries or reverse-engineer anything. Every request flows through the SDK's documented `query()` call. That choice has consequences the README spells out: Anthropic keeps control of prompt caching, context window management, compaction, rate limiting and authentication, and Meridian depends on those mechanisms rather than bypassing them. On top of that transport, Meridian adds session management so conversations persist across requests and survive compaction, undo and proxy restarts, plus SSE streaming, concurrent parent and subagent sessions, and passthrough mode, which forwards tool calls back to the client instead of executing them internally. Subagent model selection is a deliberate budget choice: primary agents get a 1M context window while subagents get 200k, which the README frames as preserving rate-limit budget. Multi-profile support lets you switch between Claude accounts without restarting, and an opt-in sticky session routing mode spreads sessions across accounts while keeping each account's prompt cache warm. There is also an envelope integrity check that validates Meridian's own wire output on every response and reports dangling blocks or undelivered tool calls on the dashboard.

Install and first request against 127.0.0.1:3456

Meridian publishes to npm as `@rynfar/meridian` and requires Node 22 or newer according to package.json. The README's quick start is four steps: install globally, authenticate once with the Claude CLI, run the setup command if you use OpenCode, then start the server.

npm install -g @rynfar/meridian
claude login
meridian setup
meridian

The `setup` step is only for OpenCode users, and the README shows a pinned V2 variant as `meridian setup --v2 --opencode-bin ~/.local/bin/opencode2`. After `meridian` starts, the proxy listens on `http://127.0.0.1:3456`. Point any Anthropic-compatible tool at it by setting the base URL and a placeholder key.

ANTHROPIC_API_KEY=x ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode

The key value is a placeholder. Meridian authenticates through the Claude Code SDK, not through API keys, but most Anthropic-compatible clients refuse to start with an empty key field, so any string works. If you prefer containers, the repository ships a Dockerfile and a docker-compose.yml. The compose file builds an image named `meridian`, maps `3456:3456`, runs the process as the `claude` user, and uses an `init` service to `chown` the `claude-auth` volume before the proxy starts, because the volume is created as root on first run.

Where Meridian breaks down or is the wrong tool

The most obvious limitation is the one the README states as a feature: Meridian does not bypass Anthropic's guardrails, so it cannot give you more capacity than your Max plan already allows. If your problem is hitting rate limits, Meridian is not a fix. It is also a local proxy by default, bound to `127.0.0.1:3456`. The README does not document authentication for exposing that port to a network, so treating it as a shared team endpoint is not something the documentation supports. Authentication itself is a moving part. The README says expired OAuth tokens are refreshed automatically and requests continue without interruption, but that refresh depends on a working `claude login` session on the host. When that session is gone, every client pointed at the proxy fails at once, and the README does not describe a fallback. The Docker setup carries its own friction: the Dockerfile comments explain that the build stage runs on glibc while the runtime stage is Alpine with musl, so the postinstall binary download is skipped during build and performed in the runtime stage instead, because a glibc binary yields ENOENT on musl. The Dockerfile also creates `/etc/machine-id` in the image layer, noting that Alpine does not provide one and that durable process-owner fencing needs it. Anyone maintaining a fork of that image inherits those details.

Meridian against a hosted gateway such as LiteLLM

A hosted gateway and Meridian solve overlapping problems from opposite directions. LiteLLM is a multi-provider router: you configure upstream providers and API keys, and it normalises many vendors behind one interface, typically deployed as a shared service. Meridian is single-purpose and local. It has one upstream, the Claude Agent SDK running under your Max subscription, and it exists so that tools which only know the Anthropic or OpenAI protocol can reach that upstream. The README's OpenAI-compatible endpoints are there so you do not need LiteLLM in front of it for tools like Open WebUI or Continue. The practical difference shows up in operations. A LiteLLM deployment is a service you run for a team, with provider keys as the credential. Meridian is a process on your machine, with your Claude login as the credential, and its feature set is built around that: session persistence across restarts, sticky routing across multiple personal accounts, per-account prompt cache warmth. If you need one endpoint for a dozen developers and several model vendors, Meridian is not that product. If you need your own subscription to appear inside Aider, it is.

Maintenance cadence, licence and upgrade cost

The repository is not archived, and the last push was on 2026-09-09, which is recent. Release history supports the same picture: meridian-v1.69.0 landed on 2026-09-09, v1.68.0 on 2026-09-05 and v1.67.0 on 2026-09-04, so releases arrive often. That cadence is also the upgrade cost. package.json declares `"version": "1.71.1"` while the newest release listed is v1.69.0, and the project uses release-please, with `.release-please-manifest.json` and `release-please-config.json` at the repository root. Frequent releases on a proxy that sits between your editor and your account mean you should read CHANGELOG.md before upgrading rather than pulling latest automatically. The `meridian setup` command writes OpenCode plugin configuration, and the README distinguishes a V1 plugin from a pinned V2 beta, so an upgrade can require re-running setup for your agent. On licensing, the README displays an MIT badge, but the repository metadata reports no licence, and there is no LICENSE file in the top-level entry listing. Those two signals disagree, and only the repository's own files can settle it. This is not legal advice; check the repository before relying on a licence term.

Editorial conclusion

Meridian fits developers who already pay for Claude Max and want their existing terminal or editor agent to route through it without patching binaries or extracting OAuth tokens. Skip it if you need a stable public endpoint, if you cannot keep `claude login` working on the host, or if your tool cannot be pointed at a custom base URL. Before adopting it, check the repository's licence file, since the README badge says MIT but the listing reports no licence, and confirm which plugin generation your OpenCode install needs by running `meridian setup` and reading docs/agents.md.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. rynfar/meridian on GitHub