Switch Claude Code Accounts Without Logging Outand Keep Every Conversation

Logout, Login, Re-explain

Switching accounts cost me a login and a conversation

I use Claude Code with more than one account: an office one, a personal one. Switching between them was the most annoying five minutes of my day, and the login was the smaller half of it.

claude-office      # Claude Code, logged in as the office account
claude-personal    # Claude Code, logged in as the personal account
claude-side        # add as many as you need

Why Not CLAUDE_CONFIG_DIR

The usual answer splits your history in two

Search for "multiple Claude Code accounts" and the standard answer is to give each account its own config folder with the CLAUDE_CONFIG_DIR environment variable. It solves the login problem and creates a new one.

~/.claude/
  .credentials.json   the login (the only account-specific file)
  projects/           every conversation, stored per working folder
  CLAUDE.md           your global instructions
  settings.json       permissions, hooks, model, statusline
  skills/  agents/    your skills and subagents

Swap Only The Login

One shared folder, a saved login per account

Every saved login lives in its own folder, ~/.claude-accounts. A small shell function swaps the right one into ~/.claude before Claude Code starts and saves it back when Claude Code exits.

~/.claude/                     shared by every account
  .credentials.json            <- the login currently in use (swapped)
  projects/  CLAUDE.md  settings.json  skills/ ...

~/.claude-accounts/            one saved login per account
  office.credentials.json
  personal.credentials.json
  active                       "office" or "personal"

Setup: Windows

Windows, in PowerShell

if (!(Test-Path $PROFILE)) { New-Item -ItemType File -Force $PROFILE }
notepad $PROFILE

# Claude Code: several accounts, ONE shared config folder (~/.claude).
# Only the login file (.credentials.json) is swapped; each account's login
# is kept in ~/.claude-accounts/<name>.credentials.json. One account at a time.
function Use-ClaudeAccount {
  param([string]$Name, [string[]]$Rest)
  $store = "$env:USERPROFILE\.claude-accounts"
  $cred  = "$env:USERPROFILE\.claude\.credentials.json"
  New-Item -ItemType Directory -Force $store | Out-Null

  # Save the login of whichever account was active (tokens refresh while in use).
  $active = if (Test-Path "$store\active") { (Get-Content "$store\active").Trim() } else { $null }
  if ($active -and (Test-Path $cred)) { Copy-Item $cred "$store\$active.credentials.json" -Force }

  # Put this account's login in place; none yet = Claude Code asks to log in once.
  if (Test-Path "$store\$Name.credentials.json") {
    Copy-Item "$store\$Name.credentials.json" $cred -Force
  } elseif (Test-Path $cred) {
    Remove-Item $cred -Force
  }
  Set-Content "$store\active" $Name

  claude @Rest

  # Save this account's (possibly refreshed, or brand-new) login.
  if (Test-Path $cred) { Copy-Item $cred "$store\$Name.credentials.json" -Force }
}

function claude-office   { Use-ClaudeAccount -Name office   -Rest $args }
function claude-personal { Use-ClaudeAccount -Name personal -Rest $args }

. $PROFILE

Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

PS> claude-office
    -> Claude Code asks you to log in -> use your office account
    -> /exit   (login saved to ~/.claude-accounts/office.credentials.json)

PS> claude-personal
    -> Claude Code asks you to log in -> use your personal account
    -> /exit   (login saved to ~/.claude-accounts/personal.credentials.json)

Setup: macOS / Linux

macOS, Linux and Git Bash

# Claude Code: several accounts, ONE shared config folder (~/.claude).
# Only the login file is swapped; logins live in ~/.claude-accounts/<name>.credentials.json.
_claude_account() {
  local name="$1"; shift
  local store="$HOME/.claude-accounts" cred="$HOME/.claude/.credentials.json"
  mkdir -p "$store" && chmod 700 "$store"
  local active=""; [ -f "$store/active" ] && active="$(tr -d '[:space:]' < "$store/active")"
  if [ -n "$active" ] && [ -f "$cred" ]; then cp -f "$cred" "$store/$active.credentials.json"; fi
  if [ -f "$store/$name.credentials.json" ]; then cp -f "$store/$name.credentials.json" "$cred"; else rm -f "$cred"; fi
  printf '%s\n' "$name" > "$store/active"
  claude "$@"
  [ -f "$cred" ] && cp -f "$cred" "$store/$name.credentials.json"
}
alias claude-office='_claude_account office'
alias claude-personal='_claude_account personal'

