How to Set Up Multiple Claude Code Accounts for Marketing Agency Client Management

TL;DR

• Use Claude Code's scope system: Managed → User → Project → Local settings create a flexible hierarchy for multi-client management
• Separate config directories: Create ~/.claude-configs/client-name/ for each client to ensure complete isolation
• Environment variable switching: Use CLAUDE_HOME with shell aliases for instant context switching between clients
• Project-level isolation: Put .claude/settings.json in each repository for team-shared configs, .claude/settings.local.json for personal overrides
• Secure credential management: Use apiKeyHelper scripts instead of hardcoding API keys in configuration files
• Permission boundaries: Leverage the permissions system to deny cross-client file access and restrict dangerous operations
• Automation wins: Create shell scripts and git hooks to automatically detect and switch client configurations based on project directory
• Session isolation: Each config directory maintains separate session history, auto-memory, and authentication state
• Managed settings for agencies: Deploy agency-wide security policies via MDM (macOS), Group Policy (Windows), or /etc/claude-code/ (Linux)
• Audit everything: Enable OpenTelemetry logging with client-specific headers for compliance and billing tracking

Managing multiple clients as a marketing agency comes with unique challenges—especially when you're using AI-powered development tools like Claude Code. Each client deserves isolated environments, secure data handling, and context-specific configurations. This comprehensive guide shows you exactly how to set up multiple Claude Code accounts and configurations to keep your agency's client work organized, secure, and efficient.

Why Marketing Agencies Need Multiple Claude Code Configurations

The Client Separation Problem

Marketing agencies juggling multiple clients face a constant challenge: context switching. When you're building a landing page for Client A in the morning and debugging email automation for Client B in the afternoon, you need clean separation between projects. Without proper account isolation, you risk:

• Cross-contamination of code contexts: Claude Code learns from your project structure and codebase. Mixing client contexts means Claude might suggest Client A's proprietary solutions when working on Client B's project.
• Credential leakage: API keys, database credentials, and authentication tokens stored in one client's environment could accidentally appear in another's codebase.
• Billing confusion: When multiple clients share a single Claude Code configuration, tracking usage and costs becomes a nightmare.

Managing multiple Claude accounts isn't just about convenience—it's about maintaining professional boundaries and protecting client confidentiality.

Data Privacy and Security Requirements

Client data is sacred. Marketing agencies often handle sensitive information: customer databases, proprietary marketing strategies, unreleased product details, and financial data. A single misconfigured Claude Code session could expose one client's data to another.

Proper multi-account management ensures:

• Each client's codebase remains isolated
• API keys and credentials never cross client boundaries
• Session history and auto-memory features don't leak information between projects
• Compliance requirements (GDPR, CCPA, SOC 2) are maintained through proper data segregation

Context Switching Efficiency

Beyond security, there's productivity. Switching between client projects means changing:

• Authentication credentials
• Project-specific instructions and coding standards
• Custom MCP (Model Context Protocol) servers
• Approved tools and permissions
• Git configurations and commit attribution

Without a systematic approach to manage multiple Claude Code profiles, you'll waste hours reconfiguring settings every time you switch clients. The right setup lets you jump between client contexts in seconds, not minutes. This is where using an ai marketing workspace approach can streamline your daily operations by keeping contexts cleanly separated.

Method 1: Configuration Scope System for Multi-Client Management

Claude Code uses a powerful scope system that determines where configurations apply and who they're shared with. Understanding these scopes is the foundation for managing multiple client accounts effectively.

What Are Configuration Scopes and How They Work

Claude Code organizes settings into four hierarchical scopes:

1. Managed scope (highest priority): Server-managed settings deployed by IT/DevOps that cannot be overridden
2. User scope: Personal settings stored in `~/.claude/` that apply across all projects
3. Project scope: Team-shared settings in `.claude/` within the repository
4. Local scope (most specific): Personal overrides in `.claude/settings.local.json` that apply only to the current project

This hierarchy means more specific scopes override broader ones. A permission denied in project settings will block access even if it's allowed in user settings.

Step-by-Step: Creating Client-Specific Configurations

For macOS and Linux:

