claude-rotate

A tiny self-hosted proxy that lets Claude Code ride multiple Claude Max/Pro subscriptions and switches accounts automatically when one hits its rate-limit window — with a built-in analytics panel showing quota gauges, per-device consumption, and cost-equivalent dollars.

One process, one config file, no database. Built for individual developers who own more than one subscription and are tired of "You've hit your session limit".

Herd-safe, by test — not by vibes: when your whole fleet slams into a rate limit at the same instant, exactly one rotation decision happens — 100 in-flight requests, 1 switch, and every request recovers with a single retry onto the new account. Reproducible numbers in Performance.

Terms-of-Service note. This tool automates switching between accounts you personally own and pay for. Each account's limits are still fully enforced by Anthropic. Rotating accounts to work past limits is a gray area under Anthropic's consumer terms — use at your own risk, and do not use consumer subscriptions to back a shared/commercial service.

Contents: How it works · Performance · Quickstart: server · Generating tokens · Quickstart: devices · Networking · Analytics panel · Configuration · Run as a service · Troubleshooting · Limitations · Operations · Comparison · Security · License

How it works

Per request the proxy: authenticates the device (device key → device name), swaps in the active account's long-lived setup-token, forwards transparently, reads the exact anthropic-ratelimit-unified-* quota headers off the response, applies the rotation policy (consume-first; quota 429 → rotate, burst 429 → pace, all spent → hold), and logs usage per device/model. Diagram regenerates with python3 screenshots/architecture.py (needs pip install diagrams + graphviz).

Key insight: Claude Code respects ANTHROPIC_BASE_URL, and claude setup-token mints a ~1-year OAuth token per account. The proxy holds those tokens; devices only ever hold an internal device key. Every response from Anthropic carries exact quota telemetry headers, so switching at 80% is measured, not guessed.

Performance (herd-safe)

The point of a server proxy is that a whole fleet leans on it at once — so high-concurrency behavior is tested, not assumed. All numbers from the reproducible stress suite (python3 tests/test_stress.py, mocked upstream, Apple-silicon dev machine — run it on yours):

Why this matters with a fleet: the failure mode of naive rotators under load is the switch stampede — N in-flight requests each trigger their own switch, the account pool burns down in seconds, and every device's prompt cache is thrown away N times. Here a single lock serializes the decision: one switch, everyone else rides it. To be precise about what the lock can and cannot do: requests already on the wire when the quota hits still reach the dying account once each — nothing can un-send them — but there is exactly one switch and exactly one retry per request, and both counts are asserted in the test.