# macOS: the login lives in the Keychain, not in ~/.claude/.credentials.json.
_claude_account() {
  local name="$1"; shift
  local store="$HOME/.claude-accounts" svc="Claude Code-credentials"
  mkdir -p "$store" && chmod 700 "$store"
  local active=""; [ -f "$store/active" ] && active="$(tr -d '[:space:]' < "$store/active")"
  # Save the active account's current login out of the Keychain.
  if [ -n "$active" ]; then
    security find-generic-password -s "$svc" -w > "$store/$active.json.tmp" 2>/dev/null \
      && mv "$store/$active.json.tmp" "$store/$active.json" || rm -f "$store/$active.json.tmp"
  fi
  # Put this account's login into the Keychain; none yet = Claude Code asks to log in once.
  security delete-generic-password -s "$svc" >/dev/null 2>&1
  [ -f "$store/$name.json" ] && security add-generic-password -s "$svc" -a "$USER" -w "$(cat "$store/$name.json")"
  printf '%s\n' "$name" > "$store/active"
  claude "$@"
  security find-generic-password -s "$svc" -w > "$store/$name.json" 2>/dev/null || rm -f "$store/$name.json"
}
alias claude-office='_claude_account office'
alias claude-personal='_claude_account personal'

source ~/.bashrc   # or ~/.zshrc on macOS
claude-office      # log in once, then /exit
claude-personal    # log in once, then /exit

Using It Day To Day

Hit a limit, switch, keep going in the same chat

This is the part that made the setup worth it. Because conversations are stored per folder and not per account, a chat started on one account can be continued on another with all its context.

~/projects/api> claude-office
  > refactor the auth middleware to use the new session store
  ... an hour of work ...
  ! usage limit reached
  > /exit

~/projects/api> claude-personal --continue
  (same conversation, same context)
  > ok, carry on with the remaining two routes

Things To Know

What to watch out for

It is a small setup, but there are a few rules that keep it working.

Quick Answers

Questions people ask about this

Short answers to the things that come up most.

Can I use two Claude accounts in Claude Code at the same time?

Not with a single login slot, which is what Claude Code gives you: one credentials file, one active account. The setup here keeps a saved login per account and swaps the right one into place when you start a session, so switching is one command with no logout and no OTP. Use one account at a time. Two sessions running under different accounts at once would share the one credentials file and fight over it.

Why not just use CLAUDE_CONFIG_DIR for each account?

It works for logins, but it gives each account its own copy of everything else too: conversation history, project memory, settings, skills, CLAUDE.md, MCP servers. Your office account cannot resume a chat you started on your personal one, and every setting has to be made twice. The point of this setup is the opposite: one config folder that both accounts read, with only the login file swapped.

Where does Claude Code store the login?

On Windows and Linux it is a plain JSON file at ~/.claude/.credentials.json. On macOS it is stored in the login Keychain instead, so swapping a file does nothing there and the script has to swap the Keychain entry. Everything else, including conversations, lives under ~/.claude/projects and is shared by both accounts in this setup.

Do I lose my conversation when I switch accounts?

No. Conversations are stored on disk under ~/.claude/projects, keyed by the folder you were working in, not by the account. Exit the office session, run claude-personal --continue in the same folder, and the same conversation opens with its full context. Only the account paying for the next message changes.

Is it safe to keep saved logins in a folder?

Treat ~/.claude-accounts like a password store. The files hold OAuth tokens that act as your account. Keep the folder out of git, out of cloud-synced folders like OneDrive or Dropbox, and off shared machines. If a file ever leaks, log out of that account from claude.ai to revoke it.

How do I add a third account?

One more line in your profile, for example function claude-side { Use-ClaudeAccount -Name side -Rest $args } in PowerShell, or alias claude-side='_claude_account side' in bash. The first time you run it, Claude Code asks you to log in, and from then on the login is saved like the others.

References

Docs behind the setup

The setup only uses documented Claude Code behaviour: where it keeps its files, how it resumes conversations, and how its login works.