Create a dedicated configuration directory for each client:

# Create client-specific configuration directories
mkdir -p ~/.claude-configs/client-a
mkdir -p ~/.claude-configs/client-b
mkdir -p ~/.claude-configs/client-c

# Copy your base configuration as a starting point
cp -r ~/.claude/* ~/.claude-configs/client-a/

For Windows PowerShell:

# Create client-specific configuration directories
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.claude-configs\client-a"
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.claude-configs\client-b"
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.claude-configs\client-c"

# Copy base configuration
Copy-Item -Path "$env:USERPROFILE\.claude\*" -Destination "$env:USERPROFILE\.claude-configs\client-a\" -Recurse

Creating Project-Level Isolation

For each client project, leverage the project scope by creating a `.claude/` directory in the repository root:

cd /path/to/client-a-project

# Create project-specific Claude configuration
mkdir -p .claude

# Create settings.json for team-shared configurations
cat > .claude/settings.json << 'EOF'
{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": 
      "Bash(npm run build)",
      "Bash(npm test)",
      "Read(./src/**)"
    ,
    "deny": 
      "Read(./.env)",
      "Read(./.env.*)",
      "Bash(curl *)"
    
  },
  "attribution": {
    "commit": "Generated by ClientA Marketing Team",
    "pr": "Automated by Claude Code for ClientA"
  }
}
EOF

# Create local settings for personal overrides
cat > .claude/settings.local.json << 'EOF'
{
  "model": "claude-sonnet-4-6",
  "effortLevel": "medium"
}
EOF

# Ensure local settings are gitignored
echo ".claude/settings.local.json" >> .gitignore

This approach ensures team members share core project settings while maintaining personal preferences locally.

Managing Authentication Per Client

Each client needs isolated authentication. Create client-specific settings files:

{
  "forceLoginMethod": "console",
  "forceLoginOrgUUID": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "apiKeyHelper": "/path/to/client-a-key-generator.sh"
}

The `apiKeyHelper` setting lets you specify a custom script that generates authentication values dynamically, perfect for rotating credentials or using client-specific API key management systems.

Method 2: Environment Variable Configuration

Environment variables provide a flexible way to manage multiple Claude Code sessions simultaneously without modifying configuration files.

Using Custom Configuration Directories

The most powerful approach is creating entirely separate configuration directories for each client and using shell aliases or scripts to switch between them.

macOS/Linux/WSL Setup:

# Add to your ~/.bashrc or ~/.zshrc
export CLAUDE_CONFIG_CLIENT_A="$HOME/.claude-configs/client-a"
export CLAUDE_CONFIG_CLIENT_B="$HOME/.claude-configs/client-b"
export CLAUDE_CONFIG_CLIENT_C="$HOME/.claude-configs/client-c"

# Create aliases for quick switching
alias claude-a='CLAUDE_HOME="$CLAUDE_CONFIG_CLIENT_A" claude'
alias claude-b='CLAUDE_HOME="$CLAUDE_CONFIG_CLIENT_B" claude'
alias claude-c='CLAUDE_HOME="$CLAUDE_CONFIG_CLIENT_C" claude'

Windows PowerShell Setup:

# Add to your PowerShell profile ($PROFILE)
$env:CLAUDE_CONFIG_CLIENT_A = "$env:USERPROFILE\.claude-configs\client-a"
$env:CLAUDE_CONFIG_CLIENT_B = "$env:USERPROFILE\.claude-configs\client-b"
$env:CLAUDE_CONFIG_CLIENT_C = "$env:USERPROFILE\.claude-configs\client-c"

# Create functions for quick switching
function Claude-A { 
    $env:CLAUDE_HOME = $env:CLAUDE_CONFIG_CLIENT_A
    claude $args 
}

function Claude-B { 
    $env:CLAUDE_HOME = $env:CLAUDE_CONFIG_CLIENT_B
    claude $args 
}

function Claude-C { 
    $env:CLAUDE_HOME = $env:CLAUDE_CONFIG_CLIENT_C
    claude $args 
}

Creating Aliases for Quick Switching

Enhance your workflow with intelligent alias functions that automatically switch to the correct configuration based on your current directory:

# Advanced auto-detection alias
function claude-auto() {
    local current_dir=$(pwd)
    
    case "$current_dir" in
        */clients/client-a/*|*/client-a-*)
            echo "🔵 Switching to Client A configuration..."
            CLAUDE_HOME="$CLAUDE_CONFIG_CLIENT_A" claude "$@"
            ;;
        */clients/client-b/*|*/client-b-*)
            echo "🟢 Switching to Client B configuration..."
            CLAUDE_HOME="$CLAUDE_CONFIG_CLIENT_B" claude "$@"
            ;;
        */clients/client-c/*|*/client-c-*)
            echo "🟡 Switching to Client C configuration..."
            CLAUDE_HOME="$CLAUDE_CONFIG_CLIENT_C" claude "$@"
            ;;
        *)
            echo "⚪ Using default Claude configuration..."
            claude "$@"
            ;;
    esac
}