Honest scope: single process by design (state lives in one place — don't run uvicorn workers), and the upstream is mocked (the race test adds 50 ms of simulated RTT), so figures measure the proxy's own overhead and race behavior, not Anthropic latency.

Quickstart (server)

Requires Python 3.10+ and three packages: fastapi, httpx, uvicorn (pinned in requirements.txt). Any always-on box works — a Mac mini, a home-lab Linux machine, a small VPS.

git clone <this repo> && cd claude-rotate
pip install -r requirements.txt
./setup.sh                      # creates config.json, tokens/, logs/
./setup.sh add-account acct-1   # paste token from: claude setup-token  (account 1's browser)
./setup.sh add-account acct-2   # …account 2
./setup.sh add-device my-laptop # prints the env vars for that device
python3 rotator.py

Generating account tokens (claude setup-token)

Each subscription account contributes one long-lived OAuth token. Facts below are from the official authentication docs unless flagged otherwise.

Minting a token:

claude setup-token

• Opens the same browser OAuth flow as /login; if no browser can reach the local callback (headless server, SSH session), it falls back to a paste-a-code flow — so you can mint tokens on the proxy server itself.
• Prints a token starting sk-ant-oat01-… to the terminal and does not save it anywhere — copy it straight into ./setup.sh add-account <name>, which stores it under tokens/ (chmod 600, gitignored).
• Valid for about one year. Requires a Claude subscription (Pro, Max, Team, or Enterprise).

Minting for multiple accounts from one machine. The account that completes the browser OAuth is the account the token belongs to — the CLI's current login doesn't decide it. (Officially undocumented; this is the behavior in practice.) Two workable recipes:

1. Browser profiles: keep one browser profile (or incognito window) logged into claude.ai per account. Run claude setup-token, and complete the OAuth in the profile of the account you're minting for — copy the URL into that profile if the wrong one opens.
2. Config-dir isolation: CLAUDE_CONFIG_DIR=~/.claude-acct2 claude setup-token keeps a fully separate CLI login per directory, useful if you also want to run Claude Code as different accounts.

After adding an account, send one request through the proxy and check /rotate/status — the unified utilization headers it reports are per-account, so a token minted against the wrong account shows up immediately as the wrong gauge moving.

Lifetime & revocation:

• There is currently no CLI command to list or revoke setup tokens (open feature request); revoke manually from claude.ai settings. /logout only revokes the CLI's active session credential, not previously minted setup tokens.
• Treat each token file as a year-long bearer credential for that Anthropic account (see Security notes). When a token dies early, the proxy's upstream calls start returning 401 for that account — the roadmap has an alert for this.
• Scope note: subscription OAuth tokens are for Claude Code traffic — which is all this proxy forwards — and per the 2026 docs they are rejected by the raw Messages API.

Quickstart (each device)

Two env vars in your shell profile — that's the whole client install:

export ANTHROPIC_BASE_URL=http://<server>:8484
export CLAUDE_CODE_OAUTH_TOKEN=<device key printed by add-device>

Run claude as usual. When account 1's 5-hour window fills, the next request rides account 2. Use a VPN/overlay like Tailscale between devices and server — the proxy speaks plain HTTP and device keys are bearer secrets. See Connecting distributed devices for setups.

Connecting distributed devices

The proxy is plain HTTP and device keys are bearer secrets, so the transport between devices and server must be private. Pick one:

Same LAN / subnet (nothing to install)

If every device lives on the same trusted network as the server — home lab, office LAN — you don't need Tailscale or any overlay at all:

# on the server: find its LAN address
ipconfig getifaddr en0        # macOS (en0 = Ethernet/Wi-Fi)
hostname -I                   # Linux

# on each device:
export ANTHROPIC_BASE_URL=http://192.168.1.42:8484

• macOS servers get a free stable name via Bonjour/mDNS: http://<hostname>.local:8484 (e.g. http://mac-mini.local:8484) works from Macs, iPhones, and most Linux devices (with avahi-daemon) — no IP to remember. Otherwise give the server a DHCP reservation in your router so its IP never changes under the devices pointing at it.
• Set bind in config.json to the LAN IP (or keep 0.0.0.0 if the box has only one network). Verify from a device: curl http://<server>:8484/rotate/status?key=<device key>.
• Do not port-forward 8484 on your router. LAN-only means the firewall boundary is your router's NAT; forwarding the port turns this into the internet-exposed scenario below.

The trust caveat: traffic is plain HTTP, so anyone on the same subnet can read device keys off the wire. Fine for a home network you control; on a shared office network or anywhere with guests, prefer one of the encrypted options below. And a hybrid is normal — LAN for the desktop next to the server, Tailscale for the laptop that leaves the house.

Tailscale (recommended)

Zero-config WireGuard mesh; free tier covers personal use easily.

# on the server AND every device:
#   macOS:  brew install tailscale && brew services start tailscale
#   Linux:  curl -fsSL https://tailscale.com/install.sh | sh
tailscale up                      # login once per machine, same tailnet
tailscale status                  # note the server's name / 100.x.y.z address

With MagicDNS on (default on new tailnets), devices reach the server by name:

export ANTHROPIC_BASE_URL=http://<server-hostname>:8484   # e.g. http://my-server:8484
export CLAUDE_CODE_OAUTH_TOKEN=<device key>

Tighten the listener so the proxy is only reachable over the tailnet — set bind in config.json to the server's Tailscale IP instead of 0.0.0.0:

{ "bind": "100.x.y.z", "port": 8484 }

Optional TLS: tailscale serve --bg http://127.0.0.1:8484 publishes the proxy as https://<server>.<tailnet>.ts.net (valid cert, tailnet-only). Then use that URL as ANTHROPIC_BASE_URL and set bind to 127.0.0.1.

CI runners and containers work too: ephemeral auth keys (tailscale up --auth-key=tskey-...) join a runner to the tailnet for the duration of a job; there's a ready-made GitHub Action (tailscale/github-action).

Plain WireGuard

Same effect, no third party. Sketch: generate a keypair per machine (wg genkey | tee private.key | wg pubkey > public.key), give the server a wg0 with an internal subnet (e.g. 10.84.0.1/24), add each device as a [Peer] with AllowedIPs = 10.84.0.X/32, and point devices at http://10.84.0.1:8484. Set bind to 10.84.0.1. More manual than Tailscale (key distribution, NAT traversal is on you), but fully self-hosted.

SSH tunnel (zero install)

Any device that can SSH to the server needs nothing else:

ssh -N -L 8484:127.0.0.1:8484 user@server &
export ANTHROPIC_BASE_URL=http://127.0.0.1:8484

With bind: 127.0.0.1 on the server, this is the tightest setup — the proxy never listens on a network interface at all. Use autossh (or ServerAliveInterval 30 in ~/.ssh/config) to keep the tunnel up; fine for a laptop or a single CI box, tedious beyond a few devices.

Cloudflare Tunnel (device without VPN access)

For a device that can't join your tailnet (locked-down corp machine, hosted CI you can't install agents on), cloudflared can expose the proxy through Cloudflare without opening ports:

