Keep the same chat when you switch Claude accounts

Short answer: Claude Code stores every chat as a file inside its config folder, so to continue one on another Claude account you resume that same session under the other account's config, by its transcript path. It works, with a few rough edges. Shuriken does it for you: a Claude Code chat moves on its next request, and the request that hit the limit is replayed on the new account.

Where your chat actually lives#

A Claude Code session is a file on your disk. By default, transcripts are JSONL files at ~/.claude/projects/<project>/<session-id>.jsonl, where <project> is your working directory's path with every character that isn't a letter or digit replaced by a dash (Claude Code docs: Manage sessions).

Two details matter for switching accounts:

• The config folder decides where sessions go. Set CLAUDE_CONFIG_DIR, and Claude Code stores settings, session history and plugins there instead of ~/.claude (Claude Code docs: Settings files). That's how most people run two accounts side by side, and it's also why the second account doesn't see the first one's chats in its picker.
• A session can be resumed by path. claude --resume <transcript-path> resumes the session stored in the .jsonl file at that absolute path (Claude Code docs: CLI reference).

Put those together and you have the manual route.

The manual route: resume the session under the other account#

Say your personal account just hit its limit and you set up a second config for work at ~/.claude-work (our guide to switching Claude accounts without logging out shows how).

1. Find the session file. Look in ~/.claude/projects/ for your project's folder; the newest .jsonl file in it is usually the chat you were just in.
2. Resume it under the work config, from the same project folder:

cd ~/code/my-app
CLAUDE_CONFIG_DIR=~/.claude-work claude --resume ~/.claude/projects/-Users-you-code-my-app/<session-id>.jsonl

3. Tell Claude to carry on. The conversation is back: messages, tool calls and results. Ask it to continue the task.

Three checks before you resume#

• Same folder. Run the resume from the same project directory the chat started in. The conversation is full of file paths, and they should still point at real files.
• Same model. A resumed session continues on the model it was using, with a few exceptions the docs list (Manage sessions). Make sure the other account's plan can use that model, or pick another with /model.
• Clean tree. If the agent was halfway through editing files when the limit hit, look at git status first. You'll want to know what it already changed before you ask it to carry on.

What breaks#

The conversation comes back. Some of what was running around it doesn't. The Claude Code docs list what a resumed session restores and what it doesn't (Manage sessions):

• The interrupted step isn't rerun. A tool call that was still running when the old process ended doesn't finish or get rerun. Claude sees it marked as cut off and is told to check whether it took effect before trying again.
• Background work is gone. Background subagents, background commands and workflows that ended with the old process show up as notes that they didn't finish.
• Launch flags aren't remembered. If the session depended on --mcp-config, --settings, --plugin-dir, --fallback-model or --add-dir, pass them again.
• The other config has its own setup. MCP servers, plugins and settings in your work config are whatever you put there, not what the personal one had. Expect to add and sign in to a few servers again.
• Two places writing one chat get messy. If the same session is resumed in two terminals without forking, messages from both interleave into one transcript. Pick one place to carry on.

None of this is a bug. Claude Code was built around one account per config. Moving a chat between accounts is something you're doing on top of it.

After a rate limit: wait, or move on#

When you hit a limit, you have two honest choices:

• Wait for the reset. Claude tells you when your limit comes back. The 5-hour session limit resets every five hours, and the weekly limit once a week (Claude Help Center: usage credits). Paying for usage credits keeps the same account going at API rates; our guide on what to do when you hit a Claude limit covers that.
• Move on to another account you own, with the manual route above or a tool that does it for you.

If you're going to move, move the chat, not just yourself. Starting a fresh session on the other account and pasting a summary loses the tool results, the file reads and the reasoning that got you here. Resuming keeps them.

How Shuriken keeps one chat#

Shuriken is a harness: it runs Claude Code, Codex, Gemini CLI and 60+ other agents on your own computers and servers. Each Claude account you add is a source, with its own sign-in. When the account in use reaches your switch point (99% by default, adjustable from 50% to 100%) or Claude reports a limit, here's what happens to a running chat.

Claude Code: on the next request, subagents included#

A Claude Code chat moves in the middle of the task, on its next request. Shuriken sits between Claude Code and the API, so when a request comes back with "limit reached", it doesn't let the turn die. It replays that request on the next account with the most room, and the turn carries on as if nothing happened.

Subagents and workflows started by that chat move with it. There's no new session, no resume and no "please continue". It's the same chat, with the same history, on your machine.

Other agents: at the end of the turn#

Codex, Gemini CLI and the other agents move when their current turn ends. The next turn starts on the new source, in the same chat. Slightly later than Claude Code, and just as hands-off.

You can see it happen#

Every move leaves a Switched to … card in the chat, right where it happened, with who took over and why, for example "Limit reached" or "Switch-at bar reached". If nothing can take the chat, you get one Paused card instead ("Paused: no Claude source has usage left"). Shuriken checks again every 15 minutes and continues as soon as any source frees up. Two settings change what "nothing" means: with Switch to API keys turned on (it's off by default), your API keys take over once every subscription is out; and an endpoint you added for Claude Code that serves another company's models can carry the chat on between turns, if it can read the chat's history.

What else comes along#

• MCP sign-ins. In Shuriken, an MCP sign-in belongs to the server, not to your Claude account. Switch accounts as often as you like and Linear still works. That's Global MCPs.
• Every device. Shuriken keeps one account in use per provider across all your computers and servers, so a chat on your build server and one on your laptop move together.
• The rules. How the next account is chosen, and who's never picked, is in How Shuriken picks the next account.

Use accounts you own#

All of this assumes the accounts are yours. Anthropic's consumer terms forbid sharing your login or making your account available to anyone else. Moving your own chat between your own accounts is a different thing from borrowing someone's. Our guide on multiple Claude accounts and the rules has the details.

The feature page for all of this is automatic source switching. If you'd rather never resume a chat by path again, download Shuriken.