Manual account switching for Claude Code works. A bash alias, a backup credentials file, a quick editor restart. Plenty of senior developers ship work this way and have for months. The honest question is what it actually costs in minutes, attention, and recovered context — and what an automated rotator removes from that cost without claiming to remove what it cannot.
What "manual account switching" actually means
There is a real subculture of Claude Code users running multiple accounts by hand. The recipe is mature enough that it has a canonical shape across blog posts, gists, and Reddit comments:
- Hold two or more paid Claude.ai subscriptions, each on its own email.
- Keep a backed-up copy of
~/.claude/credentials.jsonfor each one, named for the account (creds.work.json,creds.personal.json). - Write a bash alias —
claude-swaporccor some variant — that copies the desired backup over the live credentials file and restarts Claude Code. - When the active account hits a 429, run the alias, restart, re-prime the session with a context summary.
The reference implementations are public:
- The
realiti4/claude-swapgist family has been forked widely. It typically wraps the credential swap in shell. - The madewithlove blog post titled "Running multiple Claude accounts without logging out" walks through the same workflow with browser-side details.
- The Reddit thread that surfaces every few weeks under titles like "How do you handle Claude Code rate limits?" reliably converges on a variation of the same script.
The workflow exists because Claude Code itself does not natively support multiple accounts. Users who refuse to be locked out by the per-account ceiling assemble their own tooling out of cp, ~/.claude, and habit.
What manual switching costs
The honest accounting of the manual workflow per occurrence:
| Step | Time | What is lost |
|---|---|---|
| Notice the 429 / decide to swap | ~30s | Attention |
| Run the swap alias | ~5s | None |
| Wait for Claude Code to restart | ~15-30s | Editor state, terminal scroll |
| Re-open the project, re-attach to the active session | ~30s | Maybe the session, maybe not |
| Re-prime the conversation with where you left off | ~60-120s | Prompt cache, tool-read cache, agent's working memory |
| Mentally re-load the work you were doing | ~30-60s | Flow state |
The second-order costs are less visible but real:
- Lost TodoWrite state. If the dead session ended with eighteen pending items, the restored session does not inherit them. The user types them back in from memory or grep.
- Lost prompt cache. The new account's first turn re-loads the full system prompt and tool definitions at fresh-read prices. The cache discount that built up across the previous session's first hour is gone.
- Lost tool-read cache. Files the previous session read are not cached on the new account. The first time the new session needs the same file, it pays full read cost again.
- The script breaks every few months. Claude Code's credentials schema has changed at least twice in the past year. Each schema change silently breaks the swap script for users who do not re-test it after every Claude Code update.
The cumulative cost over a year of heavy use can run into days of recovered-context work. Most users do not measure it because each occurrence individually feels cheap.
What manual switching is good at
The honest version of this comparison has to acknowledge what the manual workflow does well:
- No subscription cost. The accounts are paid for either way. The swap script itself is free.
- Full transparency. You can read every line of the script. You can debug it with
bash -x. The behavior is fully under your control. - Editor-agnostic. Works the same with Claude Code, with the CLI, with other Anthropic-aware tools. The swap is at the credentials layer, beneath any specific editor.
- No third-party dependency. Anthropic and your local shell are the only required components. No proxy, no extension, no external process.
- Some users prefer the ritual. The explicit "I am switching now" moment is a real mental marker. For developers who want to feel in control of every account change, manual switching is honest about what is happening in a way that automated rotation is not.
The manual workflow is not strawman-able. It is a working solution that many engineers prefer for legitimate reasons. The point of comparing is not to win — it is to be clear about what each approach gives up.
What automated rotation removes
The watchdog-and-proxy approach changes the failure shape. Instead of waiting for a 429 and reacting, the proxy preempts the 429 by checking projected remaining budget before each request and routing to a fresher account.
What gets removed:
- The session restart. Rotation happens at the API layer. Claude Code never sees the 429. The active session continues uninterrupted across account boundaries.
- The credential-file swap. Credentials for each pooled account stay in their respective slots. No file is overwritten. No backup is needed. No schema change can silently break the workflow.
- The TodoWrite loss. The session does not end, so the TodoWrite state does not need recovery — it was never lost.
- The cache loss. The proxy enforces sticky routing per conversation — once a session lands on account A, its turns stay on account A unless the account caps. The cache built up over the session is preserved.
- The context rebuild. No new prompt to re-prime. The conversation continues from where it was.
What does not get removed by automated rotation — important to be clear about:
- The cost of multiple Claude.ai accounts. The pool requires accounts you already pay for. Pooling does not produce free Claude — it activates capacity you already own.
- Anthropic's TOS reading. Each account in the pool still has to be owned and controlled by you. The router does not change what is permissible.
- The need to think about TPM and RPM. The router handles fan-out load, but a single user's awareness of their own workload patterns is still useful.
The honest framing: automated rotation removes the operational tax of manual switching. It does not remove the financial or compliance dimensions. Those are unchanged. The rotator that does the removing is free to download and try, no credit card needed, if you want to feel the difference on your own sessions before reading further.
The real comparison — a representative week
A working comparison should use specific numbers, with appropriate caveats. Your week will vary; this is a representative pattern from a senior developer running Claude Code as a daily driver with two paid accounts:
| Metric | Manual switching | Automated rotation |
|---|---|---|
| Account swaps per week | 12-18 | 0 (handled at proxy) |
| Time per swap | 3-5 min | 0 |
| Lost sessions per week | 1-3 | 0-1 (still possible on crash, just recoverable) |
| Time per lost session | 15-25 min | 1-2 min (one-click resume) |
| Cache rebuild events | Once per swap | Once per session start |
| Mental context interruptions | 12-18 | 0 |
| Weekly time recovered | — | 60-120 min |
| Annual time recovered | — | 50-100 hours |
The honest read is that automated rotation reclaims an hour or two per week for users who currently swap accounts by hand. Whether that hour is worth the subscription cost of a rotation extension is a calculation each developer makes for themselves. For developers who do not currently swap accounts — who absorb 429s as forced breaks — the comparison is different and likely favors manual decisions about when to pause.
Frequently asked questions
Does manual switching ever break Claude Code's auto-update or hook chain?
The credentials swap itself does not touch the hook chain. The risk is that Claude Code's credentials schema can change in a minor update, and a swap script that worked yesterday can silently write a stale-format file today. The hook chain still runs; the active account is just no longer authenticated correctly. Symptoms range from 401 errors to mysterious session failures depending on what the schema change was.
If I script my manual swap with a launchd / systemd unit, can it match the rotator's UX?
You can get close — a watchdog that polls Claude Code's transcript for 429 records, runs the swap script, and re-launches the editor will replicate the basic loop. What you cannot easily replicate is in-session continuation. The credentials swap requires a Claude Code restart, which ends the session. The proxy-level approach intercepts at the API layer, so the session never ends and the cache never resets.
Why isn't this a problem on Cursor or other IDEs?
Cursor's business model is to bundle the AI compute. They run their own backend that abstracts over multiple model providers and handles rate-limiting at their layer, not at the user's account level. The user does not have a one-account ceiling because the user does not have a one-account relationship with the model provider. The trade-off is the AI compute is opaque, the model selection is constrained, and the cost structure is different.
Will Anthropic flag my account if I rotate too frequently?
Rotation across accounts you legitimately own is consistent with Anthropic's published terms. Each account in the pool has its own rate-limit budget, and a router that respects each account's limits is just using each account inside its contract. What would attract scrutiny is sharing one account's credentials with multiple users or reselling subscription access — neither of which a personal rotator does. Always check Anthropic's current TOS, but a personal pool of personally-owned accounts is the use case the TOS contemplates.
Can I run Power Claude alongside my existing manual swap script?
You can, with some friction. The credentials swap script will fight with the rotator's sticky-routing assumption — if your script overwrites the credentials file mid-session, the rotator's state for that account becomes inconsistent. The pragmatic move is to disable the swap script when the rotator is active. If you want to keep both as belt-and-suspenders, configure the rotator to treat one account as the only account and let the swap script handle the rest manually.
What's the simplest no-cost version of "automated" rotation I can build myself?
A LiteLLM proxy or similar OSS API gateway in front of api.anthropic.com, with two upstream Anthropic API keys configured as a round-robin pool, will get you the basic shape of automated rotation. What it will not give you is subscription-account pooling (the proxy works at the API-key level, not the Claude.ai-account level), session-resilience watchdog functionality, or in-editor UX. For developers comfortable with the trade-offs, it is a working free baseline.
Closing
Manual switching is honest, transparent, and free. Automated rotation costs a small subscription and reclaims the minutes the manual workflow spends every day. Which one is right depends on how you value those minutes, how often you swap, and whether the in-session continuity matters to your workflow. The version we ship is the productized rotator we built when we got tired of running the bash version ourselves.
If you want to put a week of your own swaps against it, the 14-day Premium Trial is $0 today and you can cancel anytime before day 15 — it adds the session watchdog and usage analytics on top of rotation. Not ready to put a card down? Install Power Claude Free instead: the 7-day free trial gives you full Pro access, no credit card.