# server:
cloudflared tunnel login
cloudflared tunnel create claude-rotate
cloudflared tunnel route dns claude-rotate rotate.example.com
cloudflared tunnel run --url http://127.0.0.1:8484 claude-rotate
# device:
export ANTHROPIC_BASE_URL=https://rotate.example.com

This makes the proxy internet-reachable — the only thing between the world and your Anthropic tokens is the device-key check. If you go this route, put Cloudflare Access (a Zero Trust service-token policy) in front so unauthenticated requests never reach the proxy, and treat device keys as revocable: delete a leaked one from config.json and restart. Prefer any of the VPN options above when possible.

Other overlays

ZeroTier and NetBird work identically to Tailscale for this purpose (private overlay IP + bind to it); use whichever your fleet already runs. Whatever the transport, the checklist is the same: proxy bound to a private interface, HTTP never exposed publicly, one device key per machine so any single machine can be revoked alone.

Analytics panel

Open http://<server>:8484/rotate/panel?key=<any device key>:

Live 5-hour and weekly gauges per account, straight from Anthropic's own rate-limit headers:

• Devices — every registered device: online status, last seen, last model, which account its traffic rode, requests + tokens in the last hour.
• Accounts — live 5-hour and weekly utilization gauges (from Anthropic's own headers), active account, reset countdowns.
• Alerts — device over N tokens/hour, expensive-model usage (Opus/Fable), account near the switch threshold. Thresholds in config.json.
• Consumption (24h) — by device / model / account, with a cost-equivalent column: what the usage would cost at API list prices (incl. cache read 0.1× / write 1.25×) — i.e. what the subscriptions are saving you.

JSON endpoints: /rotate/status (accounts + switch events) and /rotate/stats (rollups + alerts), same ?key= or Authorization: Bearer auth. Audit trail: logs/audit.jsonl, one JSON record per request.

OpenAI-compatible endpoint

POST /v1/chat/completions (same device-key auth) accepts OpenAI-format chat requests — streaming included — and rides the same rotated accounts, so any OpenAI-format app or LLM router can use the capacity, not just Claude Code:

curl http://<server>:8484/v1/chat/completions \
  -H "Authorization: Bearer <device key>" -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":256,
       "messages":[{"role":"user","content":"hello"}]}'

Text conversations only (tool use → 400). When every account's window is spent it returns 503 + Retry-After: <seconds to earliest reset> — point a router's circuit breaker at that. Responses carry x-rotate-account and the upstream anthropic-ratelimit-unified-* headers for per-request telemetry.

Configuration (config.json)

Rotation policy

An account is usable while its 5h window is under switch_threshold and its weekly window under switch_threshold_7d; a window past its reset counts as 0%. State survives restarts in state.json.

• consume-first (default): burn the usable account whose weekly window resets soonest — weekly quota is use-it-or-lose-it, so the perishable account is spent first and no paid quota expires unused. The proxy also switches proactively (below the threshold) when another usable account's weekly reset is at least consume_first_margin_s sooner.
• least-used: classic — lowest 5h utilization wins.
• A cooldown plus a hysteresis margin stop accounts ping-ponging at the threshold; a hard limit (quota actually rejected) always switches immediately.
• Burst vs quota 429s: a per-minute rate-limit 429 (utilization not exhausted) does not rotate — rotating would move the burst to the next account and throw away its warm prompt cache. The account is paced for retry-after seconds and the request retried.
• Hold-until-reset (hold_max_s > 0): when every account is spent, the proxy keeps the request open and retries after the soonest 5h reset instead of failing — an unattended CI/agent run finishes on its own instead of dying at 2am. Make sure your client's request timeout tolerates the wait (Claude Code's default is generous; other clients may need tuning).

