# ccam અને બીજાં Claude Code એકાઉન્ટ સ્વિચર

> claude-swap, CCS, clausona, clauth, CAAM, cux અને Claude Code એકાઉન્ટ સ્વિચ કરવાનાં બીજાં ટૂલ સાથે ccam ની સરખામણી, અને કઈ રીત કયા ઉપયોગ માટે યોગ્ય છે.

Source: https://ccam.dev/gu/compare/account-switchers/ · Updated 2026-10-20

Claude Code એકાઉન્ટ સ્વિચ કરવાનાં ટૂલ બેમાંથી એક રીત અપનાવે છે. મોટા ભાગનાં ટૂલ એક જ `~/.claude` ફોલ્ડરની અંદર લૉગિન બદલે છે, તેથી એક સમયે એક જ એકાઉન્ટ સક્રિય રહે છે. બીજાં ટૂલ, જેમાં ccam પણ છે, `CLAUDE_CONFIG_DIR` વડે દરેક એકાઉન્ટને પોતાનું ફોલ્ડર આપે છે, તેથી દરેક એકાઉન્ટ લૉગિન રહે છે અને ઘણાં એકાઉન્ટ એકસાથે ચાલી શકે છે. ccam તેમાં શેર કરેલાં સેટિંગ્સ અને MCP સર્વર ઉમેરે છે, અને વાતચીતને બીજા એકાઉન્ટના ફોલ્ડરમાં ચાલુ રાખે છે.

## એક લૉગિન બદલવું કે અલગ ફોલ્ડર?

**લૉગિન બદલવાથી** સેટિંગ્સ, MCP સર્વર અને ઇતિહાસનો એક જ સેટ રહે છે, કારણ કે ફોલ્ડર એક જ છે. સ્વિચ કરવું ઝડપી છે, અને ચાલુ સેશન નવું લૉગિન અપનાવી શકે છે. પણ એક સમયે ફક્ત એક જ એકાઉન્ટ સક્રિય રહે છે, અને તે બધાં ટર્મિનલ અને એડિટર માટે એકસાથે લાગુ પડે છે.

લૉગિન બદલવા માટે ટૂલ બાકીના દરેક એકાઉન્ટના લૉગિનની એક નકલ રાખે છે અને જરૂર પડ્યે તેને યોગ્ય જગ્યાએ લખી દે છે. Claude Code લૉગિન રિન્યૂ કરતી વખતે તેમાંનું refresh token બદલી નાખે છે, તેથી દરેક સાચવેલી નકલને ચાલુ સેશન સાથે મેળમાં રાખવી પડે છે. સ્વિચ પછી લૉગઆઉટ થઈ જતાં કે ફરી `/login` માગતાં એકાઉન્ટ એ આ પ્રોજેક્ટ સૌથી વધુ સુધારે છે એવી સમસ્યાઓમાંની એક છે.