# Make it your default
alias claude='claude-auto'

Method 3: Managing Multiple Sessions Simultaneously

Marketing agencies often need to run multiple Claude Code sessions in parallel—reviewing code for one client while another session handles automated testing. This is where ai agents for agencies can truly shine, enabling teams to efficiently juggle client work and maintain clear separation at scale.

Creating Isolated Session Directories

Each Claude Code configuration maintains its own session history, auto-memory, and state. By using separate configuration directories, you automatically get isolated sessions:

# Terminal 1: Working on Client A
CLAUDE_HOME="$HOME/.claude-configs/client-a" claude

# Terminal 2: Simultaneously working on Client B
CLAUDE_HOME="$HOME/.claude-configs/client-b" claude

# Terminal 3: Client C emergency fix
CLAUDE_HOME="$HOME/.claude-configs/client-c" claude

Avoiding Authentication Conflicts

When running multiple Claude Code instances, authentication conflicts can occur. Here's how to prevent them:

Use different authentication methods per client:

{
  "forceLoginMethod": "claudeai",
  "forceLoginOrgUUID": "client-a-org-uuid"
}

For API-based authentication:

{
  "apiKeyHelper": "/usr/local/bin/get-client-a-key.sh",
  "env": {
    "ANTHROPIC_API_KEY": "${CLIENT_A_API_KEY}"
  }
}

Session isolation checklist:

• ✅ Each client has a unique configuration directory
• ✅ Authentication credentials are client-specific
• ✅ Session history files (.jsonl) are stored separately
• ✅ MCP server configurations don't overlap
• ✅ Auto-memory directories are isolated

Managing Session History and Auto-Memory

Claude Code stores session transcripts and auto-memory in the configuration directory. Control this with the `autoMemoryDirectory` setting:

{
  "autoMemoryDirectory": "~/client-a-memory",
  "cleanupPeriodDays": 90
}

For clients with strict data retention policies, you can disable session persistence entirely:

{
  "cleanupPeriodDays": 0
}

This deletes all transcripts at startup and prevents new session files from being written—perfect for handling sensitive client work.

Security Best Practices for Multi-Client Setups

API Key Management and Storage

Never hardcode API keys in configuration files. Use secure storage mechanisms:

Option 1: Environment-based key management

# Store in a secure environment file (never commit to git)
echo "CLIENT_A_API_KEY=sk-ant-..." > ~/.claude-configs/client-a/.env
echo "CLIENT_B_API_KEY=sk-ant-..." > ~/.claude-configs/client-b/.env

# Load before running Claude
source ~/.claude-configs/client-a/.env && claude

Option 2: Use a key management script

{
  "apiKeyHelper": "/usr/local/bin/fetch-client-key.sh"
}

Create the helper script:

#!/bin/bash
# /usr/local/bin/fetch-client-key.sh

# Fetch from secure vault (e.g., 1Password, AWS Secrets Manager)
op read "op://Engineering/client-a-claude-key/credential"

Make it executable:

chmod +x /usr/local/bin/fetch-client-key.sh

Preventing Cross-Client Data Access

Use Claude Code's permission system to enforce strict boundaries:

{
  "permissions": {
    "deny": 
      "Read(../**)",
      "Bash(cd ../*)",
      "Read(~/.claude-configs/**)",
      "Read(/path/to/other/clients/**)"
    ,
    "allow": 
      "Read(./src/**)",
      "Read(./tests/**)",
      "Bash(npm run *)",
      "Bash(git *)"
    
  }
}

This configuration:

• Blocks access to parent directories
• Prevents reading other client configuration directories
• Explicitly allows only necessary operations
• Uses allowlist approach for maximum security

Audit Logging for Compliance

For agencies handling regulated industries (healthcare, finance), implement comprehensive audit logging:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://your-logging-service.com"
  },
  "otelHeadersHelper": "/usr/local/bin/generate-audit-headers.sh"
}

Create an audit header script:

#!/bin/bash
# generate-audit-headers.sh

cat << EOF
x-client-id: client-a
x-user-id: $(whoami)
x-session-timestamp: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
x-project-path: $(pwd)
EOF

This captures:

• Which client's configuration was used
• Who initiated the session
• When the session started
• Where the work was performed

Troubleshooting Common Multi-Account Issues

"Session already in use" Errors

This occurs when multiple Claude Code instances try to use the same configuration directory simultaneously.

Solution: Verify configuration isolation

# Check which config directory is active
echo $CLAUDE_HOME

# Ensure each terminal uses a different config
ps aux | grep claude

Quick fix:

# Kill existing sessions
pkill -f "claude"

# Restart with explicit config path
CLAUDE_HOME="$HOME/.claude-configs/client-a" claude

Authentication Loop Problems

If Claude Code repeatedly asks you to authenticate:

Check 1: Verify authentication file permissions

# macOS/Linux
ls -la ~/.claude-configs/*/
chmod 600 ~/.claude-configs/*/.claude.json

# Windows
icacls "$env:USERPROFILE\.claude-configs\client-a\.claude.json"

Check 2: Validate organization UUID

{
  "forceLoginMethod": "console",
  "forceLoginOrgUUID": "verify-this-uuid-is-correct"
}

Get the correct UUID from your Claude Console organization settings.

Check 3: Clear authentication cache

# Backup first
cp ~/.claude-configs/client-a/.claude.json ~/.claude-configs/client-a/.claude.json.backup

# Remove auth section and re-authenticate
claude --config ~/.claude-configs/client-a

File Permission Conflicts

Permission errors often stem from misconfigured ownership or access rights.

macOS/Linux fix:

# Fix ownership
sudo chown -R $(whoami):$(whoami) ~/.claude-configs/

# Set correct permissions
chmod -R 700 ~/.claude-configs/
find ~/.claude-configs/ -type f -name "*.json" -exec chmod 600 {} \;

Windows PowerShell fix:

# Take ownership
takeown /F "$env:USERPROFILE\.claude-configs" /R /D Y

# Grant full control
icacls "$env:USERPROFILE\.claude-configs" /grant:r "$env:USERNAME:(OI)(CI)F" /T

Automating Account Switching with Scripts

Creating a Client Switcher Script

Build a sophisticated client switcher that handles all configuration details:

#!/bin/bash
# claude-switch.sh - Intelligent client configuration switcher

set -euo pipefail

CONFIGS_DIR="$HOME/.claude-configs"
CURRENT_CLIENT_FILE="$HOME/.claude-current-client"

show_usage() {
    cat << EOF
Usage: claude-switch CLIENT_NAME

Available clients:
$(ls -1 "$CONFIGS_DIR" | sed 's/^/  - /')

Current client: $(cat "$CURRENT_CLIENT_FILE" 2>/dev/null || echo "none")
EOF
}

switch_client() {
    local client="$1"
    local config_path="$CONFIGS_DIR/$client"
    
    if [ ! -d "$config_path" ]; then
        echo "❌ Error: Client '$client' not found"
        show_usage
        exit 1
    fi
    
    echo "🔄 Switching to client: $client"
    export CLAUDE_HOME="$config_path"
    echo "$client" > "$CURRENT_CLIENT_FILE"
    
    # Load client-specific environment variables
    if [ -f "$config_path/.env" ]; then
        source "$config_path/.env"
    fi
    
    # Show client info
    echo "✅ Active configuration: $config_path"
    echo "📊 Model: $(jq -r '.model // "default"' "$config_path/settings.json" 2>/dev/null)"
    echo "🔐 Auth method: $(jq -r '.forceLoginMethod // "auto"' "$config_path/settings.json" 2>/dev/null)"
    
    # Start Claude Code
    claude "$@"
}