Preferring one account over another

Three levels of control, from lazy to pro — all in the same config.json, deliberately no separate rules file (see design note below):

Level 0 — do nothing. The defaults (consume-first + thresholds + cooldown) already make a sane global decision. Most single-owner setups need nothing else.

Level 1 — priority tiers. Give accounts a priority (lower = preferred):

"accounts": [
  { "name": "max-20x",  "token_file": "tokens/max-20x.token",  "priority": 1 },
  { "name": "max-5x",   "token_file": "tokens/max-5x.token",   "priority": 1 },
  { "name": "old-pro",  "token_file": "tokens/old-pro.token",  "priority": 2 }
]

Rotation happens within the lowest-numbered tier that still has a usable account; old-pro above is touched only when both Max accounts are spent. When a preferred account's window resets, traffic is pulled back automatically (priority_recovery in the events feed) after the cooldown — the backup is a spillway, not a new home. Accounts without a priority share one default tier, which is why Level 0 works unchanged.

Level 2 — bench an account. "disabled": true takes an account out of rotation entirely (a work account you don't want touched, one you're resting) while keeping it visible in the panel. If the active account is disabled in config, the proxy abandons it on the next response, cooldown or not. Re-enable by deleting the flag; both changes need a restart (hot reload is on the roadmap).

Combine with strategy for the remaining temperament choice: consume-first (spend perishable weekly quota first) or least-used (spread evenly).

Design note — why no rules YAML: a rules engine (per-model routes, time-of-day windows, per-device pinning) would add a parser, a second config file, and an ordering semantics to a one-file tool, and every use case we've actually hit decomposes into the four knobs above (strategy, priority, disabled, thresholds). If a real need appears that doesn't decompose — say per-device account pinning — add it as another plain field on the existing config objects, not as a DSL.

Run as a service

• macOS: deploy/com.example.claude-rotate.plist (read its comments — launchd needs the full python3 path and a local-disk install).
• Linux: deploy/claude-rotate.service (systemd).

Troubleshooting

