DEV Community: Sebastian Balog

How to run multiple Claude accounts at once (Desktop + Claude Code), and why the obvious hacks break

Sebastian Balog — Mon, 12 Oct 2026 23:52:50 +0000

Disclosure up front: I build Claude Sessions Pro, a paid Mac app that does this. Most of this post is the free way to do it yourself, plus what I learned about why the DIY versions misbehave. The app gets one short section near the end.

If you have a company Claude account and a personal one, or one account per client, you've hit this: Claude Desktop is signed in to one account. To check the other one, you sign out, sign in, lose your place, and do it again an hour later.

Claude Code in the terminal has the same problem, just with a different config folder.

Here's how to fix it, from "free, two lines of shell" to "one click", and the gotchas nobody mentions until you've already set it up.

TL;DR

You want	Do this
Two Claude Code (CLI) accounts	`CLAUDE_CONFIG_DIR=~/.claude-work claude` for the second one
Two Claude Desktop windows, free	Start a second copy with `--user-data-dir` (commands below)
Separate Dock icons, ‚åò-Tab, Google sign-in that lands in the right window, survives updates	You need each account to be its own app, not just its own folder (see "Why the hacks break")

Why Claude Desktop can only hold one login

Claude Desktop is an Electron app, so it's Chromium underneath. Everything for the signed-in account (session cookies, settings, connectors, MCP config, the list of Claude Code sessions) lives in one user data directory:

macOS: ~/Library/Application Support/Claude
Windows: %APPDATA%\Claude (the Microsoft Store version redirects this into its package folder, under %LOCALAPPDATA%\Packages\Claude_‚Ä¶\LocalCache\Roaming\Claude)

One folder, one cookie jar, one login. Signing in to account B overwrites account A's session.

Your chats aren't lost when you switch; they live in your account on Anthropic's side. What you lose is time, context, and the ability to see both at once.

So every working solution comes down to the same idea: give each account its own data directory.

Claude Code (CLI): one environment variable

The CLI is the easy part. It reads its login and settings from a config directory, which you can override:

# second account, one-off
CLAUDE_CONFIG_DIR=~/.claude-work claude

Make it permanent with an alias in ~/.zshrc or ~/.bashrc:

alias claude-work='CLAUDE_CONFIG_DIR="$HOME/.claude-work" claude'
alias claude-personal='CLAUDE_CONFIG_DIR="$HOME/.claude-personal" claude'

Run claude-work once, log in with the work account, done. Each folder keeps its own login, history and settings. This works the same on macOS, Linux and Windows (in PowerShell: $env:CLAUDE_CONFIG_DIR="$HOME\.claude-work"; claude).

Claude Desktop on macOS: a second copy, for free

Chromium apps accept --user-data-dir, and Claude Desktop honors it. This starts a second, independent Claude next to your normal one:

open -n -a Claude --args --user-data-dir="$HOME/Library/Application Support/Claude-Work"

-n opens a new instance even though Claude is already running.
Everything after --args goes to Claude itself.

# ~/.zshrc
claude-profile() {
  local name="${1:?usage: claude-profile <name>}"
  open -n -a Claude --args --user-data-dir="$HOME/Library/Application Support/Claude-$name"
}

claude-profile Work
claude-profile ClientA

Want it clickable? Open Script Editor, paste do shell script "open -n -a Claude --args --user-data-dir=$HOME/Library/Application\\ Support/Claude-Work", then File ‚Üí Export ‚Üí File Format: Application. Drop it in the Dock.

That's the whole free method, and for a lot of people it's enough. Now the part the copy-paste guides skip.

Why the hacks break (the interesting part)

All of these come from one fact: to the operating system, both windows are still the same app.

1. One Dock icon, one ‚åò-Tab entry

macOS groups windows by bundle identifier (com.anthropic.claudefordesktop). Your two instances share it, so they share a Dock icon, a name, and a single ‚åò-Tab slot. You can't tell which window is which account without looking inside it.

A Script Editor launcher doesn't fix this. The launcher is its own app, but the Claude window it opens still belongs to Claude.

2. Google sign-in comes back to the wrong window

This one costs people the most time. When you click Continue with Google, Claude opens your browser. After you log in, the browser hands the result back through a claude:// link.

The OS routes that link to the app registered for claude://, not to the specific window that started the login. With two instances of the same app, the link goes to whichever instance the OS picks, usually the first one. So you sign in to your work account and it lands in your personal window, or nowhere useful.

On Windows it's even more deterministic. Chromium's single-instance logic means a new launch first checks for a lock file in the default data folder; if that instance is running, the link gets forwarded to it. So the default Claude window always wins.