if [ $# -eq 0 ]; then
    show_usage
    exit 0
fi

switch_client "$@"

Make it executable and add to your PATH:

chmod +x claude-switch.sh
sudo mv claude-switch.sh /usr/local/bin/claude-switch

Usage:

# List available clients
claude-switch

# Switch to a specific client
claude-switch client-a

# Switch and run a command
claude-switch client-b "review the latest PR"

Integration with Terminal Workflows

Integrate with tmux for persistent sessions:

# .tmux.conf
bind-key C-a split-window -h "claude-switch client-a"
bind-key C-b split-window -h "claude-switch client-b"
bind-key C-c split-window -h "claude-switch client-c"

Create a project-aware prompt:

# Add to ~/.bashrc or ~/.zshrc
claude_prompt() {
    if [ -n "${CLAUDE_HOME:-}" ]; then
        local client=$(basename "$CLAUDE_HOME")
        echo " 🤖$client"
    fi
}

PS1='$(claude_prompt) \u@\h:\w\$ '

VS Code integration:

Create `.vscode/tasks.json` in each client project:

{
  "version": "2.0.0",
  "tasks": 
    {
      "label": "Claude Code - Client A",
      "type": "shell",
      "command": "CLAUDE_HOME=$HOME/.claude-configs/client-a claude",
      "problemMatcher": [,
      "presentation": {
        "reveal": "always",
        "panel": "new"
      }
    }
  
}

Advanced Automation: Git Hook Integration

Automatically switch Claude Code configurations based on the git repository:

#!/bin/bash
# .git/hooks/post-checkout

# Detect client from remote URL
REMOTE_URL=$(git config --get remote.origin.url)

case "$REMOTE_URL" in
    *client-a*)
        export CLAUDE_HOME="$HOME/.claude-configs/client-a"
        echo "🔵 Auto-configured for Client A"
        ;;
    *client-b*)
        export CLAUDE_HOME="$HOME/.claude-configs/client-b"
        echo "🟢 Auto-configured for Client B"
        ;;
    *client-c*)
        export CLAUDE_HOME="$HOME/.claude-configs/client-c"
        echo "🟡 Auto-configured for Client C"
        ;;
esac

Advanced Configuration: Client-Specific Customization

Custom Instructions per Client

Each client has unique coding standards, frameworks, and workflows. Use CLAUDE.md files to codify these:

# Client A: React + TypeScript + Tailwind
cat > ~/projects/client-a/CLAUDE.md << 'EOF'
# Client A Development Standards

## Tech Stack
- React 18 with TypeScript
- Tailwind CSS for styling
- Vitest for testing
- Conventional Commits

## Code Style
- Use functional components with hooks
- Prefer named exports
- Always include PropTypes or TypeScript interfaces
- Maximum function length: 50 lines

## Testing Requirements
- Minimum 80% code coverage
- Test user interactions, not implementation details
- Use React Testing Library patterns

## Git Workflow
- Branch naming: feature/TICKET-description
- Commit messages: type(scope): description
- Always squash merge to main
EOF

MCP Server Configurations per Client

Different clients need different tool integrations. Configure MCP servers per client:

Client A: E-commerce focus

{
  "mcpServers": {
    "shopify": {
      "command": "npx",
      "args": "-y", "@shopify/mcp-server",
      "env": {
        "SHOPIFY_API_KEY": "${CLIENT_A_SHOPIFY_KEY}"
      }
    },
    "stripe": {
      "command": "npx",
      "args": "-y", "@stripe/mcp-server",
      "env": {
        "STRIPE_API_KEY": "${CLIENT_A_STRIPE_KEY}"
      }
    }
  }
}

Client B: Content marketing focus

