How to Back Up Your Mac to S3 Storage: Complete Guide (2025)

Time Machine is great for local backups, but what happens if your Mac and backup drive are both destroyed in a fire, flood, or theft? Off-site backup to S3 storage gives you disaster-proof protection for your irreplaceable files.

This guide covers three methods to back up your Mac to S3-compatible storage: Arq Backup (best GUI experience), rclone (free and powerful), and Restic (encrypted and deduplicated).

Why Back Up Your Mac to S3?

What You'll Need

• macOS 10.15 (Catalina) or newer
• S3-compatible storage credentials:
  • Endpoint URL: s3.danubedata.com
  • Access Key ID
  • Secret Access Key
  • Bucket name

Method 1: Arq Backup (Recommended for Most Users)

Arq Backup ($49.99/year or $4.99/month subscription) is the gold standard for Mac backups to cloud storage. It offers a native macOS experience with client-side encryption, versioning, and smart scheduling.

Key Features:

• Client-side encryption (only you can decrypt)
• Deduplication (saves storage space)
• Incremental backups (fast after initial backup)
• Multiple backup targets
• Network-aware scheduling
• Detailed backup verification

Step 1: Install Arq Backup

1. Download from arqbackup.com
2. Open the DMG and drag Arq to Applications
3. Launch Arq and complete the setup wizard

Step 2: Add S3 Storage Location

1. Click Arq menu → Preferences
2. Go to Storage Locations tab
3. Click + → S3-Compatible
4. Configure the connection:

# Arq S3-Compatible Configuration
Server: s3.danubedata.com
Port: 443
Use SSL: Yes (checked)
Signature Version: Version 4

Access Key ID: YOUR_ACCESS_KEY
Secret Access Key: YOUR_SECRET_ACCESS_KEY

Bucket Name: your-backup-bucket
Path: /mac-backups (or leave empty for root)
Storage Class: Standard

5. Click Test Connection
6. Click Save

Step 3: Create Backup Plan

1. Go to Backup Plans tab
2. Click + to create new plan
3. Name it "Mac Full Backup"
4. Select your S3 storage location
5. Create an encryption password (store this safely!)

Step 4: Select What to Back Up

Click Select Files and choose folders:

# Essential folders to back up
✓ ~/Documents          - All your documents
✓ ~/Desktop            - Desktop files
✓ ~/Pictures           - Photos (if not using iCloud Photos)
✓ ~/Movies             - Video files
✓ ~/Music              - Music library
✓ ~/Downloads          - Downloaded files
✓ ~/Projects           - Development projects (if applicable)

# Optional but recommended
✓ ~/Library/Application Support  - App data and preferences
✓ ~/.ssh                         - SSH keys (encrypted!)
✓ ~/.zshrc, ~/.bashrc           - Shell configurations

# Folders to EXCLUDE
✗ ~/Library/Caches              - Temporary files
✗ ~/.Trash                       - Trash
✗ ~/Library/Application Support/MobileSync  - iOS backups (huge)
✗ node_modules (everywhere)     - Recreatable
✗ .git (optionally)             - Can be large

Step 5: Configure Schedule

# Recommended schedule settings
Backup interval: Hourly
Pause backups when: On battery power
Network: Back up only on these networks: [Your home WiFi]
Throttle upload: 50% of available bandwidth (adjust as needed)

Step 6: Set Retention Policy

# Recommended retention
Keep all backups for: 7 days
After that, keep: 1 backup per day for 30 days
After that, keep: 1 backup per week for 6 months
After that, keep: 1 backup per month forever

Step 7: Run First Backup

1. Click Back Up Now
2. Initial backup may take hours/days depending on data size
3. Check progress in the Arq menu bar icon

Method 2: Rclone (Free, Powerful)

Rclone is a free, open-source command-line tool that syncs files to S3 and 50+ other cloud storage providers. It's extremely powerful and scriptable.

Step 1: Install Rclone

# Using Homebrew (recommended)
brew install rclone

# Or download directly
curl https://rclone.org/install.sh | sudo bash

# Verify installation
rclone version

Step 2: Configure Rclone

# Start interactive configuration
rclone config

# Follow these prompts:
n) New remote
name> danubedata
Storage> s3
provider> Other
env_auth> false
access_key_id> YOUR_ACCESS_KEY_ID
secret_access_key> YOUR_SECRET_ACCESS_KEY
region> eu-central-1
endpoint> https://s3.danubedata.com
location_constraint> (leave empty, press Enter)
acl> private
Edit advanced config?> n
Keep this remote?> y
q) Quit config

Step 3: Test Connection

# List buckets
rclone lsd danubedata:

# List contents of bucket
rclone ls danubedata:your-bucket

# Create a test file
echo "test" > /tmp/test.txt
rclone copy /tmp/test.txt danubedata:your-bucket/test/
rclone ls danubedata:your-bucket/test/

Step 4: Basic Backup Commands

# Sync Documents folder (mirror - deletes removed files from destination)
rclone sync ~/Documents danubedata:your-bucket/mac/documents --progress