Workarounds: use email sign-in for the extra profiles, or quit every other Claude window while you sign in to the new one.

3. Claude Code sessions don't follow you

The Code tab in Claude Desktop lists sessions from the data directory it's using. A fresh Claude-Work folder starts empty, even if that account has sessions in your main Claude. They aren't gone; they're in the other folder. You'd have to copy the right ones over by hand.

4. "Just copy Claude.app and rename it" doesn't survive updates

The natural next step is duplicating Claude.app, changing its bundle ID and name in Info.plist, and re-signing it, so each account really is a separate app with its own Dock icon. That does fix #1.

But Claude updates itself, and an update can bring back the original bundle or leave you with a copy that's stuck on an old version. Then you're redoing the copy, re-signing, and re-pointing it at the right data folder after every Claude release.

Claude Desktop on Windows: the same trick

Claude for Windows installs through the Microsoft Store, with a command alias you can call directly. In PowerShell:

Start-Process "$env:LOCALAPPDATA\Microsoft\WindowsApps\claude-desktop.exe" `
  -ArgumentList "--user-data-dir=`"$env:USERPROFILE\ClaudeProfiles\Work`""

Same rules as on the Mac: each --user-data-dir is a separate login. And the same gotchas apply:

All windows share one taskbar icon and the title "Claude".
Google sign-in returns to the default Claude window (see #2), so sign in to extra profiles with email, or close the main Claude first.
If Claude's own "start with Windows" setting is on, the default instance is always running and always catches the sign-in.

The other options, briefly

A second browser profile with claude.ai. Totally fine for chatting. You lose the desktop-only features for that account: the Code tab, local MCP servers and desktop connectors.
A second OS user account. Fully isolated, including Claude Code. But you only see one user's desktop at a time, and none of your files or apps come along.
Sign out and back in. Free and built in. Fine weekly, painful hourly.
Apps that do it for you. Parall (a general launcher for many apps, $9.99 in the Mac App Store), Multi-Claude ($20) and Claude Sessions Pro ($15) all turn each account into its own app.

What I built

I got tired of doing all of the above by hand, so I built Claude Sessions Pro for macOS. It makes each account a real, separate Mac app built from your installed Claude, which is what fixes the gotchas above:

Own app per account: "Claude Work", "Claude Personal", each with a colored letter badge on its Dock icon and its own ‚åò-Tab spot.
Google sign-in works with the other accounts still open, and returns to the profile that asked for it.
Claude Code sessions and pins come along: sessions from your main Claude move into the matching account's profile, and the CLI opens per profile with its own CLAUDE_CONFIG_DIR.
Survives Claude updates: when Claude updates, each profile app is rebuilt from the new version the next time it isn't running. Logins and data stay put.
Menu bar switcher to open or switch accounts.

It's $15 one-time for up to 2 computers, with a 1-hour free preview that starts once you've signed in to a profile. I'd rather you see it working with your own accounts before paying.

A Windows version is coming soon. Same idea, built for Windows' quirks: it routes Google sign-in to the right window and labels every window with its account. If you want to know when it ships, doubleclaude.com is where it'll land.

Here's the full comparison table with every method: How to run multiple Claude accounts on one Mac.

Is this allowed?

Plenty of people have legitimate separate accounts: a company Team account plus a personal Pro one, or one per client. Everything above runs the official Claude app and doesn't change how Claude works.

But Anthropic's terms apply to each account. Creating extra accounts specifically to dodge usage limits is the kind of thing that gets accounts suspended. Read the Consumer Terms and Usage Policy, and only use accounts you're allowed to use.

If you've found another approach (or another gotcha), drop it in the comments. I'm especially curious how people handle this on Linux, where Claude Desktop isn't official.

Stop Instagram and TikTok labelling your Photoshop and Premiere exports as AI

Sebastian Balog — Mon, 05 Oct 2026 01:58:20 +0000

Quick fix: the label comes from Content Credentials (C2PA) that Photoshop and Premiere Pro write into your export after a generative edit, and export settings don't switch them off. Check every file as it lands in your export folder and remove those credentials before posting: below is a free script that does it, and an app that does it for you on Mac and Windows.

Why your exports get labelled

If you edit for clients or post every day, the "AI info" problem isn't one photo. It's every export. One Generative Fill in Photoshop or two seconds of Generative Extend in Premiere Pro, and the file you deliver carries Content Credentials (C2PA) that Instagram, Facebook, TikTok, YouTube and LinkedIn read and turn into a label.

Adobe's own FAQ says that when its generative tools create or modify content, C2PA metadata is attached automatically and can't be switched off for that content. Photoshop's Export As → Metadata: None controls camera and copyright info, not that record. So the dependable place to check is the exported file, right after it lands in your export folder.

Here's how to automate that check yourself, and the gotchas that make it harder than it looks.

What to look for

Two markers do almost all the labelling:

C2PA manifest: JUMBF boxes labelled c2pa (in JPEG they sit in APP11 segments; in MP4/MOV in a top-level uuid box).
IPTC digital source type: Iptc4xmpExt:DigitalSourceType set to trainedAlgorithmicMedia or compositeWithTrainedAlgorithmicMedia.

A quick check for one file:

c2patool "export.jpg" >/dev/null 2>&1 && echo "C2PA manifest present"
exiftool -q -q -if '$XMP-iptcExt:DigitalSourceType =~ /TrainedAlgorithmic/i' -p '$FileName: AI source tag' "export.jpg"

A DIY watcher (macOS, fswatch)

#!/usr/bin/env bash
# watch-exports.sh: flag new exports that carry AI metadata
# needs: brew install fswatch exiftool c2patool
DIR="${1:-$HOME/Exports}"

settled() {               # wait until the editor has finished writing
  local f="$1" a b
  while :; do
    a=$(stat -f %z "$f" 2>/dev/null) || return 1
    sleep 2
    b=$(stat -f %z "$f" 2>/dev/null) || return 1
    [[ "$a" == "$b" ]] && return 0
  done
}

check() {
  local f="$1" hits=()
  c2patool "$f" >/dev/null 2>&1 && hits+=("C2PA")
  exiftool -q -q -if '$XMP-iptcExt:DigitalSourceType =~ /TrainedAlgorithmic/i' -p x "$f" | grep -q x && hits+=("IPTC AI tag")
  if ((${#hits[@]})); then
    osascript -e "display notification \"${hits[*]}\" with title \"AI metadata: $(basename "$f")\""
  fi
}

fswatch -0 -r -e '.*' -i '\.(jpe?g|png|mp4|mov)$' --event Created --event Updated "$DIR" |
while IFS= read -r -d '' f; do
  [[ "$(basename "$f")" == clean_* ]] && continue
  settled "$f" && check "$f"
done

It works, and it's a good way to see how often your exports actually carry these markers. The parts that take the most care:

"Finished writing" is the hard part. Premiere and Media Encoder write large files over minutes; Photoshop writes a temp file and renames it. The size-stable loop above is the simplest heuristic; a render that pauses mid-write can still fool it.
Recursion and noise. Editors create sidecar and cache files; filter by extension and ignore your own clean_ outputs or you'll loop.
Cleaning without damage. The naive exiftool -all= also deletes the colour profile and orientation. Use exiftool -all= -tagsfromfile @ -icc_profile -orientation file.jpg for photos, and a stream-copy remux for video: ffmpeg -i in.mp4 -map 0 -c copy -map_metadata -1 out.mp4.
Verifying. Re-run the checks on the output (c2patool should say No claim found), and for video compare ffmpeg -f streamhash of input and output.
Windows. No fswatch; you'd rebuild this around PowerShell's FileSystemWatcher.

The app version

I got tired of maintaining scripts like this, so it became a feature in MetaClean, my Mac and Windows metadata app. Watch Folders runs in the background on your export folders, subfolders included. Every new JPG, PNG, MP4 or MOV is checked once it has finished saving, whether it came from Photoshop, Lightroom, Premiere Pro or Media Encoder, CapCut or was just copied in. Files without AI metadata never interrupt you. When one carries Content Credentials or an AI-origin tag, a compact prompt lists what was found, and Clean saves a verified clean_ copy next to the original: no re-encoding, colour profile and orientation kept, video streams copied as they are. For existing archives there's a batch mode for whole folders. Everything stays on your machine. 3-day free trial, then $5 once.

Disclosure: I'm the developer of MetaClean.

TL;DR

Generative edits in Photoshop and Premiere attach C2PA automatically; export settings don't remove it.
Check exports with c2patool and the IPTC DigitalSourceType tag.
Automate with a folder watcher, but handle "file finished", recursion, safe cleaning and verification.
Or let MetaClean's Watch Folders do it on Mac and Windows.

How to remove the "AI-generated" label from your TikTok videos (CapCut fix)

Sebastian Balog — Mon, 05 Oct 2026 01:57:49 +0000

Quick fix: TikTok reads AI metadata inside the MP4, not your footage. Delete the labelled post, strip the metadata from your original export with one ffmpeg command (below, no re-encoding) or with MetaClean, and repost the clean copy with the AI-generated content switch off.

Here's why it happens, how to see it in your own files, and how to prove the fix didn't touch quality.

Why your real video got labelled

You film something yourself, add one AI effect in CapCut, export, post, and TikTok puts "AI-generated" on it. The footage is yours. The label disagrees.

Like Instagram's "AI info", TikTok's automatic label is mostly a metadata decision. TikTok has said it reads Content Credentials (C2PA) to label AI content automatically, and editing apps write AI markers into the files they export after an AI feature is used. So the useful question isn't "what does the video look like?" but "what does the MP4 say about itself?"

Where the label comes from

TikTok adds "AI-generated" in two ways:

You switch it on in the post settings ("AI-generated content").
Automatically, when the uploaded file carries AI metadata.

The second one is the surprise. Typical sources:

App or feature	What you did	What ends up in the file
CapCut AI features	AI effects, enhancements, generated elements	AI metadata in the export
Premiere Pro Generative Extend	Stretched a clip by a few frames	C2PA Content Credentials
AI video generators	B-roll, backgrounds, intros	C2PA Content Credentials
AI upscalers / enhancers	Sharpen, stabilise, upscale	C2PA or IPTC, depending on the app

One AI touch is enough for the whole video, because the note describes the file, not the frame.

Look inside the MP4

An MP4 is a tree of boxes (atoms). Regular metadata lives in moov/udta and meta; a C2PA manifest is stored as its own JUMBF payload in a top-level uuid box, next to the audio and video data rather than inside it. That's why the usual "Properties → Details" view doesn't show it.

Dump everything ExifTool can see, grouped by where it lives:

exiftool -a -G1 -s clip.mp4

Look for the encoder and creation tool (Encoder, Software, HandlerVendorID), any XMP block, and anything mentioning AI, AIGC or C2PA:

exiftool -a -G1 -s clip.mp4 | grep -iE 'c2pa|jumd|aigc|digitalsource|encoder|software'

For the signed manifest itself, the official c2patool reads MP4 and MOV directly:

c2patool clip.mp4
# prints the manifest: claim generator, actions, digitalSourceType...
# or "No claim found" if there is none

And while you're in there, check the stuff you probably didn't mean to share: phones write a recording location and the device model into the udta atoms.

exiftool -GPSCoordinates -Model -Make -CreationDate clip.mp4

Removing it without re-encoding

Re-exporting the video to "shake off" metadata costs quality and often writes the same markers again. The clean way is a remux: copy the existing video and audio streams into a new container and leave the metadata boxes behind.

ffmpeg -i clip.mp4 -map 0 -c copy -map_metadata -1 -movflags +faststart clean.mp4

-c copy means no decoding and no re-encoding: same frames, same bitrate.
-map_metadata -1 drops the global metadata (including the location and device atoms).
The C2PA uuid box isn't carried over by the remux.
+faststart moves the index to the front, which upload pipelines like.

Then prove it, because a clean-looking command isn't proof:

c2patool clean.mp4                    # should say: No claim found
exiftool -a -G1 -s clean.mp4 | grep -iE 'c2pa|jumd|aigc|gps'   # should print nothing

# and the streams are bit-for-bit identical:
ffmpeg -loglevel error -i clip.mp4  -map 0 -c copy -f streamhash -hash sha256 -
ffmpeg -loglevel error -i clean.mp4 -map 0 -c copy -f streamhash -hash sha256 -

If the two streamhash outputs match, the picture and sound are exactly what you exported.

Then repost: delete the labelled post (copy the caption and note the sound first), upload clean.mp4, and leave the AI-generated content switch off.

If you export from CapCut every day

Doing this per clip gets old fast. I built MetaClean for that: a Mac and Windows app that shows every piece of metadata in a video (or photo) in plain words, removes the AI markers, or location and device details too, and saves a verified clean_ copy next to the original, using the same stream-copy approach as above. Its Watch Folders mode sits on your CapCut export folder (subfolders included) and only pops up when a new export actually carries AI metadata: one click and the clean copy is ready to post. Everything runs locally; nothing is uploaded. 3-day free trial, then $5 once.

Disclosure: I'm the developer of MetaClean.

TL;DR

TikTok's automatic "AI-generated" label is read from the file's metadata, including C2PA Content Credentials.
See it: c2patool clip.mp4 and exiftool -a -G1 -s clip.mp4.
Remove it without touching quality: ffmpeg -i clip.mp4 -map 0 -c copy -map_metadata -1 clean.mp4, then verify with c2patool and streamhash.
Full TikTok walkthrough: How to remove the AI-generated label on TikTok.

Why Instagram labels your real photo "AI info" (and how to see the metadata behind it)

Sebastian Balog — Sat, 26 Sep 2026 20:46:48 +0000

You take a real photo, remove a stray object with a generative fill tool, post it, and Instagram adds "AI info" under your name. The picture is 99% camera, but the label says otherwise.

The label usually isn't about the pixels. It's about metadata the editing tool wrote into the file. Once you know where it lives, you can see it in seconds, and remove it without touching the image.

What the platforms read

Meta has said it labels images using industry-standard signals in the file. Two of them do most of the work:

1. C2PA Content Credentials. A signed manifest embedded in the file (in a JPEG it sits in APP11 segments as JUMBF boxes). It records which app made or edited the image and what it did: c2pa.opened, c2pa.edited, and, for AI tools, a digitalSourceType saying generative AI was involved. Photoshop, Firefly, ChatGPT's image generation and a growing list of phones and cameras write it.

2. The IPTC digital source type. A single XMP field, Iptc4xmpExt:DigitalSourceType, whose value is a URL from the IPTC vocabulary. The two that matter:

trainedAlgorithmicMedia: made with generative AI
compositeWithTrainedAlgorithmicMedia: edited with generative AI (your generative-fill case)

Either one is enough to earn the label.

See it in your own files

With ExifTool installed:

# The IPTC AI tag
exiftool -XMP-iptcExt:DigitalSourceType photo.jpg
# Digital Source Type : http://cv.iptc.org/newscodes/digitalsourcetype/compositeWithTrainedAlgorithmicMedia

# Is there a C2PA manifest? (JUMBF boxes labelled c2pa)
exiftool -a -JUMDLabel photo.jpg
# JUMD Label : c2pa
# JUMD Label : urn:c2pa:060ce687-...
# JUMD Label : c2pa.assertions

For the full, human-readable manifest (signer, actions, validation state), use the official c2patool:

c2patool photo.jpg

While you're in there, check what else the file carries. Most phones add GPS once the camera has location access:

exiftool -GPSPosition -Model -SerialNumber photo.jpg

No command line handy? I built a free in-browser EXIF and C2PA viewer that reads all of this, including the prompts Stable Diffusion and ComfyUI hide in PNGs. The file is read locally and never uploaded; switch off your Wi-Fi after the page loads and it still works.

Removing it (and the gotcha that bites everyone)

The classic one-liner does remove the C2PA manifest, the IPTC tag and your GPS:

exiftool -all= photo.jpg

But run it on a photo from a phone and look closely:

Warning: ICC_Profile deleted. Image colors may be affected - photo.jpg

-all= also deletes the colour profile and the orientation flag. iPhone photos are usually Display P3, so they come out duller, and portrait shots can come out sideways. The fix is to copy those two back from the original in the same command:

exiftool -all= -tagsfromfile @ -icc_profile -orientation photo.jpg

I tested both on a C2PA-signed, Display P3, rotated JPEG: the second command removed the manifest (c2patool reports No claim found), the IPTC tag and the GPS, kept the profile and rotation, and left the decoded pixels identical.

Then check your result, because a clean-looking command isn't proof:

exiftool -a -JUMDLabel -XMP-iptcExt:DigitalSourceType -GPSPosition photo.jpg   # should print nothing
c2patool photo.jpg                                                             # should say No claim found

If the label is already on a post, removing the metadata from your file isn't enough on its own: Instagram keeps the label on what it already published. I wrote up the full repost routine for feed posts, Reels, Stories and Facebook (including saving your caption first) in How to remove AI info from Instagram posts.

Doing this for a whole camera roll

For one JPEG, the ExifTool commands above are all you need. For folders full of photos and videos (where metadata lives in QuickTime atoms and its own C2PA box), I made MetaClean, a Mac and Windows app that does the whole thing offline. It bundles pinned versions of ExifTool, c2patool and FFmpeg, never re-encodes (video is remuxed with stream copy), keeps colour profiles and orientation, and re-inspects every output before saving it as clean_<name>, leaving the original untouched. There's a 3-day free trial, then it's $5 once.

Disclosure: I'm the developer of MetaClean and the viewer linked above.

TL;DR

"AI info" on a real photo usually comes from C2PA Content Credentials or the IPTC DigitalSourceType tag, not from the pixels.
See them: exiftool -XMP-iptcExt:DigitalSourceType -a -JUMDLabel photo.jpg, or c2patool photo.jpg.
Remove them without breaking the photo: exiftool -all= -tagsfromfile @ -icc_profile -orientation photo.jpg, then verify.
Already labelled? See how to remove AI info from Instagram.