{
  "mcpServers": {
    "wordpress": {
      "command": "npx",
      "args": "-y", "@wordpress/mcp-server",
      "env": {
        "WP_API_URL": "https://client-b-blog.com/wp-json"
      }
    },
    "analytics": {
      "command": "npx",
      "args": "-y", "@google/analytics-mcp",
      "env": {
        "GA_PROPERTY_ID": "${CLIENT_B_GA_ID}"
      }
    }
  }
}

Hooks for Client-Specific Workflows

Automate repetitive tasks with client-specific hooks:

{
  "hooks": {
    "afterEdit": {
      "command": "npm run format && npm run lint:fix"
    },
    "beforeCommit": {
      "command": "npm test -- --changed"
    },
    "afterCommit": {
      "command": "curl -X POST https://client-a-webhook.com/notify -d '{\"event\": \"commit\", \"user\": \"${USER}\"}'"
    }
  }
}

Enterprise-Grade Multi-Client Management

Managed Settings for Agency-Wide Standards

For agencies managing dozens of clients, use managed settings to enforce baseline security and compliance:

{
  "allowManagedPermissionRulesOnly": true,
  "permissions": {
    "deny": 
      "Bash(rm -rf *)",
      "Bash(curl *)",
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)"
    
  },
  "strictKnownMarketplaces": true,
  "allowedHttpHookUrls": 
    "https://*.youragency.com/*",
    "https://approved-webhooks.com/*"
  ,
  "cleanupPeriodDays": 30
}

Deploy via:

• macOS: Configuration profiles through MDM
• Windows: Group Policy or Intune
• Linux: /etc/claude-code/managed-settings.json

Team Collaboration Patterns

Pattern 1: Shared project settings, personal local overrides

client-a-project/
├── .claude/
│   ├── settings.json          # Team-shared (committed)
│   └── settings.local.json    # Personal (gitignored)
├── CLAUDE.md                   # Client standards (committed)
└── .mcp.json                   # Project MCP servers (committed)

Pattern 2: User-level agency defaults

// ~/.claude/settings.json
{
  "companyAnnouncements": 
    "Remember: All client work requires code review before deployment",
    "Security reminder: Never commit API keys or credentials"
  ,
  "permissions": {
    "deny": 
      "Read(.env*)",
      "Read(**/secrets/**)"
    
  }
}

Billing and Usage Tracking

Track Claude Code usage per client for accurate billing:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://metrics.youragency.com",
    "OTEL_RESOURCE_ATTRIBUTES": "client.id=client-a,project.name=website-redesign"
  },
  "otelHeadersHelper": "/usr/local/bin/generate-billing-headers.sh"
}

Platform-Specific Considerations

macOS-Specific Tips

Use launchd for automatic configuration:

<!-- ~/Library/LaunchAgents/com.youragency.claude-client-a.plist -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.youragency.claude-client-a</string>
    <key>EnvironmentVariables</key>
    <dict>
        <key>CLAUDE_HOME</key>
        <string>/Users/yourname/.claude-configs/client-a</string>
    </dict>
</dict>
</plist>

Windows-Specific Tips

PowerShell profile for automatic loading:

# $PROFILE (Microsoft.PowerShell_profile.ps1)

# Define client configurations
$script:ClaudeClients = @{
    "client-a" = "$env:USERPROFILE\.claude-configs\client-a"
    "client-b" = "$env:USERPROFILE\.claude-configs\client-b"
    "client-c" = "$env:USERPROFILE\.claude-configs\client-c"
}

# Auto-detect based on current directory
function Initialize-ClaudeConfig {
    $currentPath = Get-Location
    
    foreach ($client in $script:ClaudeClients.Keys) {
        if ($currentPath -like "*\$client\*") {
            $env:CLAUDE_HOME = $script:ClaudeClients$client
            Write-Host "🤖 Configured for $client" -ForegroundColor Cyan
            return
        }
    }
}

# Run on every directory change
$ExecutionContext.InvokeCommand.LocationChangedAction = {
    Initialize-ClaudeConfig
}

Linux/WSL Considerations

Systemd user service for background configuration:

ini
# ~/.config/systemd/user/claude-client-a.service
Unit
Description=Claude Code Client A Configuration