# Copy Documents folder (doesn't delete from destination)
rclone copy ~/Documents danubedata:your-bucket/mac/documents --progress

# Backup with bandwidth limit (10 MB/s)
rclone sync ~/Documents danubedata:your-bucket/mac/documents 
  --bwlimit 10M 
  --progress

# Backup with exclusions
rclone sync ~/Documents danubedata:your-bucket/mac/documents 
  --exclude ".DS_Store" 
  --exclude "*.tmp" 
  --exclude ".Trash/**" 
  --progress

# Dry run (see what would be uploaded without actually uploading)
rclone sync ~/Documents danubedata:your-bucket/mac/documents --dry-run

Step 5: Create Backup Script

# Create backup script
cat > ~/backup-mac.sh << 'EOF'
#!/bin/bash
# Mac to S3 Backup Script

BUCKET="your-bucket"
LOG_FILE="$HOME/Library/Logs/rclone-backup.log"
DATE=$(date "+%Y-%m-%d %H:%M:%S")

echo "=== Backup started: $DATE ===" >> "$LOG_FILE"

# Backup Documents
echo "Backing up Documents..." >> "$LOG_FILE"
rclone sync "$HOME/Documents" "danubedata:$BUCKET/mac/documents" 
  --exclude ".DS_Store" 
  --exclude "*.tmp" 
  --log-file="$LOG_FILE" 
  --log-level INFO

# Backup Desktop
echo "Backing up Desktop..." >> "$LOG_FILE"
rclone sync "$HOME/Desktop" "danubedata:$BUCKET/mac/desktop" 
  --exclude ".DS_Store" 
  --log-file="$LOG_FILE" 
  --log-level INFO

# Backup Pictures (if not using iCloud Photos)
echo "Backing up Pictures..." >> "$LOG_FILE"
rclone sync "$HOME/Pictures" "danubedata:$BUCKET/mac/pictures" 
  --exclude ".DS_Store" 
  --exclude "Photos Library.photoslibrary/**" 
  --log-file="$LOG_FILE" 
  --log-level INFO

# Backup Projects (development folders)
if [ -d "$HOME/Projects" ]; then
  echo "Backing up Projects..." >> "$LOG_FILE"
  rclone sync "$HOME/Projects" "danubedata:$BUCKET/mac/projects" 
    --exclude ".DS_Store" 
    --exclude "node_modules/**" 
    --exclude "vendor/**" 
    --exclude ".git/**" 
    --exclude "*.log" 
    --log-file="$LOG_FILE" 
    --log-level INFO
fi

# Backup SSH keys and shell configs
echo "Backing up configs..." >> "$LOG_FILE"
rclone copy "$HOME/.ssh" "danubedata:$BUCKET/mac/configs/ssh" 
  --log-file="$LOG_FILE" 
  --log-level INFO
rclone copy "$HOME/.zshrc" "danubedata:$BUCKET/mac/configs/" 
  --log-file="$LOG_FILE" 
  --log-level INFO

echo "=== Backup completed: $(date "+%Y-%m-%d %H:%M:%S") ===" >> "$LOG_FILE"

# macOS notification
osascript -e 'display notification "Mac backup to S3 completed successfully" with title "Backup Complete"'
EOF

# Make executable
chmod +x ~/backup-mac.sh

# Test the script
~/backup-mac.sh

Step 6: Automate with launchd

Create a Launch Agent to run backups automatically:

# Create Launch Agent plist
cat > ~/Library/LaunchAgents/com.rclone.backup.plist << 'EOF'
<?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.rclone.backup</string>

    <key>ProgramArguments</key>
    <array>
        <string>/bin/bash</string>
        <string>-c</string>
        <string>$HOME/backup-mac.sh</string>
    </array>

    <key>StartCalendarInterval</key>
    <dict>
        <key>Hour</key>
        <integer>3</integer>
        <key>Minute</key>
        <integer>0</integer>
    </dict>

    <key>StandardOutPath</key>
    <string>/tmp/rclone-backup-stdout.log</string>

    <key>StandardErrorPath</key>
    <string>/tmp/rclone-backup-stderr.log</string>

    <key>RunAtLoad</key>
    <false/>
</dict>
</plist>
EOF

# Fix the HOME variable issue
sed -i '' "s|$HOME|$HOME|g" ~/Library/LaunchAgents/com.rclone.backup.plist

# Load the Launch Agent
launchctl load ~/Library/LaunchAgents/com.rclone.backup.plist

# Check if it's loaded
launchctl list | grep rclone

# To run manually
launchctl start com.rclone.backup

# To unload (stop scheduling)
launchctl unload ~/Library/LaunchAgents/com.rclone.backup.plist

Method 3: Restic (Encrypted & Deduplicated)

Restic is a modern backup program with built-in encryption, deduplication, and integrity verification. It's ideal if security is your top priority.

Step 1: Install Restic

# Using Homebrew
brew install restic