**અલગ ફોલ્ડર** એ રીત છે જે [Claude Code ના દસ્તાવેજીકરણમાં વર્ણવેલી છે](https://code.claude.com/docs/en/authentication#log-in-with-multiple-accounts). દરેક એકાઉન્ટ લૉગિન રહે છે, અને તમે કામનું અને અંગત સેશન સાથે-સાથે ચલાવી શકો છો. દરેક લૉગિન પોતાના ફોલ્ડરમાં જ રહે છે, જ્યાં Claude Code તેને હંમેશની જેમ રિન્યૂ કરે છે. તેની કિંમત એ છે કે દરેક ફોલ્ડર પોતાનાં સેટિંગ્સ, MCP સર્વર અને ઇતિહાસ સાથે શરૂ થાય છે, સિવાય કે કોઈ ટૂલ તેમને શેર કરે.

## ટૂલની સરખામણી

દરેક પ્રોજેક્ટના પોતાના દસ્તાવેજીકરણ અને સોર્સ કોડમાંથી 2026-10-20 ના રોજ લીધેલું (clausona: v0.12.0-beta). "દસ્તાવેજીકૃત નથી" નો અર્થ એ છે કે પ્રોજેક્ટ તેના વિશે કંઈ કહેતો નથી, એવો નહીં કે સુવિધા નથી.

| ટૂલ | રીત | એકસાથે ઘણાં એકાઉન્ટ | 5 કલાકનો અને સાપ્તાહિક વપરાશ | મર્યાદા આવે ત્યારે | પ્લેટફૉર્મ |
| --- | --- | --- | --- | --- | --- |
| ccam | અલગ ફોલ્ડર | હા | હા, `ccam usage` | સૌથી વધુ જગ્યાવાળા એકાઉન્ટમાં વાતચીત ચાલુ રાખવા તમે `ccam next --auto --continue` ચલાવો છો; `ccam --fallback` `-p` jobs ત્યાં જાતે ફરી ચલાવે છે, અને `ccam pick` workers ને જુદાં એકાઉન્ટમાં વહેંચે છે | Linux, macOS, Windows |
| [claude-swap](https://github.com/realiti4/claude-swap) | લૉગિન બદલે છે; `cswap run` વડે અલગ ફોલ્ડર | હા, `cswap run` વડે | હા | `cswap auto` નક્કી કરેલી હદે લૉગિન બદલે છે; ચાલુ સેશન ચાલુ રહે છે | Linux, macOS, Windows |
| [CCS](https://github.com/kaitranntt/ccs) | અલગ ફોલ્ડર | હા | અંશતઃ | એકાઉન્ટ પૂલ સ્થાનિક proxy દ્વારા request આગલા એકાઉન્ટને મોકલે છે | Linux, macOS, Windows |
| [clausona](https://github.com/larcane97/clausona) | અલગ ફોલ્ડર | હા | હા | દરેક run પહેલાં routes quota વાળું એકાઉન્ટ પસંદ કરે છે, reset ની રાહ જોઈ શકે છે, અને workers ને અલગ-અલગ એકાઉન્ટ આપે છે | Linux, macOS, Windows |
| [clauth](https://github.com/uwuclxdy/clauth) | લૉગિન બદલે છે; `clauth start` વડે અલગ ફોલ્ડર | હા, `clauth start` વડે | હા | fallback chain માં આગળના એકાઉન્ટ પર જાય છે | Linux, macOS, Windows |
| [CAAM](https://github.com/Dicklesworthstone/coding_agent_account_manager) | લૉગિન બદલે છે, અથવા અલગ પાડેલી પ્રોફાઇલ | હા, અલગ પાડેલી પ્રોફાઇલ વડે | હા | `caam run` non-interactive કમાન્ડ બીજા એકાઉન્ટ પર ફરી ચલાવે છે | Linux, macOS, Windows |
| [cux](https://github.com/inulute/cux) | લૉગિન બદલે છે અને `claude` ને wrap કરે છે | ના, એક જ સક્રિય એકાઉન્ટ | હા | લૉગિન બદલીને એ જ વાતચીત ફરી ચાલુ કરે છે | Linux, macOS, Windows |
| [CCSwitcher](https://github.com/XueshiQiao/CCSwitcher) | લૉગિન બદલે છે | ના | હા | નક્કી કરેલી હદે વૈકલ્પિક સ્વિચ | macOS |
| [Claude Switcher](https://github.com/Symbioose/claude-account-switcher) | લૉગિન બદલે છે | ના | હા | 100% પર વૈકલ્પિક સ્વિચ | macOS |

ccswap એ claude-swap નો fork છે, જે Codex લૉગિન પણ સંભાળે છે. [claude-account](https://github.com/hamzarehmandeveloper/claude-account), [claude-multiprofile](https://github.com/jmdarre-v/claude-multiprofile) અને [claude-code-profiles](https://github.com/quinnjr/claude-code-profiles) પણ દરેક એકાઉન્ટને પોતાનું ફોલ્ડર આપે છે. આમાંનાં કેટલાંક ટૂલ Codex કે Gemini જેવા બીજા coding agents પણ સંભાળે છે.

## તે કેવી રીતે બનેલાં છે

| ટૂલ | કઈ ભાષામાં લખાયેલું | Claude Code ચાલે ત્યારે | લૉગિનની એક જગ્યાએથી બીજે નકલ કરે છે | એકાઉન્ટ શું શેર કરી શકે |
| --- | --- | --- | --- | --- |
| ccam | Go, એક static binary | કંઈ નહીં: ccam પોતાની જગ્યા `claude` ને આપી દે છે (Windows પર, જ્યાં આ શક્ય નથી, તે તેની રાહ જુએ છે) | ના | દરેક આઇટમ અલગથી: દરેક એકાઉન્ટ માટે local કે નામવાળું group |
| claude-swap | Python 3.12+, uv કે pipx વડે ઇન્સ્ટોલ | `cswap run` સાથે કંઈ નહીં; `cswap auto` અને મેનુ બાર ઍપ ચાલુ રહે છે | હા, જ્યારે લૉગિન બદલે ત્યારે | `cswap run` સાથે: સેટિંગ્સ, `CLAUDE.md` અને extensions એકસાથે, ઇતિહાસ વૈકલ્પિક; દરેક લૉન્ચ વખતે MCP સર્વરની નકલ થાય છે |
| CCS | Node.js 18+ કે Bun | CCS parent process તરીકે રહે છે; પૂલ સ્થાનિક proxy ઉમેરે છે | તેનાં એકાઉન્ટ ફોલ્ડર માટે ના; પૂલ પોતાનાં લૉગિન રાખે છે | દરેક એકાઉન્ટ માટે શેર કરેલું કે local, ઇતિહાસ context group માં; MCP સર્વરની નકલ થાય છે |
| clausona | TypeScript, Node.js 20+ | સાદું `claude` એક shell function દ્વારા ચાલે છે; `clausona run` Node ને parent તરીકે રાખે છે; દરેક exit પછી એક background Node process | ના, પણ વપરાશ વાંચવા માટે તે નિષ્ક્રિય એકાઉન્ટના tokens જાતે રિન્યૂ કરે છે | એકાઉન્ટની પોતાની ફાઇલો સિવાય બધું, એક primary માંથી; ઇતિહાસ વૈકલ્પિક; `claude mcp add` વડે ઉમેરેલા સર્વર શેર થતા નથી |
| clauth | Rust | clauth parent process તરીકે રહે છે | હા, જ્યારે લૉગિન બદલે ત્યારે | આખું `~/.claude`, અથવા કંઈ નહીં |
| CAAM | Go | મોડ પર આધાર રાખે છે; એક વૈકલ્પિક daemon | હા, તેના vault મોડમાં | મોડ પ્રમાણે નક્કી; દરેક લૉન્ચ વખતે MCP સર્વરની નકલ થાય છે |
| cux | Go | `claude` ની આસપાસ એક wrapper રહે છે | હા | બધું: એક જ ફોલ્ડર |
| CCSwitcher, Claude Switcher | macOS ઍપ (Swift, Python) | મેનુ બાર ઍપ | હા | બધું: એક જ ફોલ્ડર |

## ccam શું સારું કરે છે

### લૉગિન ત્યાં જ રહે છે જ્યાં Claude Code એ મૂક્યાં

ccam ક્યારેય Claude લૉગિનની એક જગ્યાએથી બીજે નકલ કરતું નથી. દરેક એકાઉન્ટનું લૉગિન તેના પોતાના ફોલ્ડરમાં રહે છે, અથવા macOS પર તે ફોલ્ડરની પોતાની Keychain આઇટમમાં, અને તેને રિન્યૂ કરનાર પ્રોગ્રામ Claude Code છે. મેળ ગુમાવી શકે એવી કોઈ સાચવેલી નકલ નથી. હાલનું `~/.claude`, જે `ccam import` વડે નોંધાયેલું છે, એ જ Keychain આઇટમ રાખે છે જે સાદું `claude` વાપરે છે, તેથી બંને રીતે તે લૉગિન રહે છે.

ccam સમયસીમા વીતેલું token જાતે ફક્ત ત્યારે જ રિન્યૂ કરે છે જ્યારે તમે `ccam usage --refresh` ચલાવો. તે પહેલાં lock લે છે અને તે એકાઉન્ટ ચાલતું હોય તો ના પાડે છે, તેથી ચાલુ સેશનની નીચેથી તે ક્યારેય token બદલતું નથી.

### તમારી અને Claude Code ની વચ્ચે કંઈ ચાલતું નથી

ccam એક ફાઇલ વાંચે છે, તેની લિંક તપાસે છે અને પોતાની જગ્યા `claude` ને આપી દે છે (`exec`). તમે કામ કરો ત્યારે કોઈ ccam process, wrapper, proxy કે daemon હોતાં નથી: standard input, signals અને exit code Claude Code નાં છે, અને તેની request સીધી Anthropic સુધી જાય છે. Windows process ને બદલી શકતું નથી, તેથી ત્યાં ccam એ જ console સાથે Claude Code શરૂ કરે છે અને તેના exit code ની રાહ જુએ છે, બીજું કંઈ કરતું નથી.

આ રીતે એકાઉન્ટ શરૂ કરવાથી લગભગ 4 ms ઉમેરાય છે, 95મા percentile પર 6 ms થી ઓછો, અને peak memory 8 MB ([`scripts/perf-check.sh`](https://github.com/jhyunwoo/ccam/blob/main/scripts/perf-check.sh) hyperfine સાથે, 300 વખત ચલાવીને). એ જ laptop પર, કોઈ પ્રોગ્રામ કંઈ કરે તે પહેલાં જ, ફક્ત Python interpreter શરૂ થવામાં 13 ms અને Node.js માં 31 ms લાગે છે.

### આઇટમ પ્રમાણે, એકાઉન્ટ પ્રમાણે શેર કરો

MCP સર્વર, `settings.json`, `CLAUDE.md`, extensions (agents, commands, skills, plugins) અને વાતચીતનો ઇતિહાસ પાંચ અલગ આઇટમ છે. દરેક એકાઉન્ટ દરેક આઇટમને `local` કે કોઈ group પર સેટ કરે છે, તેથી બે કામનાં એકાઉન્ટ `work` group માં ઇતિહાસ શેર કરી શકે છે જ્યારે અંગત એકાઉન્ટ પોતાનો ઇતિહાસ અલગ રાખે છે, અને ત્રણેય એ જ MCP સર્વર શેર કરે છે.

- MCP સર્વર લૉન્ચ વખતે `--mcp-config` વડે આપવામાં આવે છે, તેથી ડિફૉલ્ટ રીતે ccam ક્યારેય `.claude.json` માં ફેરફાર કરતું નથી, જે ફાઇલ Claude Code ચાલતી વખતે ફરી લખે છે. `ccam mcp add` આખા group માટે એક જ વાર સર્વર ઉમેરે છે.
- બાકીની આઇટમ group ફોલ્ડર તરફની લિંક છે, તેથી એક એકાઉન્ટમાં કરેલો ફેરફાર તરત બીજાંમાં દેખાય છે. લૉન્ચ વખતે કંઈ નકલ થતું નથી.
- લૉગિન, `.claude.json` અને ચાલુ સ્થિતિ ક્યારેય શેર થતાં નથી.

### દરેક ફેરફાર પહેલાં બતાવાય છે અને તેનો backup લેવાય છે

`ccam share` અને `ccam migrate` કંઈ પણ ખસેડતાં પહેલાં યોજના બતાવે છે અને પૂછે છે. કોઈ ફાઇલ એકાઉન્ટ અને તેના group વચ્ચે અલગ હોય ત્યારે તમે પસંદ કરો છો: group ની રાખવી, તમારી વાપરવી, કે JSON merge કરવું. મૂળ ફાઇલો `.ccam-backup/<time>/` માં જાય છે, કાઢી નાખેલા એકાઉન્ટનું ફોલ્ડર trash ફોલ્ડરમાં જાય છે, અને ફાઇલો એક જ rename માં બદલાય છે, તેથી અધવચ્ચે અટકેલું લખાણ જૂની ફાઇલને જેમ છે તેમ રાખે છે. `--dry-run` બતાવે છે કે લૉન્ચ, શેરિંગ, migration, shortcuts, updates અને સમારકામ શું કરશે. `ccam doctor --fix` તૂટેલી લિંક અને permissions સુધારે છે.

### આગલા એકાઉન્ટમાં એ જ વાતચીત

શેર કરેલા ઇતિહાસ સાથે, `ccam next --auto --continue` બધાં એકાઉન્ટને એકસાથે તેમનો વપરાશ પૂછે છે, સૌથી વધુ જગ્યાવાળું એકાઉન્ટ ખોલે છે અને વાતચીત ચાલુ રાખે છે. ક્યારે સ્વિચ કરવું તે તમે નક્કી કરો છો; ccam બૅકગ્રાઉન્ડમાં તમારા વપરાશ પર નજર રાખતું નથી. કોઈ એકાઉન્ટ 90% પર પહોંચે એટલે સ્ટેટસ લાઇન આ command સૂચવે છે.

Scripts તમારી રાહ જોઈ શકતી નથી, તેથી `ccam --fallback work -p "…"` તેમના માટે સ્વિચ કરે છે: એકાઉન્ટ તેની મર્યાદાએ પહોંચે ત્યારે એ જ command સૌથી વધુ જગ્યાવાળા એકાઉન્ટ તરીકે ફરી ચાલે છે, અને ફક્ત પૂરા થયેલા run નું output છપાય છે. વપરાશ મર્યાદા સિવાયની નિષ્ફળતા જેમ છે તેમ આગળ આપવામાં આવે છે. સમાંતર workers માટે, `ccam pick` દરેકને જગ્યાવાળું જુદું એકાઉન્ટ આપે છે, અને કોઈ એકાઉન્ટમાં જગ્યા ન બચે ત્યારે બંને code 75 સાથે બહાર નીકળે છે.

### દરેક ફોલ્ડરમાં યોગ્ય એકાઉન્ટ

`ccam folder work ~/code/company` તે ફોલ્ડરની અંદર એકાઉન્ટના નામ વગરના દરેક લૉન્ચને `work` વાપરતું કરે છે, જ્યારે તમારા બાકીના પ્રોજેક્ટ ડિફૉલ્ટ એકાઉન્ટ જ વાપરે છે. આ સેટિંગ એ જ `config.toml` માં રહે છે જે દરેક લૉન્ચ વાંચે છે, તેથી તેમાં કોઈ સમય લાગતો નથી.

### એક binary, ચકાસેલાં downloads

ccam Linux, macOS અને Windows માટે લગભગ 10 MB ની static binary છે, અને તેના માટે કોઈ runtime ઇન્સ્ટોલ કરવો પડતો નથી. install scripts (`install.sh`, `install.ps1`) અને `ccam update` દરેક download ને release નાં SHA-256 checksums સાથે ચકાસે છે, અને ccam ક્યારેય જાતે updates શોધતું નથી. તેમાં કોઈ telemetry નથી: તે ફક્ત તમારાં એકાઉન્ટનો વપરાશ જાણવા Anthropic ને request મોકલે છે, સમાંતર રીતે, 3 સેકન્ડની મર્યાદા અને 60 સેકન્ડના cache સાથે, અને તમે માગેલાં downloads કરે છે.

## બીજાં ટૂલ ક્યાં વધુ કરે છે

- કોઈ એકાઉન્ટ વપરાશની હદ વટાવે ત્યારે claude-swap, clauth, cux, CAAM અને CCSwitcher ચાલુ interactive સેશનને જાતે સ્વિચ કરી શકે છે. ccam `-p` runs ને `--fallback` વડે સ્વિચ કરે છે અને interactive સેશન તમારા પર છોડે છે.
- Developer Mode વગરના Windows પર ccam ફોલ્ડર શેર કરે છે પણ `settings.json` જેવી એકલી ફાઇલો શેર કરી શકતું નથી; claude-swap અને CCS ત્યાં તેની નકલ કરે છે.
- CCSwitcher, Claude Switcher અને claude-swap macOS મેનુ બારમાં વપરાશ બતાવે છે.
- CCS, clausona, CAAM, clauth, ccswap અને Claude Switcher, Codex અને બીજા coding agents પણ સંભાળે છે.
- clausona એકાઉન્ટ પ્રમાણે extensions ચાલુ-બંધ પણ કરે છે (ccam નું `ccam ext` તેમને ફક્ત બતાવે છે), સ્થાનિક token ખર્ચ નોંધે છે, અને tmux તથા બીજાં ટર્મિનલમાં workers નો કાફલો ચલાવતાં Claude Code plugins આપે છે.
- CAAM, CCSwitcher અને Claude Switcher Homebrew વડે ઇન્સ્ટોલ થાય છે, અને clauth અને CAAM તેમનાં release checksums પર સહી કરે છે. ccam તેની script, `.deb` કે `go install` વડે ઇન્સ્ટોલ થાય છે, અને સહી વગર checksums ચકાસે છે.

## કયું યોગ્ય છે?

જો તમે એક સમયે એક જ એકાઉન્ટ વાપરતા હો કે ચાલુ સેશન આપમેળે સ્વિચ થાય એવું ઇચ્છતા હો, તો લૉગિન બદલતું ટૂલ પસંદ કરો. જો તમને એકાઉન્ટ સાથે-સાથે, એક જ શેર કરેલું સેટઅપ, આગલા એકાઉન્ટમાં એ જ વાતચીત અને Claude Code ની બાજુમાં બીજું કંઈ ન ચાલે એવું Linux, macOS કે Windows પર જોઈતું હોય, તો ccam પસંદ કરો. જો કંઈ શેર કરવાની જરૂર ન હોય, તો [સાદા શેલ alias](https://ccam.dev/gu/compare/aliases.md) પૂરતા છે.

તમે ઘણાં એકાઉન્ટ વાપરી શકો કે નહીં, તે દરેક એકાઉન્ટની શરતો પર આધાર રાખે છે. તેમ કરતાં પહેલાં શરતો તપાસો.