Service
Type=oneshot
Environment="CLAUDE_HOME=%h/.claude-configs/client-a"
ExecStart=/usr/local/bin/claude-switch client-a

Install
WantedBy=default.target

Best Practices Summary

Do's

• ✅ Use separate configuration directories for each client to ensure complete isolation
• ✅ Leverage project-scoped settings (.claude/settings.json) for team-shared configurations
• ✅ Implement the apiKeyHelper pattern for secure, dynamic credential management
• ✅ Create shell aliases or scripts for quick context switching
• ✅ Use managed settings to enforce agency-wide security policies
• ✅ Document client-specific standards in CLAUDE.md files
• ✅ Set up audit logging for compliance-sensitive clients
• ✅ Test configurations in isolation before deploying to production

Don'ts

• ❌ Never hardcode API keys in configuration files
• ❌ Don't share configuration directories between clients
• ❌ Avoid running multiple instances with the same CLAUDE_HOME
• ❌ Don't commit .claude/settings.local.json to version control
• ❌ Never allow unrestricted file system access in client configurations
• ❌ Don't skip authentication isolation between client accounts
• ❌ Avoid mixing client contexts in the same terminal session

Conclusion

Setting up multiple Claude Code accounts for marketing agency client management doesn't have to be complicated. By leveraging Claude Code's configuration scope system, environment variables, and project-level settings, you can create isolated, secure, and efficient workflows for each client.

The key is understanding the hierarchy: managed settings for agency-wide policies, user settings for personal preferences, project settings for team collaboration, and local settings for individual overrides. Combined with intelligent automation through shell scripts and git hooks, you can switch between client contexts in seconds while maintaining the highest security standards.

Whether you're managing two clients or twenty, this systematic approach ensures:

• Complete data isolation between client projects
• Secure credential management without hardcoded secrets
• Efficient context switching with minimal cognitive overhead
• Compliance-ready audit trails for regulated industries
• Team collaboration without sacrificing individual productivity

Start with the basic configuration scope approach, add environment variable automation as you scale, and implement enterprise-grade managed settings when handling sensitive client work. Your agency's multi-client Claude Code setup will become a competitive advantage—freeing your team to focus on delivering exceptional results instead of wrestling with configuration management.

FAQs

What is Claude Code and how does it benefit marketing agencies?

Claude Code is an AI-powered development tool designed to streamline workflows for marketing agencies. It allows for the creation of isolated environments for each client, enhancing security, data privacy, and productivity by preventing context switching issues and credential leakage.

How do I set up multiple Claude Code configurations for different clients?

To set up multiple Claude Code configurations, create separate configuration directories for each client, such as ~/.claude-configs/client-name/. This ensures complete isolation of settings, credentials, and session history for each client project.

What is the scope system in Claude Code?

The scope system in Claude Code organizes settings into four hierarchical levels: Managed, User, Project, and Local. This hierarchy allows more specific settings to override broader ones, ensuring tailored configurations for different use cases.

How can I manage API keys securely in Claude Code?

Avoid hardcoding API keys in configuration files. Instead, use apiKeyHelper scripts or secure environment variables to dynamically manage authentication credentials, ensuring they remain confidential and client-specific.

What measures can I take to prevent cross-client data access?

Implement strict permission rules in your Claude Code configurations to deny access to unauthorized files. Use the permissions system to enforce boundaries, ensuring that one client’s data cannot be accessed from another’s environment.

How can I automate client configuration switching in Claude Code?

You can automate client configuration switching by creating shell scripts or aliases that set the CLAUDE_HOME environment variable based on the current working directory. This allows for quick context switching without manual reconfiguration.

What are the best practices for managing multiple Claude Code sessions?

Best practices include using separate configuration directories for each client, setting up unique authentication methods, implementing audit logging for compliance, and maintaining clear documentation of client-specific standards in a CLAUDE.md file.

How do I ensure compliance with data privacy regulations while using Claude Code?

To ensure compliance, maintain clear separation of client data, use secure credential management practices, enable audit logging for tracking, and adhere to industry-specific regulations through proper configuration and settings management.