Client gets 401 with claude-rotate: unknown device key. The proxy is rejecting the device (the error body names claude-rotate, so it's not Anthropic). The device's CLAUDE_CODE_OAUTH_TOKEN doesn't match any entry in config.json devices{} — re-check the key, or re-run ./setup.sh add-device and restart.

Client gets a 401 whose error body comes from Anthropic. The account token the proxy swapped in was rejected upstream — on a previously working account this almost always means the setup token died (revoked, or hit its ~1-year expiry). Re-mint with claude setup-token, replace tokens/<name>.token, restart.

A request seems to hang. If every account is spent and hold_max_s is set, that's hold-until-reset doing its job — the request is parked until the soonest 5h window reset. Check recent_events in /rotate/status for a hold entry. Set hold_max_s: 0 if you'd rather fail fast.

"Why did it switch accounts?" Every switch is an event in /rotate/status → recent_events (and the panel's Recent switches), with a reason: quota_exhausted, utilization>=<threshold>, consume_first, priority_recovery, or account_disabled. If you saw a 429 upstream but no switch, it was a per-minute burst — the proxy paced the same account on purpose (see Rotation policy).

Config edits don't take effect. Config is read once at startup. Restart: launchctl kickstart -k gui/$(id -u)/<label> (macOS) or systemctl restart claude-rotate (Linux). Hot reload is on the roadmap.

Does the VS Code extension work? Yes — it honours the same ANTHROPIC_BASE_URL / CLAUDE_CODE_OAUTH_TOKEN environment variables. Launch VS Code from a shell that has them exported (or set them user-wide) so the extension inherits them.

Panel is empty or unauthorized. The panel needs ?key=<any device key> in the URL; consumption tables build from logs/audit.jsonl and only show the last 24h, so a fresh install shows zeros until traffic flows.

Client throws Zlib/Brotli decoding errors. Shouldn't happen — the proxy forces accept-encoding: identity upstream and strips content-encoding from responses. If it appears after modifying rotator.py, you broke load-bearing fact #2 in the continuation notes.

Limitations

Stated plainly, in the same spirit as the comparison:

• One active account, globally. Every device rides the same account at any moment, so a token-hungry CI box drains the window your laptop is using. Per-device visibility exists (panel, alerts); per-device quotas don't.
• No per-model weekly caps. Anthropic tracks some model families separately; the proxy only tracks the account-wide 5h/7d windows, so an account out of (say) Opus quota gets benched entirely even if Sonnet still has room. teamclaude does this better today.
• Switches drop warm prompt caches. After a rotation, every device's first request re-writes its prompt cache on the new account — that's the cost that burst-pacing (and the hysteresis margin) exist to avoid paying needlessly.
• Restart to reconfigure. No hot reload yet.
• Plain HTTP by design. Transport privacy is delegated to the network layer — see Connecting distributed devices.
• Built on undocumented headers. Quota telemetry comes from anthropic-ratelimit-unified-*; if Anthropic changes them, rotation degrades to reacting to 429s until the code is updated.
• No automatic token renewal. Setup tokens last ~1 year and die silently; the symptom is upstream 401s (see Troubleshooting).

Operations

• Audit log growth. logs/audit.jsonl grows without bound (one JSON line per request) and the stats endpoint re-reads it fully on every refresh, so after months it slows the panel. The panel only uses the last 24h — rotate the file whenever you like:

  copy

  # e.g. monthly via cron/launchd; the proxy recreates the file on the next request
  mv logs/audit.jsonl "logs/audit-$(date +%Y%m).jsonl"
  

  No restart needed (the file is opened per write). In-process rotation is on the roadmap.

• What to back up. tokens/ and config.json — that's the whole identity of the install. state.json is disposable (quota state is re-learned from the first responses; you only lose the events history), and logs/ is disposable analytics.

• Upgrades. git pull, run python3 tests/run_all.py, restart the service, then eyeball /rotate/panel — active account, gauges, and a request flowing end-to-end.

• Health check. curl -fs http://<server>:8484/rotate/status?key=<device key> exits non-zero when the proxy is down — wire it into uptime monitoring if the fleet depends on it. The launchd/systemd units in deploy/ already restart the process if it dies.

Comparison with similar projects

The multi-account rotation niche is well populated. Stars as of Sep 2026.

Honest reviews:

• teamclaude — the most sophisticated rotation engine in the field: per-model weekly caps, burst-vs-quota 429 discrimination, post-failover pacing, OAuth refresh, a MITM catch for hardcoded endpoints, zero npm dependencies. claude-rotate adopted its burst-pacing and hold-until-reset ideas. If you're one person on one machine, it's arguably the better tool; it has no multi-device story.
• claude-swap — the most popular and most polished UX (uv/pipx install, hysteresis, quarantine of dead tokens, parallel sessions per terminal). It swaps local credentials rather than proxying, so there's no fleet/CI story and each machine manages its own accounts. Its consume-first strategy is where we took the name and idea from.
• claude-relay-service — by far the biggest (Redis, admin UI, multi-provider: Claude/OpenAI/Gemini). It is explicitly built for 拼车 / carpooling — pooling subscription accounts across multiple people to split costs. That is not a gray area: sharing consumer subscription access with third parties violates Anthropic's consumer terms, and account bans around such services are regularly reported. Impressive engineering; don't use it with consumer Max/Pro accounts.
• CC-Router — clean and simple, but blind round-robin: no telemetry, so it can rotate onto a spent account and drops warm prompt caches for no reason.
• claude-account-switcher (and the Alfred/menu-bar family) — solves login juggling, not routing. Manual switching between your own accounts is the most ToS-defensible workflow of all; the auto-switch-at-limit mode shares the same gray area as everything else here.
• claude-rotate — what we actually add over the field: the multi-device server model (devices hold revocable device keys, year-long account tokens never leave the server), per-device consumption/cost attribution, and a published concurrency story — the stress suite proves one-switch-per-herd and no-rotation burst storms under 100+ in-flight requests, numbers you can re-run rather than take on faith. (teamclaude engineered for herd failover too — its post-switch pacing — but doesn't publish load measurements.) What others do better: teamclaude's per-model caps and OAuth refresh, claude-swap's install/UX polish. One file, no database, by design.

On ToS, plainly: every tool above that automatically rotates consumer subscriptions to continue past a rate limit — including claude-rotate — sits in the same gray area described in the note at the top of this README: you're automating around limits Anthropic set per account, using accounts you personally own and pay for. Anthropic's consumer terms prohibit sharing account credentials and reselling access; they are less explicit about one person owning several subscriptions. The bright line: rotating your own accounts = gray, at your own risk; pooling/sharing/reselling access (claude-relay-service's core use case) = violation. If your workload is commercial or shared, use the API with metered billing instead.

Security notes

• tokens/*.token are year-long bearer credentials for your Anthropic accounts. They stay on the server, mode 600, and are gitignored along with config.json, state.json, and logs/.
• Device keys authenticate devices to the proxy only; revoke one by deleting its entry in config.json and restarting.
• Don't expose port 8484 to the public internet; bind to a tailnet/LAN interface or keep bind: 0.0.0.0 behind a firewall.

For the next agent (continuation notes)

Everything lives in rotator.py (~450 lines, FastAPI) — read it top to bottom before changing anything. phase0_proxy.py is a standalone logging passthrough kept for debugging header behavior; not part of the service.

Load-bearing implementation facts (each was verified empirically — keep them):

1. Transparent passthrough. The proxy forwards all paths/methods to api.anthropic.com, replacing only the Authorization header. Claude Code sends its own anthropic-beta: oauth-2025-04-20 etc. — do not strip or reorder client headers.
2. Encoding trick. Forwarded requests force accept-encoding: identity and the response's content-encoding header is dropped — otherwise httpx auto-decompresses while the original header survives and the client throws Zlib/Brotli errors.
3. Quota telemetry comes from anthropic-ratelimit-unified-5h-utilization / -7d-utilization / -5h-reset / -status response headers (present on Max subscription traffic; undocumented — re-verify after Anthropic API changes).
4. SSE usage capture parses data: lines containing "usage" while streaming chunks through untouched; audit is written in the stream's finally.

Roadmap, in intended order:

• Tests. python3 tests/run_all.py — 101 offline checks, no network (needs a valid config.json to import the module): test_rotator.py switch logic (consume-first ordering, burst-vs-quota 429, cooldown, hysteresis, hold/exhausted verdicts, window-reset recovery); test_analytics.py SSE usage capture, pricing/cost math, aggregate_audit rollups/alerts/roster; test_proxy.py end-to-end HTTP through the real ASGI app against a mocked upstream (auth, header rewriting incl. the encoding trick, SSE relay, transparent quota-429 rotate+retry, burst pacing, 429 passthrough vs hold-until-reset, admin endpoints); test_stress.py high-traffic behavior (300-request fan-out with throughput floor, exactly-one-switch race check with 100 in-flight requests during a quota hit, burst storm without rotation, 20 concurrent held requests, 50 parallel SSE streams, events-list bound under churn, aggregate_audit speed on a 50k-row log).
• OpenAI-compatible endpoint. POST /v1/chat/completions (see its section above): OpenAI ↔ Anthropic translation incl. SSE chunks, in oai_compat.py (pure, tested offline in tests/test_oai_compat.py); injects anthropic-version + anthropic-beta: oauth-2025-04-20, forwards NO client headers, refuses tool use with a 400. The rotation loop is shared with the transparent proxy (send_upstream).
• Exhaustion signal. The OpenAI endpoint returns 503 + Retry-After: <earliest reset> when all accounts are spent (after any hold_max_s hold is exhausted) — point a router's breaker at it. The transparent proxy deliberately still passes Anthropic's 429 through: Claude Code handles those natively, and that path's contract is transparency.
• Webhook alerts (Slack/Teams/generic POST) firing on the same rules as the panel's alerts section.
• In-process audit rotation — roll logs/audit.jsonl past a size/age threshold so the Operations section's cron recipe becomes unnecessary, and stop re-reading the whole file per stats call (seek from the tail).
• Dockerfile (+ compose example) — also enables running as a sidecar next to a router in k8s; tokens mounted as secrets.
• Hot config reload (SIGHUP or mtime check) so add-account / add-device don't need a restart.
• Token renewal automation — setup-tokens last ~1 year; at minimum alert on auth failures (401 from upstream on a known-good account usually means the token died).

Style: keep it one file until it genuinely hurts; stdlib + fastapi/httpx only; every new claim about Anthropic behavior gets verified against the live API before being relied on (the phase0_proxy.py harness exists for exactly that).

License

MIT © 2026 John Doxaras. The Terms-of-Service note at the top of this README is part of the deal: this software is for rotating accounts you own and pay for, at your own risk.