# Verify installation
restic version

Step 2: Configure Environment Variables

# Add to ~/.zshrc or ~/.bashrc
export AWS_ACCESS_KEY_ID="YOUR_ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_SECRET_KEY"
export RESTIC_REPOSITORY="s3:https://s3.danubedata.com/your-bucket/mac-restic"
export RESTIC_PASSWORD="your-strong-encryption-password"

# Reload shell
source ~/.zshrc

Step 3: Initialize Repository

# Initialize (first time only)
restic init

# You should see:
# created restic repository at s3:https://s3.danubedata.com/your-bucket/mac-restic

Step 4: Run Backups

# Backup home directory
restic backup ~

# Backup specific folders
restic backup ~/Documents ~/Desktop ~/Pictures

# Backup with exclusions
restic backup ~ 
  --exclude="Library/Caches" 
  --exclude=".Trash" 
  --exclude="node_modules" 
  --exclude=".git" 
  --exclude="*.log" 
  --verbose

# Backup with tags
restic backup ~/Documents --tag documents --tag mac

# View all snapshots
restic snapshots

# View snapshots with specific tag
restic snapshots --tag documents

Step 5: Create Automated Backup Script

#!/bin/bash
# ~/restic-backup.sh

export AWS_ACCESS_KEY_ID="YOUR_ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_SECRET_KEY"
export RESTIC_REPOSITORY="s3:https://s3.danubedata.com/your-bucket/mac-restic"
export RESTIC_PASSWORD="your-strong-encryption-password"

LOG_FILE="$HOME/Library/Logs/restic-backup.log"

echo "=== Restic backup started: $(date) ===" >> "$LOG_FILE"

# Run backup
restic backup 
  "$HOME/Documents" 
  "$HOME/Desktop" 
  "$HOME/Pictures" 
  "$HOME/.ssh" 
  --exclude=".DS_Store" 
  --exclude="*.tmp" 
  --exclude="Library/Caches/**" 
  --exclude="node_modules/**" 
  --verbose 
  2>&1 | tee -a "$LOG_FILE"

# Clean up old snapshots
restic forget 
  --keep-hourly 24 
  --keep-daily 7 
  --keep-weekly 4 
  --keep-monthly 12 
  --prune 
  2>&1 | tee -a "$LOG_FILE"

# Verify integrity (weekly)
if [ $(date +%u) -eq 7 ]; then
  echo "Running integrity check..." >> "$LOG_FILE"
  restic check 2>&1 | tee -a "$LOG_FILE"
fi

echo "=== Backup completed: $(date) ===" >> "$LOG_FILE"

# Notification
osascript -e 'display notification "Restic backup completed" with title "Backup Complete"'

Restoring from Restic

# List all snapshots
restic snapshots

# Restore entire snapshot
restic restore latest --target ~/restored

# Restore specific folder
restic restore latest --target ~/restored --include "/Documents"

# Restore specific file
restic restore latest --target ~/restored --include "/Documents/important.pdf"

# Mount backup as filesystem (browse backups)
mkdir ~/mnt
restic mount ~/mnt
# Now browse ~/mnt/snapshots/
# Unmount when done: umount ~/mnt

Method 4: Cyberduck (GUI for Manual Backups)

For occasional manual uploads, Cyberduck provides a simple drag-and-drop interface.

1. Download from cyberduck.io
2. Click Open Connection
3. Select Amazon S3
4. Configure:

Server: s3.danubedata.com
Port: 443
Access Key ID: YOUR_ACCESS_KEY
Secret Access Key: YOUR_SECRET_KEY

5. Navigate to your bucket
6. Drag and drop files to upload

Which Mac Folders to Back Up

Best Practices for Mac Backups

1. Use the 3-2-1 Rule

Keep 3 copies of data, on 2 different media types, with 1 off-site. Time Machine + S3 = perfect combination.

2. Encrypt Sensitive Data

Use Arq or Restic's built-in encryption for sensitive files. Never store unencrypted SSH keys or passwords in the cloud.

3. Exclude Unnecessary Files

# Common exclusions to save space
.DS_Store
*.tmp
*.log
node_modules/
vendor/
.git/
Library/Caches/
.Trash/

4. Test Restores Regularly

A backup you can't restore is worthless. Test monthly:

# Rclone restore test
rclone copy danubedata:your-bucket/mac/documents/test.txt /tmp/

# Restic restore test
restic restore latest --target /tmp/restore-test --include "/Documents/test.txt"

5. Monitor Backup Status

Check logs regularly and set up notifications for failures.

Comparison: Which Method Should You Use?

Get Started with DanubeData

Ready to protect your Mac with off-site S3 backups?

1. Create a DanubeData account
2. Create a storage bucket for backups
3. Generate access keys
4. Choose your backup method and follow this guide

👉 Create Your Backup Bucket - €3.99/month includes 1TB storage

Your Mac contains years of work and memories. Don't trust it all to a single hard drive.

Need help setting up Mac backups? Contact our team for personalized assistance.